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.
44 #include "addon/md5.hpp"
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);
70 buffer_space = 64 - buffer_index; // how much space is left in buffer
72 // Transform as many times as possible.
73 if (input_length >= buffer_space) { // ie. we have enough to fill the buffer
74 // fill the rest of the buffer and transform
75 memcpy (buffer + buffer_index, input, buffer_space);
78 // now, transform each 64-byte piece of the input, bypassing the buffer
79 for (input_index = buffer_space; input_index + 63 < input_length;
81 transform (input+input_index);
83 buffer_index = 0; // so we can buffer remaining
85 input_index=0; // so we can buffer the whole input
87 // and here we do the buffering:
88 memcpy(buffer+buffer_index, input+input_index, input_length-input_index);
91 void MD5::update(FILE *file) {
92 uint8_t buffer_[1024];
95 while ((len=fread(buffer_, 1, 1024, file))) update(buffer_, len);
100 void MD5::update(std::istream& stream) {
101 uint8_t buffer_[1024];
104 while (stream.good()) {
105 stream.read((char*)buffer_, 1024); // note that return value of read is unusable.
107 update(buffer_, len);
111 void MD5::update(std::ifstream& stream) {
112 uint8_t buffer_[1024];
115 while (stream.good()) {
116 stream.read((char*)buffer_, 1024); // note that return value of read is unusable.
118 update(buffer_, len);
122 MD5::MD5(FILE *file) :
125 init(); // must be called be all constructors
130 MD5::MD5(std::istream& stream) :
133 init(); // must called by all constructors
138 MD5::MD5(std::ifstream& stream) :
141 init(); // must called by all constructors
146 uint8_t* MD5::raw_digest() {
147 uint8_t* s = new uint8_t[16];
151 memcpy(s, digest, 16);
155 std::string MD5::hex_digest() {
157 char* s= new char[33];
161 for (i=0; i<16; i++) sprintf(s+i*2, "%02x", digest[i]);
168 std::ostream& operator<<(std::ostream &stream, MD5 context) {
169 stream << context.hex_digest();
178 // Nothing counted, so count=0
182 // Load magic initialization constants.
183 state[0] = 0x67452301;
184 state[1] = 0xefcdab89;
185 state[2] = 0x98badcfe;
186 state[3] = 0x10325476;
189 void MD5::finalize() {
190 if (finalized) return;
193 unsigned int index, padLen;
194 static uint8_t PADDING[64]={
195 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
196 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
197 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
200 // Save number of bits
201 encode (bits, count, 8);
203 // Pad out to 56 mod 64.
204 index = (uint32_t) ((count[0] >> 3) & 0x3f);
205 padLen = (index < 56) ? (56 - index) : (120 - index);
206 update (PADDING, padLen);
208 // Append length (before padding)
211 // Store state in digest
212 encode (digest, state, 16);
214 // Zeroize sensitive information
215 memset (buffer, 0, sizeof(*buffer));
220 // Constants for MD5Transform routine.
221 // Although we could use C++ style constants, defines are actually better,
222 // since they let us easily evade scope clashes.
241 void MD5::transform (uint8_t block[64]) {
242 uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
244 decode (x, block, 64);
246 assert(!finalized); // not just a user error, since the method is private
249 FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
250 FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
251 FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
252 FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
253 FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
254 FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
255 FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
256 FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
257 FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
258 FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
259 FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
260 FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
261 FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
262 FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
263 FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
264 FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
267 GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
268 GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
269 GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
270 GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
271 GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
272 GG (d, a, b, c, x[10], S22, 0x02441453); /* 22 */
273 GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
274 GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
275 GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
276 GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
277 GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
278 GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
279 GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
280 GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
281 GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
282 GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
285 HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
286 HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
287 HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
288 HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
289 HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
290 HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
291 HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
292 HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
293 HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
294 HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
295 HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
296 HH (b, c, d, a, x[ 6], S34, 0x04881d05); /* 44 */
297 HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
298 HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
299 HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
300 HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
303 II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
304 II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
305 II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
306 II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
307 II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
308 II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
309 II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
310 II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
311 II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
312 II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
313 II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
314 II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
315 II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
316 II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
317 II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
318 II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
325 // Zeroize sensitive information.
326 memset ( (uint8_t* ) x, 0, sizeof(x));
329 void MD5::encode (uint8_t* output, uint32_t* input, uint32_t len) {
332 for (i = 0, j = 0; j < len; i++, j += 4) {
333 output[j] = (uint8_t) (input[i] & 0xff);
334 output[j+1] = (uint8_t) ((input[i] >> 8) & 0xff);
335 output[j+2] = (uint8_t) ((input[i] >> 16) & 0xff);
336 output[j+3] = (uint8_t) ((input[i] >> 24) & 0xff);
340 void MD5::decode (uint32_t* output, uint8_t* input, uint32_t len) {
343 for (i = 0, j = 0; j < len; i++, j += 4) {
344 output[i] = ((uint32_t)input[j]) | (((uint32_t)input[j+1]) << 8) | (((uint32_t)input[j+2]) << 16) | (((uint32_t)input[j+3]) << 24);
348 // Note: Replace "for loop" with standard memcpy if possible.
349 void MD5::memcpy (uint8_t* output, uint8_t* input, uint32_t len) {
352 for (i = 0; i < len; i++) output[i] = input[i];
355 // Note: Replace "for loop" with standard memset if possible.
356 void MD5::memset (uint8_t* output, uint8_t value, uint32_t len) {
359 for (i = 0; i < len; i++) output[i] = value;
362 inline unsigned int MD5::rotate_left(uint32_t x, uint32_t n) {
363 return (x << n) | (x >> (32-n));
366 inline unsigned int MD5::F(uint32_t x, uint32_t y, uint32_t z) {
367 return (x & y) | (~x & z);
370 inline unsigned int MD5::G(uint32_t x, uint32_t y, uint32_t z) {
371 return (x & z) | (y & ~z);
374 inline unsigned int MD5::H(uint32_t x, uint32_t y, uint32_t z) {
378 inline unsigned int MD5::I(uint32_t x, uint32_t y, uint32_t z) {
382 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) {
383 a += F(b, c, d) + x + ac;
384 a = rotate_left (a, s) +b;
387 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) {
388 a += G(b, c, d) + x + ac;
389 a = rotate_left (a, s) +b;
392 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) {
393 a += H(b, c, d) + x + ac;
394 a = rotate_left (a, s) +b;
397 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) {
398 a += I(b, c, d) + x + ac;
399 a = rotate_left (a, s) +b;