MySQL 5.6.14 Source Code Document
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
md5_hash.cpp
1 /*
2  Copyright (C) 2003-2006 MySQL AB, 2009 Sun Microsystems, Inc.
3  All rights reserved. Use is subject to license terms.
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; version 2 of the License.
8 
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  GNU General Public License for more details.
13 
14  You should have received a copy of the GNU General Public License
15  along with this program; if not, write to the Free Software
16  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 
19 
20 
21 #include "md5_hash.hpp"
22 
23 #ifdef WORDS_BIGENDIAN
24 #define HIGHFIRST 1
25 #endif
26 
27 /*
28  * This code implements the MD5 message-digest algorithm.
29  * The algorithm is due to Ron Rivest. This code was
30  * written by Colin Plumb in 1993, no copyright is claimed.
31  * This code is in the public domain; do with it what you wish.
32  *
33  * Equivalent code is available from RSA Data Security, Inc.
34  * This code has been tested against that, and is equivalent,
35  * except that you don't need to include two pages of legalese
36  * with every copy.
37  *
38  * The code has been modified by Mikael Ronstroem to handle
39  * calculating a hash value of a key that is always a multiple
40  * of 4 bytes long. Word 0 of the calculated 4-word hash value
41  * is returned as the hash value.
42  */
43 
44 #ifndef HIGHFIRST
45 #define byteReverse(buf, len) /* Nothing */
46 #else
47 void byteReverse(unsigned char *buf, unsigned longs);
48 /*
49  * Note: this code is harmless on little-endian machines.
50  */
51 void byteReverse(unsigned char *buf, unsigned longs)
52 {
53  Uint32 t;
54  do {
55  t = (Uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
56  ((unsigned) buf[1] << 8 | buf[0]);
57  *(Uint32 *) buf = t;
58  buf += 4;
59  } while (--longs);
60 }
61 #endif
62 
63 /* The four core functions - F1 is optimized somewhat */
64 
65 /* #define F1(x, y, z) (x & y | ~x & z) */
66 #define F1(x, y, z) (z ^ (x & (y ^ z)))
67 #define F2(x, y, z) F1(z, x, y)
68 #define F3(x, y, z) (x ^ y ^ z)
69 #define F4(x, y, z) (y ^ (x | ~z))
70 
71 /* This is the central step in the MD5 algorithm. */
72 #define MD5STEP(f, w, x, y, z, data, s) \
73  ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
74 
75 /*
76  * The core of the MD5 algorithm, this alters an existing MD5 hash to
77  * reflect the addition of 16 longwords of new data. MD5Update blocks
78  * the data and converts bytes into longwords for this routine.
79  */
80 static void MD5Transform(Uint32 buf[4], Uint32 const in[16])
81 {
82  register Uint32 a, b, c, d;
83 
84  a = buf[0];
85  b = buf[1];
86  c = buf[2];
87  d = buf[3];
88 
89  MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
90  MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
91  MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
92  MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
93  MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
94  MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
95  MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
96  MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
97  MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
98  MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
99  MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
100  MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
101  MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
102  MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
103  MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
104  MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
105 
106  MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
107  MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
108  MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
109  MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
110  MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
111  MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
112  MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
113  MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
114  MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
115  MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
116  MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
117  MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
118  MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
119  MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
120  MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
121  MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
122 
123  MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
124  MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
125  MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
126  MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
127  MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
128  MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
129  MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
130  MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
131  MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
132  MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
133  MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
134  MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
135  MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
136  MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
137  MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
138  MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
139 
140  MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
141  MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
142  MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
143  MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
144  MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
145  MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
146  MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
147  MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
148  MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
149  MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
150  MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
151  MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
152  MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
153  MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
154  MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
155  MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
156 
157  buf[0] += a;
158  buf[1] += b;
159  buf[2] += c;
160  buf[3] += d;
161 }
162 
163 /*
164  * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
165  * initialization constants.
166  */
167 void md5_hash(Uint32 result[4], const Uint64* keybuf, Uint32 no_of_32_words)
168 {
174  Uint32 i;
175  Uint32 buf[4];
176  union {
177  Uint64 transform64_buf[8];
178  Uint32 transform32_buf[16];
179  };
180  Uint32 len = no_of_32_words << 2;
181  const Uint64* key64buf = (const Uint64*)keybuf;
182  const Uint32* key32buf = (const Uint32*)keybuf;
183 
184  buf[0] = 0x67452301;
185  buf[1] = 0xefcdab89;
186  buf[2] = 0x98badcfe;
187  buf[3] = 0x10325476;
188 
189  while (no_of_32_words >= 16) {
190  transform64_buf[0] = key64buf[0];
191  transform64_buf[1] = key64buf[1];
192  transform64_buf[2] = key64buf[2];
193  transform64_buf[3] = key64buf[3];
194  transform64_buf[4] = key64buf[4];
195  transform64_buf[5] = key64buf[5];
196  transform64_buf[6] = key64buf[6];
197  transform64_buf[7] = key64buf[7];
198  no_of_32_words -= 16;
199  key64buf += 8;
200  byteReverse((unsigned char *)transform32_buf, 16);
201  MD5Transform(buf, transform32_buf);
202  }
203 
204  key32buf = (const Uint32*)key64buf;
205  transform64_buf[0] = 0;
206  transform64_buf[1] = 0;
207  transform64_buf[2] = 0;
208  transform64_buf[3] = 0;
209  transform64_buf[4] = 0;
210  transform64_buf[5] = 0;
211  transform64_buf[6] = 0;
212  transform64_buf[7] = (Uint64)len;
213 
214  for (i = 0; i < no_of_32_words; i++)
215  transform32_buf[i] = key32buf[i];
216  transform32_buf[no_of_32_words] = 0x80000000;
217 
218  if (no_of_32_words < 14) {
219  byteReverse((unsigned char *)transform32_buf, 16);
220  MD5Transform(buf, transform32_buf);
221  } else {
222  if (no_of_32_words == 14)
223  transform32_buf[15] = 0;
224  MD5Transform(buf, transform32_buf);
225  transform64_buf[0] = 0;
226  transform64_buf[1] = 0;
227  transform64_buf[2] = 0;
228  transform64_buf[3] = 0;
229  transform64_buf[4] = 0;
230  transform64_buf[5] = 0;
231  transform64_buf[6] = 0;
232  transform64_buf[7] = (Uint64)len;
233  byteReverse((unsigned char *)transform32_buf, 16);
234  MD5Transform(buf, transform32_buf);
235  }
236 
237  result[0] = buf[0];
238  result[1] = buf[1];
239  result[2] = buf[2];
240  result[3] = buf[3];
241 }
242