33 #if defined(POLARSSL_MD5_C)
37 #if defined(POLARSSL_FS_IO) || defined(POLARSSL_SELF_TEST)
45 #define GET_UINT32_LE(n,b,i) \
47 (n) = ( (uint32_t) (b)[(i) ] ) \
48 | ( (uint32_t) (b)[(i) + 1] << 8 ) \
49 | ( (uint32_t) (b)[(i) + 2] << 16 ) \
50 | ( (uint32_t) (b)[(i) + 3] << 24 ); \
55 #define PUT_UINT32_LE(n,b,i) \
57 (b)[(i) ] = (unsigned char) ( (n) ); \
58 (b)[(i) + 1] = (unsigned char) ( (n) >> 8 ); \
59 (b)[(i) + 2] = (unsigned char) ( (n) >> 16 ); \
60 (b)[(i) + 3] = (unsigned char) ( (n) >> 24 ); \
72 ctx->
state[0] = 0x67452301;
73 ctx->
state[1] = 0xEFCDAB89;
74 ctx->
state[2] = 0x98BADCFE;
75 ctx->
state[3] = 0x10325476;
80 uint32_t X[16], A, B, C, D;
82 GET_UINT32_LE( X[ 0], data, 0 );
83 GET_UINT32_LE( X[ 1], data, 4 );
84 GET_UINT32_LE( X[ 2], data, 8 );
85 GET_UINT32_LE( X[ 3], data, 12 );
86 GET_UINT32_LE( X[ 4], data, 16 );
87 GET_UINT32_LE( X[ 5], data, 20 );
88 GET_UINT32_LE( X[ 6], data, 24 );
89 GET_UINT32_LE( X[ 7], data, 28 );
90 GET_UINT32_LE( X[ 8], data, 32 );
91 GET_UINT32_LE( X[ 9], data, 36 );
92 GET_UINT32_LE( X[10], data, 40 );
93 GET_UINT32_LE( X[11], data, 44 );
94 GET_UINT32_LE( X[12], data, 48 );
95 GET_UINT32_LE( X[13], data, 52 );
96 GET_UINT32_LE( X[14], data, 56 );
97 GET_UINT32_LE( X[15], data, 60 );
99 #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
101 #define P(a,b,c,d,k,s,t) \
103 a += F(b,c,d) + X[k] + t; a = S(a,s) + b; \
111 #define F(x,y,z) (z ^ (x & (y ^ z)))
113 P( A, B, C, D, 0, 7, 0xD76AA478 );
114 P( D, A, B, C, 1, 12, 0xE8C7B756 );
115 P( C, D, A, B, 2, 17, 0x242070DB );
116 P( B, C, D, A, 3, 22, 0xC1BDCEEE );
117 P( A, B, C, D, 4, 7, 0xF57C0FAF );
118 P( D, A, B, C, 5, 12, 0x4787C62A );
119 P( C, D, A, B, 6, 17, 0xA8304613 );
120 P( B, C, D, A, 7, 22, 0xFD469501 );
121 P( A, B, C, D, 8, 7, 0x698098D8 );
122 P( D, A, B, C, 9, 12, 0x8B44F7AF );
123 P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
124 P( B, C, D, A, 11, 22, 0x895CD7BE );
125 P( A, B, C, D, 12, 7, 0x6B901122 );
126 P( D, A, B, C, 13, 12, 0xFD987193 );
127 P( C, D, A, B, 14, 17, 0xA679438E );
128 P( B, C, D, A, 15, 22, 0x49B40821 );
132 #define F(x,y,z) (y ^ (z & (x ^ y)))
134 P( A, B, C, D, 1, 5, 0xF61E2562 );
135 P( D, A, B, C, 6, 9, 0xC040B340 );
136 P( C, D, A, B, 11, 14, 0x265E5A51 );
137 P( B, C, D, A, 0, 20, 0xE9B6C7AA );
138 P( A, B, C, D, 5, 5, 0xD62F105D );
139 P( D, A, B, C, 10, 9, 0x02441453 );
140 P( C, D, A, B, 15, 14, 0xD8A1E681 );
141 P( B, C, D, A, 4, 20, 0xE7D3FBC8 );
142 P( A, B, C, D, 9, 5, 0x21E1CDE6 );
143 P( D, A, B, C, 14, 9, 0xC33707D6 );
144 P( C, D, A, B, 3, 14, 0xF4D50D87 );
145 P( B, C, D, A, 8, 20, 0x455A14ED );
146 P( A, B, C, D, 13, 5, 0xA9E3E905 );
147 P( D, A, B, C, 2, 9, 0xFCEFA3F8 );
148 P( C, D, A, B, 7, 14, 0x676F02D9 );
149 P( B, C, D, A, 12, 20, 0x8D2A4C8A );
153 #define F(x,y,z) (x ^ y ^ z)
155 P( A, B, C, D, 5, 4, 0xFFFA3942 );
156 P( D, A, B, C, 8, 11, 0x8771F681 );
157 P( C, D, A, B, 11, 16, 0x6D9D6122 );
158 P( B, C, D, A, 14, 23, 0xFDE5380C );
159 P( A, B, C, D, 1, 4, 0xA4BEEA44 );
160 P( D, A, B, C, 4, 11, 0x4BDECFA9 );
161 P( C, D, A, B, 7, 16, 0xF6BB4B60 );
162 P( B, C, D, A, 10, 23, 0xBEBFBC70 );
163 P( A, B, C, D, 13, 4, 0x289B7EC6 );
164 P( D, A, B, C, 0, 11, 0xEAA127FA );
165 P( C, D, A, B, 3, 16, 0xD4EF3085 );
166 P( B, C, D, A, 6, 23, 0x04881D05 );
167 P( A, B, C, D, 9, 4, 0xD9D4D039 );
168 P( D, A, B, C, 12, 11, 0xE6DB99E5 );
169 P( C, D, A, B, 15, 16, 0x1FA27CF8 );
170 P( B, C, D, A, 2, 23, 0xC4AC5665 );
174 #define F(x,y,z) (y ^ (x | ~z))
176 P( A, B, C, D, 0, 6, 0xF4292244 );
177 P( D, A, B, C, 7, 10, 0x432AFF97 );
178 P( C, D, A, B, 14, 15, 0xAB9423A7 );
179 P( B, C, D, A, 5, 21, 0xFC93A039 );
180 P( A, B, C, D, 12, 6, 0x655B59C3 );
181 P( D, A, B, C, 3, 10, 0x8F0CCC92 );
182 P( C, D, A, B, 10, 15, 0xFFEFF47D );
183 P( B, C, D, A, 1, 21, 0x85845DD1 );
184 P( A, B, C, D, 8, 6, 0x6FA87E4F );
185 P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
186 P( C, D, A, B, 6, 15, 0xA3014314 );
187 P( B, C, D, A, 13, 21, 0x4E0811A1 );
188 P( A, B, C, D, 4, 6, 0xF7537E82 );
189 P( D, A, B, C, 11, 10, 0xBD3AF235 );
190 P( C, D, A, B, 2, 15, 0x2AD7D2BB );
191 P( B, C, D, A, 9, 21, 0xEB86D391 );
212 left = ctx->
total[0] & 0x3F;
215 ctx->
total[0] += (uint32_t) ilen;
216 ctx->
total[0] &= 0xFFFFFFFF;
218 if( ctx->
total[0] < (uint32_t) ilen )
221 if( left && ilen >= fill )
223 memcpy( (
void *) (ctx->
buffer + left),
224 (
void *) input, fill );
240 memcpy( (
void *) (ctx->
buffer + left),
241 (
void *) input, ilen );
245 static const unsigned char md5_padding[64] =
247 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
248 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
250 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
260 unsigned char msglen[8];
262 high = ( ctx->
total[0] >> 29 )
263 | ( ctx->
total[1] << 3 );
264 low = ( ctx->
total[0] << 3 );
266 PUT_UINT32_LE( low, msglen, 0 );
267 PUT_UINT32_LE( high, msglen, 4 );
269 last = ctx->
total[0] & 0x3F;
270 padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
272 md5_update( ctx, (
unsigned char *) md5_padding, padn );
275 PUT_UINT32_LE( ctx->
state[0], output, 0 );
276 PUT_UINT32_LE( ctx->
state[1], output, 4 );
277 PUT_UINT32_LE( ctx->
state[2], output, 8 );
278 PUT_UINT32_LE( ctx->
state[3], output, 12 );
284 void md5(
const unsigned char *input,
size_t ilen,
unsigned char output[16] )
295 #if defined(POLARSSL_FS_IO)
299 int md5_file(
const char *path,
unsigned char output[16] )
304 unsigned char buf[1024];
306 if( ( f = fopen( path,
"rb" ) ) == NULL )
311 while( ( n = fread( buf, 1,
sizeof( buf ), f ) ) > 0 )
318 if( ferror( f ) != 0 )
335 unsigned char sum[16];
339 md5( key, keylen, sum );
344 memset( ctx->
ipad, 0x36, 64 );
345 memset( ctx->
opad, 0x5C, 64 );
347 for( i = 0; i < keylen; i++ )
349 ctx->
ipad[i] = (
unsigned char)( ctx->
ipad[i] ^ key[i] );
350 ctx->
opad[i] = (
unsigned char)( ctx->
opad[i] ^ key[i] );
356 memset( sum, 0,
sizeof( sum ) );
372 unsigned char tmpbuf[16];
380 memset( tmpbuf, 0,
sizeof( tmpbuf ) );
395 void md5_hmac(
const unsigned char *key,
size_t keylen,
396 const unsigned char *input,
size_t ilen,
397 unsigned char output[16] )
408 #if defined(POLARSSL_SELF_TEST)
412 static unsigned char md5_test_buf[7][81] =
417 {
"message digest" },
418 {
"abcdefghijklmnopqrstuvwxyz" },
419 {
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" },
420 {
"12345678901234567890123456789012345678901234567890123456789012" \
421 "345678901234567890" }
424 static const int md5_test_buflen[7] =
426 0, 1, 3, 14, 26, 62, 80
429 static const unsigned char md5_test_sum[7][16] =
431 { 0xD4, 0x1D, 0x8C, 0xD9, 0x8F, 0x00, 0xB2, 0x04,
432 0xE9, 0x80, 0x09, 0x98, 0xEC, 0xF8, 0x42, 0x7E },
433 { 0x0C, 0xC1, 0x75, 0xB9, 0xC0, 0xF1, 0xB6, 0xA8,
434 0x31, 0xC3, 0x99, 0xE2, 0x69, 0x77, 0x26, 0x61 },
435 { 0x90, 0x01, 0x50, 0x98, 0x3C, 0xD2, 0x4F, 0xB0,
436 0xD6, 0x96, 0x3F, 0x7D, 0x28, 0xE1, 0x7F, 0x72 },
437 { 0xF9, 0x6B, 0x69, 0x7D, 0x7C, 0xB7, 0x93, 0x8D,
438 0x52, 0x5A, 0x2F, 0x31, 0xAA, 0xF1, 0x61, 0xD0 },
439 { 0xC3, 0xFC, 0xD3, 0xD7, 0x61, 0x92, 0xE4, 0x00,
440 0x7D, 0xFB, 0x49, 0x6C, 0xCA, 0x67, 0xE1, 0x3B },
441 { 0xD1, 0x74, 0xAB, 0x98, 0xD2, 0x77, 0xD9, 0xF5,
442 0xA5, 0x61, 0x1C, 0x2C, 0x9F, 0x41, 0x9D, 0x9F },
443 { 0x57, 0xED, 0xF4, 0xA2, 0x2B, 0xE3, 0xC9, 0x55,
444 0xAC, 0x49, 0xDA, 0x2E, 0x21, 0x07, 0xB6, 0x7A }
450 static unsigned char md5_hmac_test_key[7][26] =
452 {
"\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B" },
454 {
"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA" },
455 {
"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10"
456 "\x11\x12\x13\x14\x15\x16\x17\x18\x19" },
457 {
"\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C" },
462 static const int md5_hmac_test_keylen[7] =
464 16, 4, 16, 25, 16, 80, 80
467 static unsigned char md5_hmac_test_buf[7][74] =
470 {
"what do ya want for nothing?" },
471 {
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
472 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
473 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
474 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
475 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD" },
476 {
"\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
477 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
478 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
479 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
480 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD" },
481 {
"Test With Truncation" },
482 {
"Test Using Larger Than Block-Size Key - Hash Key First" },
483 {
"Test Using Larger Than Block-Size Key and Larger"
484 " Than One Block-Size Data" }
487 static const int md5_hmac_test_buflen[7] =
489 8, 28, 50, 50, 20, 54, 73
492 static const unsigned char md5_hmac_test_sum[7][16] =
494 { 0x92, 0x94, 0x72, 0x7A, 0x36, 0x38, 0xBB, 0x1C,
495 0x13, 0xF4, 0x8E, 0xF8, 0x15, 0x8B, 0xFC, 0x9D },
496 { 0x75, 0x0C, 0x78, 0x3E, 0x6A, 0xB0, 0xB5, 0x03,
497 0xEA, 0xA8, 0x6E, 0x31, 0x0A, 0x5D, 0xB7, 0x38 },
498 { 0x56, 0xBE, 0x34, 0x52, 0x1D, 0x14, 0x4C, 0x88,
499 0xDB, 0xB8, 0xC7, 0x33, 0xF0, 0xE8, 0xB3, 0xF6 },
500 { 0x69, 0x7E, 0xAF, 0x0A, 0xCA, 0x3A, 0x3A, 0xEA,
501 0x3A, 0x75, 0x16, 0x47, 0x46, 0xFF, 0xAA, 0x79 },
502 { 0x56, 0x46, 0x1E, 0xF2, 0x34, 0x2E, 0xDC, 0x00,
503 0xF9, 0xBA, 0xB9, 0x95 },
504 { 0x6B, 0x1A, 0xB7, 0xFE, 0x4B, 0xD7, 0xBF, 0x8F,
505 0x0B, 0x62, 0xE6, 0xCE, 0x61, 0xB9, 0xD0, 0xCD },
506 { 0x6F, 0x63, 0x0F, 0xAD, 0x67, 0xCD, 0xA0, 0xEE,
507 0x1F, 0xB1, 0xF5, 0x62, 0xDB, 0x3A, 0xA5, 0x3E }
516 unsigned char buf[1024];
517 unsigned char md5sum[16];
520 for( i = 0; i < 7; i++ )
523 printf(
" MD5 test #%d: ", i + 1 );
525 md5( md5_test_buf[i], md5_test_buflen[i], md5sum );
527 if( memcmp( md5sum, md5_test_sum[i], 16 ) != 0 )
530 printf(
"failed\n" );
536 printf(
"passed\n" );
542 for( i = 0; i < 7; i++ )
545 printf(
" HMAC-MD5 test #%d: ", i + 1 );
547 if( i == 5 || i == 6 )
549 memset( buf,
'\xAA', buflen = 80 );
554 md5_hmac_test_keylen[i] );
557 md5_hmac_test_buflen[i] );
561 buflen = ( i == 4 ) ? 12 : 16;
563 if( memcmp( md5sum, md5_hmac_test_sum[i], buflen ) != 0 )
566 printf(
"failed\n" );
572 printf(
"passed\n" );