2 // MD5 message-digest algorithm
3 // Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights reserved.
5 // C++/object oriented translation and modification:
6 // Copyright (C) 1995 Mordechai T. Abzug
8 // Further adaptations for SuperTux:
9 // Copyright (C) 2008 Christoph Sommer <christoph.sommer@2008.expires.deltadevelopment.de>
11 // This translation/modification is provided "as is," without express or
12 // implied warranty of any kind.
14 // The translators/modifiers do not claim:
15 // (1) that MD5 will do what you think it does;
16 // (2) that this translation/ modification is accurate; or
17 // (3) that this software is "merchantible."
21 // MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
22 // MDDRIVER.C - test driver for MD2, MD4 and MD5
23 // Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights reserved.
25 // License to copy and use this software is granted provided that it
26 // is identified as the "RSA Data Security, Inc. MD5 Message-Digest
27 // Algorithm" in all material mentioning or referencing this software
30 // License is also granted to make and use derivative works provided
31 // that such works are identified as "derived from the RSA Data
32 // Security, Inc. MD5 Message-Digest Algorithm" in all material
33 // mentioning or referencing the derived work.
35 // RSA Data Security, Inc. makes no representations concerning either
36 // the merchantability of this software or the suitability of this
37 // software for any particular purpose. It is provided "as is"
38 // without express or implied warranty of any kind.
40 // These notices must be retained in any copies of any part of this
41 // documentation and/or software.
55 void MD5::update (uint8_t* input, uint32_t input_length) {
57 uint32_t input_index, buffer_index;
58 uint32_t buffer_space; // how much space is left in buffer
60 if (finalized) throw std::runtime_error("MD5::update: Can't update a finalized digest!");
62 // Compute number of bytes mod 64
63 buffer_index = (unsigned int)((count[0] >> 3) & 0x3F);
65 // Update number of bits
66 if ( (count[0] += ((uint32_t) input_length << 3))<((uint32_t) input_length << 3) ) count[1]++;
68 count[1] += ((uint32_t)input_length >> 29);
71 buffer_space = 64 - buffer_index; // how much space is left in buffer
73 // Transform as many times as possible.
74 if (input_length >= buffer_space) { // ie. we have enough to fill the buffer
75 // fill the rest of the buffer and transform
76 memcpy (buffer + buffer_index, input, buffer_space);
79 // now, transform each 64-byte piece of the input, bypassing the buffer
80 for (input_index = buffer_space; input_index + 63 < input_length;
82 transform (input+input_index);
84 buffer_index = 0; // so we can buffer remaining
86 input_index=0; // so we can buffer the whole input
89 // and here we do the buffering:
90 memcpy(buffer+buffer_index, input+input_index, input_length-input_index);
93 void MD5::update(FILE *file) {
97 while ((len=fread(buffer, 1, 1024, file))) update(buffer, len);
102 void MD5::update(std::istream& stream) {
103 uint8_t buffer[1024];
106 while (stream.good()) {
107 stream.read((char*)buffer, 1024); // note that return value of read is unusable.
113 void MD5::update(std::ifstream& stream) {
114 uint8_t buffer[1024];
117 while (stream.good()) {
118 stream.read((char*)buffer, 1024); // note that return value of read is unusable.
125 MD5::MD5(FILE *file) {
126 init(); // must be called be all constructors
131 MD5::MD5(std::istream& stream) {
132 init(); // must called by all constructors
137 MD5::MD5(std::ifstream& stream) {
138 init(); // must called by all constructors
143 uint8_t* MD5::raw_digest() {
144 uint8_t* s = new uint8_t[16];
148 memcpy(s, digest, 16);
152 std::string MD5::hex_digest() {
154 char* s= new char[33];
158 for (i=0; i<16; i++) sprintf(s+i*2, "%02x", digest[i]);
165 std::ostream& operator<<(std::ostream &stream, MD5 context) {
166 stream << context.hex_digest();
176 // Nothing counted, so count=0
180 // Load magic initialization constants.
181 state[0] = 0x67452301;
182 state[1] = 0xefcdab89;
183 state[2] = 0x98badcfe;
184 state[3] = 0x10325476;
187 void MD5::finalize() {
188 if (finalized) return;
191 unsigned int index, padLen;
192 static uint8_t PADDING[64]={
193 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
194 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
195 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
198 // Save number of bits
199 encode (bits, count, 8);
201 // Pad out to 56 mod 64.
202 index = (uint32_t) ((count[0] >> 3) & 0x3f);
203 padLen = (index < 56) ? (56 - index) : (120 - index);
204 update (PADDING, padLen);
206 // Append length (before padding)
209 // Store state in digest
210 encode (digest, state, 16);
212 // Zeroize sensitive information
213 memset (buffer, 0, sizeof(*buffer));
218 // Constants for MD5Transform routine.
219 // Although we could use C++ style constants, defines are actually better,
220 // since they let us easily evade scope clashes.
239 void MD5::transform (uint8_t block[64]) {
240 uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
242 decode (x, block, 64);
244 assert(!finalized); // not just a user error, since the method is private
247 FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
248 FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
249 FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
250 FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
251 FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
252 FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
253 FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
254 FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
255 FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
256 FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
257 FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
258 FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
259 FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
260 FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
261 FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
262 FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
265 GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
266 GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
267 GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
268 GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
269 GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
270 GG (d, a, b, c, x[10], S22, 0x02441453); /* 22 */
271 GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
272 GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
273 GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
274 GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
275 GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
276 GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
277 GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
278 GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
279 GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
280 GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
283 HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
284 HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
285 HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
286 HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
287 HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
288 HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
289 HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
290 HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
291 HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
292 HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
293 HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
294 HH (b, c, d, a, x[ 6], S34, 0x04881d05); /* 44 */
295 HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
296 HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
297 HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
298 HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
301 II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
302 II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
303 II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
304 II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
305 II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
306 II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
307 II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
308 II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
309 II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
310 II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
311 II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
312 II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
313 II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
314 II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
315 II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
316 II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
323 // Zeroize sensitive information.
324 memset ( (uint8_t* ) x, 0, sizeof(x));
327 void MD5::encode (uint8_t* output, uint32_t* input, uint32_t len) {
330 for (i = 0, j = 0; j < len; i++, j += 4) {
331 output[j] = (uint8_t) (input[i] & 0xff);
332 output[j+1] = (uint8_t) ((input[i] >> 8) & 0xff);
333 output[j+2] = (uint8_t) ((input[i] >> 16) & 0xff);
334 output[j+3] = (uint8_t) ((input[i] >> 24) & 0xff);
338 void MD5::decode (uint32_t* output, uint8_t* input, uint32_t len) {
341 for (i = 0, j = 0; j < len; i++, j += 4) {
342 output[i] = ((uint32_t)input[j]) | (((uint32_t)input[j+1]) << 8) | (((uint32_t)input[j+2]) << 16) | (((uint32_t)input[j+3]) << 24);
346 // Note: Replace "for loop" with standard memcpy if possible.
347 void MD5::memcpy (uint8_t* output, uint8_t* input, uint32_t len) {
350 for (i = 0; i < len; i++) output[i] = input[i];
353 // Note: Replace "for loop" with standard memset if possible.
354 void MD5::memset (uint8_t* output, uint8_t value, uint32_t len) {
357 for (i = 0; i < len; i++) output[i] = value;
360 inline unsigned int MD5::rotate_left(uint32_t x, uint32_t n) {
361 return (x << n) | (x >> (32-n));
364 inline unsigned int MD5::F(uint32_t x, uint32_t y, uint32_t z) {
365 return (x & y) | (~x & z);
368 inline unsigned int MD5::G(uint32_t x, uint32_t y, uint32_t z) {
369 return (x & z) | (y & ~z);
372 inline unsigned int MD5::H(uint32_t x, uint32_t y, uint32_t z) {
376 inline unsigned int MD5::I(uint32_t x, uint32_t y, uint32_t z) {
380 inline void MD5::FF(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) {
381 a += F(b, c, d) + x + ac;
382 a = rotate_left (a, s) +b;
385 inline void MD5::GG(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) {
386 a += G(b, c, d) + x + ac;
387 a = rotate_left (a, s) +b;
390 inline void MD5::HH(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) {
391 a += H(b, c, d) + x + ac;
392 a = rotate_left (a, s) +b;
395 inline void MD5::II(uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) {
396 a += I(b, c, d) + x + ac;
397 a = rotate_left (a, s) +b;