1 /* MD5
2 converted to C++ class by Frank Thilo (thilo@unix-ag.org)
3 for bzflag (http://www.bzflag.org)
4
5 based on:
6
7 md5.h and md5.c
8 reference implemantion of RFC 1321
9
10 Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
11 rights reserved.
12
13 License to copy and use this software is granted provided that it
14 is identified as the "RSA Data Security, Inc. MD5 Message-Digest
15 Algorithm" in all material mentioning or referencing this software
16 or this function.
17
18 License is also granted to make and use derivative works provided
19 that such works are identified as "derived from the RSA Data
20 Security, Inc. MD5 Message-Digest Algorithm" in all material
21 mentioning or referencing the derived work.
22
23 RSA Data Security, Inc. makes no representations concerning either
24 the merchantability of this software or the suitability of this
25 software for any particular purpose. It is provided "as is"
26 without express or implied warranty of any kind.
27
28 These notices must be retained in any copies of any part of this
29 documentation and/or software.
30
31 */
32
33 /* interface header */
34 #include "md5.h"
35
36 /* system implementation headers */
37 #include <cstdio>
38 #include <string>
39
40
41 // Constants for MD5Transform routine.
42 #define S11 7
43 #define S12 12
44 #define S13 17
45 #define S14 22
46 #define S21 5
47 #define S22 9
48 #define S23 14
49 #define S24 20
50 #define S31 4
51 #define S32 11
52 #define S33 16
53 #define S34 23
54 #define S41 6
55 #define S42 10
56 #define S43 15
57 #define S44 21
58
59 ///////////////////////////////////////////////
60
61 // F, G, H and I are basic MD5 functions.
F(uint4 x,uint4 y,uint4 z)62 inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) {
63 return (x&y) | (~x&z);
64 }
65
G(uint4 x,uint4 y,uint4 z)66 inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) {
67 return (x&z) | (y&~z);
68 }
69
H(uint4 x,uint4 y,uint4 z)70 inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) {
71 return x^y^z;
72 }
73
I(uint4 x,uint4 y,uint4 z)74 inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) {
75 return y ^ (x | ~z);
76 }
77
78 // rotate_left rotates x left n bits.
rotate_left(uint4 x,int n)79 inline MD5::uint4 MD5::rotate_left(uint4 x, int n) {
80 return (x << n) | (x >> (32-n));
81 }
82
83 // FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
84 // Rotation is separate from addition to prevent recomputation.
FF(uint4 & a,uint4 b,uint4 c,uint4 d,uint4 x,uint4 s,uint4 ac)85 inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
86 a = rotate_left(a+ F(b,c,d) + x + ac, s) + b;
87 }
88
GG(uint4 & a,uint4 b,uint4 c,uint4 d,uint4 x,uint4 s,uint4 ac)89 inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
90 a = rotate_left(a + G(b,c,d) + x + ac, s) + b;
91 }
92
HH(uint4 & a,uint4 b,uint4 c,uint4 d,uint4 x,uint4 s,uint4 ac)93 inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
94 a = rotate_left(a + H(b,c,d) + x + ac, s) + b;
95 }
96
II(uint4 & a,uint4 b,uint4 c,uint4 d,uint4 x,uint4 s,uint4 ac)97 inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
98 a = rotate_left(a + I(b,c,d) + x + ac, s) + b;
99 }
100
101 //////////////////////////////////////////////
102
103 // default ctor, just initailize
MD5()104 MD5::MD5()
105 {
106 init();
107 }
108
109 //////////////////////////////////////////////
110
111 // nifty shortcut ctor, compute MD5 for string and finalize it right away
MD5(const std::string & text)112 MD5::MD5(const std::string &text)
113 {
114 init();
115 update(text.c_str(), text.length());
116 finalize();
117 }
118
119 //////////////////////////////
120
init()121 void MD5::init()
122 {
123 finalized=false;
124
125 count[0] = 0;
126 count[1] = 0;
127
128 // load magic initialization constants.
129 state[0] = 0x67452301;
130 state[1] = 0xefcdab89;
131 state[2] = 0x98badcfe;
132 state[3] = 0x10325476;
133 }
134
135 //////////////////////////////
136
137 // decodes input (unsigned char) into output (uint4). Assumes len is a multiple of 4.
decode(uint4 output[],const uint1 input[],size_type len)138 void MD5::decode(uint4 output[], const uint1 input[], size_type len)
139 {
140 for (unsigned int i = 0, j = 0; j < len; i++, j += 4)
141 output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
142 (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
143 }
144
145 //////////////////////////////
146
147 // encodes input (uint4) into output (unsigned char). Assumes len is
148 // a multiple of 4.
encode(uint1 output[],const uint4 input[],size_type len)149 void MD5::encode(uint1 output[], const uint4 input[], size_type len)
150 {
151 for (size_type i = 0, j = 0; j < len; i++, j += 4) {
152 output[j] = input[i] & 0xff;
153 output[j+1] = (input[i] >> 8) & 0xff;
154 output[j+2] = (input[i] >> 16) & 0xff;
155 output[j+3] = (input[i] >> 24) & 0xff;
156 }
157 }
158
159 //////////////////////////////
160
161 // apply MD5 algo on a block
transform(const uint1 block[blocksize])162 void MD5::transform(const uint1 block[blocksize])
163 {
164 uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
165 decode (x, block, blocksize);
166
167 /* Round 1 */
168 FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
169 FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
170 FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
171 FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
172 FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
173 FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
174 FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
175 FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
176 FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
177 FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
178 FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
179 FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
180 FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
181 FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
182 FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
183 FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
184
185 /* Round 2 */
186 GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
187 GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
188 GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
189 GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
190 GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
191 GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
192 GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
193 GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
194 GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
195 GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
196 GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
197 GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
198 GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
199 GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
200 GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
201 GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
202
203 /* Round 3 */
204 HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
205 HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
206 HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
207 HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
208 HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
209 HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
210 HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
211 HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
212 HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
213 HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
214 HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
215 HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
216 HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
217 HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
218 HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
219 HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
220
221 /* Round 4 */
222 II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
223 II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
224 II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
225 II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
226 II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
227 II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
228 II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
229 II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
230 II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
231 II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
232 II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
233 II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
234 II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
235 II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
236 II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
237 II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
238
239 state[0] += a;
240 state[1] += b;
241 state[2] += c;
242 state[3] += d;
243
244 // Zeroize sensitive information.
245 memset(x, 0, sizeof x);
246 }
247
248 //////////////////////////////
249
250 // MD5 block update operation. Continues an MD5 message-digest
251 // operation, processing another message block
update(const unsigned char input[],size_type length)252 void MD5::update(const unsigned char input[], size_type length)
253 {
254 // compute number of bytes mod 64
255 size_type index = count[0] / 8 % blocksize;
256
257 // Update number of bits
258 if ((count[0] += (length << 3)) < (length << 3))
259 count[1]++;
260 count[1] += (length >> 29);
261
262 // number of bytes we need to fill in buffer
263 size_type firstpart = 64 - index;
264
265 size_type i;
266
267 // transform as many times as possible.
268 if (length >= firstpart)
269 {
270 // fill buffer first, transform
271 memcpy(&buffer[index], input, firstpart);
272 transform(buffer);
273
274 // transform chunks of blocksize (64 bytes)
275 for (i = firstpart; i + blocksize <= length; i += blocksize)
276 transform(&input[i]);
277
278 index = 0;
279 }
280 else
281 i = 0;
282
283 // buffer remaining input
284 memcpy(&buffer[index], &input[i], length-i);
285 }
286
287 //////////////////////////////
288
289 // for convenience provide a verson with signed char
update(const char input[],size_type length)290 void MD5::update(const char input[], size_type length)
291 {
292 update((const unsigned char*)input, length);
293 }
294
295 //////////////////////////////
296
297 // MD5 finalization. Ends an MD5 message-digest operation, writing the
298 // the message digest and zeroizing the context.
finalize()299 MD5& MD5::finalize()
300 {
301 static unsigned char padding[64] = {
302 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
303 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
304 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
305 };
306
307 if (!finalized) {
308 // Save number of bits
309 unsigned char bits[8];
310 encode(bits, count, 8);
311
312 // pad out to 56 mod 64.
313 size_type index = count[0] / 8 % 64;
314 size_type padLen = (index < 56) ? (56 - index) : (120 - index);
315 update(padding, padLen);
316
317 // Append length (before padding)
318 update(bits, 8);
319
320 // Store state in digest
321 encode(digest, state, 16);
322
323 // Zeroize sensitive information.
324 memset(buffer, 0, sizeof buffer);
325 memset(count, 0, sizeof count);
326
327 finalized=true;
328 }
329
330 return *this;
331 }
332
333 //////////////////////////////
334
335 // return hex representation of digest as string
hexdigest() const336 std::string MD5::hexdigest() const
337 {
338 if (!finalized)
339 return "";
340
341 char buf[33];
342 for (int i=0; i<16; i++)
343 sprintf(buf+i*2, "%02x", digest[i]);
344 buf[32]=0;
345
346 return std::string(buf);
347 }
348
349 //////////////////////////////
350
operator <<(std::ostream & out,MD5 md5)351 std::ostream& operator<<(std::ostream& out, MD5 md5)
352 {
353 return out << md5.hexdigest();
354 }
355
356 //////////////////////////////
357
md5(const std::string str)358 std::string md5(const std::string str)
359 {
360 MD5 md5 = MD5(str);
361
362 return md5.hexdigest();
363 }
364
365