32 #if !defined(POLARSSL_CONFIG_FILE)
35 #include POLARSSL_CONFIG_FILE
38 #if defined(POLARSSL_RIPEMD160_C)
42 #if defined(POLARSSL_FS_IO) || defined(POLARSSL_SELF_TEST)
46 #if defined(POLARSSL_SELF_TEST)
50 #if defined(POLARSSL_PLATFORM_C)
53 #define polarssl_printf printf
60 #define GET_UINT32_LE(n,b,i) \
62 (n) = ( (uint32_t) (b)[(i) ] ) \
63 | ( (uint32_t) (b)[(i) + 1] << 8 ) \
64 | ( (uint32_t) (b)[(i) + 2] << 16 ) \
65 | ( (uint32_t) (b)[(i) + 3] << 24 ); \
70 #define PUT_UINT32_LE(n,b,i) \
72 (b)[(i) ] = (unsigned char) ( (n) ); \
73 (b)[(i) + 1] = (unsigned char) ( (n) >> 8 ); \
74 (b)[(i) + 2] = (unsigned char) ( (n) >> 16 ); \
75 (b)[(i) + 3] = (unsigned char) ( (n) >> 24 ); \
87 ctx->
state[0] = 0x67452301;
88 ctx->
state[1] = 0xEFCDAB89;
89 ctx->
state[2] = 0x98BADCFE;
90 ctx->
state[3] = 0x10325476;
91 ctx->
state[4] = 0xC3D2E1F0;
99 uint32_t A, B, C, D, E, Ap, Bp, Cp, Dp, Ep, X[16];
101 GET_UINT32_LE( X[ 0], data, 0 );
102 GET_UINT32_LE( X[ 1], data, 4 );
103 GET_UINT32_LE( X[ 2], data, 8 );
104 GET_UINT32_LE( X[ 3], data, 12 );
105 GET_UINT32_LE( X[ 4], data, 16 );
106 GET_UINT32_LE( X[ 5], data, 20 );
107 GET_UINT32_LE( X[ 6], data, 24 );
108 GET_UINT32_LE( X[ 7], data, 28 );
109 GET_UINT32_LE( X[ 8], data, 32 );
110 GET_UINT32_LE( X[ 9], data, 36 );
111 GET_UINT32_LE( X[10], data, 40 );
112 GET_UINT32_LE( X[11], data, 44 );
113 GET_UINT32_LE( X[12], data, 48 );
114 GET_UINT32_LE( X[13], data, 52 );
115 GET_UINT32_LE( X[14], data, 56 );
116 GET_UINT32_LE( X[15], data, 60 );
118 A = Ap = ctx->
state[0];
119 B = Bp = ctx->
state[1];
120 C = Cp = ctx->
state[2];
121 D = Dp = ctx->
state[3];
122 E = Ep = ctx->
state[4];
124 #define F1( x, y, z ) ( x ^ y ^ z )
125 #define F2( x, y, z ) ( ( x & y ) | ( ~x & z ) )
126 #define F3( x, y, z ) ( ( x | ~y ) ^ z )
127 #define F4( x, y, z ) ( ( x & z ) | ( y & ~z ) )
128 #define F5( x, y, z ) ( x ^ ( y | ~z ) )
130 #define S( x, n ) ( ( x << n ) | ( x >> (32 - n) ) )
132 #define P( a, b, c, d, e, r, s, f, k ) \
133 a += f( b, c, d ) + X[r] + k; \
137 #define P2( a, b, c, d, e, r, s, rp, sp ) \
138 P( a, b, c, d, e, r, s, F, K ); \
139 P( a ## p, b ## p, c ## p, d ## p, e ## p, rp, sp, Fp, Kp );
144 #define Kp 0x50A28BE6
145 P2( A, B, C, D, E, 0, 11, 5, 8 );
146 P2( E, A, B, C, D, 1, 14, 14, 9 );
147 P2( D, E, A, B, C, 2, 15, 7, 9 );
148 P2( C, D, E, A, B, 3, 12, 0, 11 );
149 P2( B, C, D, E, A, 4, 5, 9, 13 );
150 P2( A, B, C, D, E, 5, 8, 2, 15 );
151 P2( E, A, B, C, D, 6, 7, 11, 15 );
152 P2( D, E, A, B, C, 7, 9, 4, 5 );
153 P2( C, D, E, A, B, 8, 11, 13, 7 );
154 P2( B, C, D, E, A, 9, 13, 6, 7 );
155 P2( A, B, C, D, E, 10, 14, 15, 8 );
156 P2( E, A, B, C, D, 11, 15, 8, 11 );
157 P2( D, E, A, B, C, 12, 6, 1, 14 );
158 P2( C, D, E, A, B, 13, 7, 10, 14 );
159 P2( B, C, D, E, A, 14, 9, 3, 12 );
160 P2( A, B, C, D, E, 15, 8, 12, 6 );
169 #define Kp 0x5C4DD124
170 P2( E, A, B, C, D, 7, 7, 6, 9 );
171 P2( D, E, A, B, C, 4, 6, 11, 13 );
172 P2( C, D, E, A, B, 13, 8, 3, 15 );
173 P2( B, C, D, E, A, 1, 13, 7, 7 );
174 P2( A, B, C, D, E, 10, 11, 0, 12 );
175 P2( E, A, B, C, D, 6, 9, 13, 8 );
176 P2( D, E, A, B, C, 15, 7, 5, 9 );
177 P2( C, D, E, A, B, 3, 15, 10, 11 );
178 P2( B, C, D, E, A, 12, 7, 14, 7 );
179 P2( A, B, C, D, E, 0, 12, 15, 7 );
180 P2( E, A, B, C, D, 9, 15, 8, 12 );
181 P2( D, E, A, B, C, 5, 9, 12, 7 );
182 P2( C, D, E, A, B, 2, 11, 4, 6 );
183 P2( B, C, D, E, A, 14, 7, 9, 15 );
184 P2( A, B, C, D, E, 11, 13, 1, 13 );
185 P2( E, A, B, C, D, 8, 12, 2, 11 );
194 #define Kp 0x6D703EF3
195 P2( D, E, A, B, C, 3, 11, 15, 9 );
196 P2( C, D, E, A, B, 10, 13, 5, 7 );
197 P2( B, C, D, E, A, 14, 6, 1, 15 );
198 P2( A, B, C, D, E, 4, 7, 3, 11 );
199 P2( E, A, B, C, D, 9, 14, 7, 8 );
200 P2( D, E, A, B, C, 15, 9, 14, 6 );
201 P2( C, D, E, A, B, 8, 13, 6, 6 );
202 P2( B, C, D, E, A, 1, 15, 9, 14 );
203 P2( A, B, C, D, E, 2, 14, 11, 12 );
204 P2( E, A, B, C, D, 7, 8, 8, 13 );
205 P2( D, E, A, B, C, 0, 13, 12, 5 );
206 P2( C, D, E, A, B, 6, 6, 2, 14 );
207 P2( B, C, D, E, A, 13, 5, 10, 13 );
208 P2( A, B, C, D, E, 11, 12, 0, 13 );
209 P2( E, A, B, C, D, 5, 7, 4, 7 );
210 P2( D, E, A, B, C, 12, 5, 13, 5 );
219 #define Kp 0x7A6D76E9
220 P2( C, D, E, A, B, 1, 11, 8, 15 );
221 P2( B, C, D, E, A, 9, 12, 6, 5 );
222 P2( A, B, C, D, E, 11, 14, 4, 8 );
223 P2( E, A, B, C, D, 10, 15, 1, 11 );
224 P2( D, E, A, B, C, 0, 14, 3, 14 );
225 P2( C, D, E, A, B, 8, 15, 11, 14 );
226 P2( B, C, D, E, A, 12, 9, 15, 6 );
227 P2( A, B, C, D, E, 4, 8, 0, 14 );
228 P2( E, A, B, C, D, 13, 9, 5, 6 );
229 P2( D, E, A, B, C, 3, 14, 12, 9 );
230 P2( C, D, E, A, B, 7, 5, 2, 12 );
231 P2( B, C, D, E, A, 15, 6, 13, 9 );
232 P2( A, B, C, D, E, 14, 8, 9, 12 );
233 P2( E, A, B, C, D, 5, 6, 7, 5 );
234 P2( D, E, A, B, C, 6, 5, 10, 15 );
235 P2( C, D, E, A, B, 2, 12, 14, 8 );
244 #define Kp 0x00000000
245 P2( B, C, D, E, A, 4, 9, 12, 8 );
246 P2( A, B, C, D, E, 0, 15, 15, 5 );
247 P2( E, A, B, C, D, 5, 5, 10, 12 );
248 P2( D, E, A, B, C, 9, 11, 4, 9 );
249 P2( C, D, E, A, B, 7, 6, 1, 12 );
250 P2( B, C, D, E, A, 12, 8, 5, 5 );
251 P2( A, B, C, D, E, 2, 13, 8, 14 );
252 P2( E, A, B, C, D, 10, 12, 7, 6 );
253 P2( D, E, A, B, C, 14, 5, 6, 8 );
254 P2( C, D, E, A, B, 1, 12, 2, 13 );
255 P2( B, C, D, E, A, 3, 13, 13, 6 );
256 P2( A, B, C, D, E, 8, 14, 14, 5 );
257 P2( E, A, B, C, D, 11, 11, 0, 15 );
258 P2( D, E, A, B, C, 6, 8, 3, 13 );
259 P2( C, D, E, A, B, 15, 5, 9, 11 );
260 P2( B, C, D, E, A, 13, 6, 11, 11 );
266 C = ctx->
state[1] + C + Dp;
278 const unsigned char *input,
size_t ilen )
286 left = ctx->
total[0] & 0x3F;
289 ctx->
total[0] += (uint32_t) ilen;
290 ctx->
total[0] &= 0xFFFFFFFF;
292 if( ctx->
total[0] < (uint32_t) ilen )
295 if( left && ilen >= fill )
297 memcpy( (
void *) (ctx->
buffer + left), input, fill );
313 memcpy( (
void *) (ctx->
buffer + left), input, ilen );
317 static const unsigned char ripemd160_padding[64] =
319 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
320 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
321 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
322 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
332 unsigned char msglen[8];
334 high = ( ctx->
total[0] >> 29 )
335 | ( ctx->
total[1] << 3 );
336 low = ( ctx->
total[0] << 3 );
338 PUT_UINT32_LE( low, msglen, 0 );
339 PUT_UINT32_LE( high, msglen, 4 );
341 last = ctx->
total[0] & 0x3F;
342 padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
347 PUT_UINT32_LE( ctx->
state[0], output, 0 );
348 PUT_UINT32_LE( ctx->
state[1], output, 4 );
349 PUT_UINT32_LE( ctx->
state[2], output, 8 );
350 PUT_UINT32_LE( ctx->
state[3], output, 12 );
351 PUT_UINT32_LE( ctx->
state[4], output, 16 );
357 void ripemd160(
const unsigned char *input,
size_t ilen,
358 unsigned char output[20] )
369 #if defined(POLARSSL_FS_IO)
378 unsigned char buf[1024];
380 if( ( f = fopen( path,
"rb" ) ) == NULL )
385 while( ( n = fread( buf, 1,
sizeof( buf ), f ) ) > 0 )
392 if( ferror( f ) != 0 )
407 const unsigned char *key,
size_t keylen )
410 unsigned char sum[20];
419 memset( ctx->
ipad, 0x36, 64 );
420 memset( ctx->
opad, 0x5C, 64 );
422 for( i = 0; i < keylen; i++ )
424 ctx->
ipad[i] = (
unsigned char)( ctx->
ipad[i] ^ key[i] );
425 ctx->
opad[i] = (
unsigned char)( ctx->
opad[i] ^ key[i] );
431 memset( sum, 0,
sizeof( sum ) );
438 const unsigned char *input,
size_t ilen )
448 unsigned char tmpbuf[20];
456 memset( tmpbuf, 0,
sizeof( tmpbuf ) );
472 const unsigned char *input,
size_t ilen,
473 unsigned char output[20] )
485 #if defined(POLARSSL_SELF_TEST)
492 static const char *ripemd160_test_input[TESTS] =
498 "abcdefghijklmnopqrstuvwxyz",
499 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
500 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
501 "1234567890123456789012345678901234567890"
502 "1234567890123456789012345678901234567890",
505 static const unsigned char ripemd160_test_md[TESTS][20] =
507 { 0x9c, 0x11, 0x85, 0xa5, 0xc5, 0xe9, 0xfc, 0x54, 0x61, 0x28,
508 0x08, 0x97, 0x7e, 0xe8, 0xf5, 0x48, 0xb2, 0x25, 0x8d, 0x31 },
509 { 0x0b, 0xdc, 0x9d, 0x2d, 0x25, 0x6b, 0x3e, 0xe9, 0xda, 0xae,
510 0x34, 0x7b, 0xe6, 0xf4, 0xdc, 0x83, 0x5a, 0x46, 0x7f, 0xfe },
511 { 0x8e, 0xb2, 0x08, 0xf7, 0xe0, 0x5d, 0x98, 0x7a, 0x9b, 0x04,
512 0x4a, 0x8e, 0x98, 0xc6, 0xb0, 0x87, 0xf1, 0x5a, 0x0b, 0xfc },
513 { 0x5d, 0x06, 0x89, 0xef, 0x49, 0xd2, 0xfa, 0xe5, 0x72, 0xb8,
514 0x81, 0xb1, 0x23, 0xa8, 0x5f, 0xfa, 0x21, 0x59, 0x5f, 0x36 },
515 { 0xf7, 0x1c, 0x27, 0x10, 0x9c, 0x69, 0x2c, 0x1b, 0x56, 0xbb,
516 0xdc, 0xeb, 0x5b, 0x9d, 0x28, 0x65, 0xb3, 0x70, 0x8d, 0xbc },
517 { 0x12, 0xa0, 0x53, 0x38, 0x4a, 0x9c, 0x0c, 0x88, 0xe4, 0x05,
518 0xa0, 0x6c, 0x27, 0xdc, 0xf4, 0x9a, 0xda, 0x62, 0xeb, 0x2b },
519 { 0xb0, 0xe2, 0x0b, 0x6e, 0x31, 0x16, 0x64, 0x02, 0x86, 0xed,
520 0x3a, 0x87, 0xa5, 0x71, 0x30, 0x79, 0xb2, 0x1f, 0x51, 0x89 },
521 { 0x9b, 0x75, 0x2e, 0x45, 0x57, 0x3d, 0x4b, 0x39, 0xf4, 0xdb,
522 0xd3, 0x32, 0x3c, 0xab, 0x82, 0xbf, 0x63, 0x32, 0x6b, 0xfb },
525 static const unsigned char ripemd160_test_hmac[KEYS][TESTS][20] =
528 { 0xcf, 0x38, 0x76, 0x77, 0xbf, 0xda, 0x84, 0x83, 0xe6, 0x3b,
529 0x57, 0xe0, 0x6c, 0x3b, 0x5e, 0xcd, 0x8b, 0x7f, 0xc0, 0x55 },
530 { 0x0d, 0x35, 0x1d, 0x71, 0xb7, 0x8e, 0x36, 0xdb, 0xb7, 0x39,
531 0x1c, 0x81, 0x0a, 0x0d, 0x2b, 0x62, 0x40, 0xdd, 0xba, 0xfc },
532 { 0xf7, 0xef, 0x28, 0x8c, 0xb1, 0xbb, 0xcc, 0x61, 0x60, 0xd7,
533 0x65, 0x07, 0xe0, 0xa3, 0xbb, 0xf7, 0x12, 0xfb, 0x67, 0xd6 },
534 { 0xf8, 0x36, 0x62, 0xcc, 0x8d, 0x33, 0x9c, 0x22, 0x7e, 0x60,
535 0x0f, 0xcd, 0x63, 0x6c, 0x57, 0xd2, 0x57, 0x1b, 0x1c, 0x34 },
536 { 0x84, 0x3d, 0x1c, 0x4e, 0xb8, 0x80, 0xac, 0x8a, 0xc0, 0xc9,
537 0xc9, 0x56, 0x96, 0x50, 0x79, 0x57, 0xd0, 0x15, 0x5d, 0xdb },
538 { 0x60, 0xf5, 0xef, 0x19, 0x8a, 0x2d, 0xd5, 0x74, 0x55, 0x45,
539 0xc1, 0xf0, 0xc4, 0x7a, 0xa3, 0xfb, 0x57, 0x76, 0xf8, 0x81 },
540 { 0xe4, 0x9c, 0x13, 0x6a, 0x9e, 0x56, 0x27, 0xe0, 0x68, 0x1b,
541 0x80, 0x8a, 0x3b, 0x97, 0xe6, 0xa6, 0xe6, 0x61, 0xae, 0x79 },
542 { 0x31, 0xbe, 0x3c, 0xc9, 0x8c, 0xee, 0x37, 0xb7, 0x9b, 0x06,
543 0x19, 0xe3, 0xe1, 0xc2, 0xbe, 0x4f, 0x1a, 0xa5, 0x6e, 0x6c },
546 { 0xfe, 0x69, 0xa6, 0x6c, 0x74, 0x23, 0xee, 0xa9, 0xc8, 0xfa,
547 0x2e, 0xff, 0x8d, 0x9d, 0xaf, 0xb4, 0xf1, 0x7a, 0x62, 0xf5 },
548 { 0x85, 0x74, 0x3e, 0x89, 0x9b, 0xc8, 0x2d, 0xbf, 0xa3, 0x6f,
549 0xaa, 0xa7, 0xa2, 0x5b, 0x7c, 0xfd, 0x37, 0x24, 0x32, 0xcd },
550 { 0x6e, 0x4a, 0xfd, 0x50, 0x1f, 0xa6, 0xb4, 0xa1, 0x82, 0x3c,
551 0xa3, 0xb1, 0x0b, 0xd9, 0xaa, 0x0b, 0xa9, 0x7b, 0xa1, 0x82 },
552 { 0x2e, 0x06, 0x6e, 0x62, 0x4b, 0xad, 0xb7, 0x6a, 0x18, 0x4c,
553 0x8f, 0x90, 0xfb, 0xa0, 0x53, 0x33, 0x0e, 0x65, 0x0e, 0x92 },
554 { 0x07, 0xe9, 0x42, 0xaa, 0x4e, 0x3c, 0xd7, 0xc0, 0x4d, 0xed,
555 0xc1, 0xd4, 0x6e, 0x2e, 0x8c, 0xc4, 0xc7, 0x41, 0xb3, 0xd9 },
556 { 0xb6, 0x58, 0x23, 0x18, 0xdd, 0xcf, 0xb6, 0x7a, 0x53, 0xa6,
557 0x7d, 0x67, 0x6b, 0x8a, 0xd8, 0x69, 0xad, 0xed, 0x62, 0x9a },
558 { 0xf1, 0xbe, 0x3e, 0xe8, 0x77, 0x70, 0x31, 0x40, 0xd3, 0x4f,
559 0x97, 0xea, 0x1a, 0xb3, 0xa0, 0x7c, 0x14, 0x13, 0x33, 0xe2 },
560 { 0x85, 0xf1, 0x64, 0x70, 0x3e, 0x61, 0xa6, 0x31, 0x31, 0xbe,
561 0x7e, 0x45, 0x95, 0x8e, 0x07, 0x94, 0x12, 0x39, 0x04, 0xf9 },
565 static const unsigned char ripemd160_test_key[KEYS][20] =
567 { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99,
568 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x01, 0x23, 0x45, 0x67 },
569 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc,
570 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33 },
579 unsigned char output[20];
581 memset( output, 0,
sizeof output );
583 for( i = 0; i < TESTS; i++ )
588 ripemd160( (
const unsigned char *) ripemd160_test_input[i],
589 strlen( ripemd160_test_input[i] ),
592 if( memcmp( output, ripemd160_test_md[i], 20 ) != 0 )
603 for( j = 0; j < KEYS; j++ )
610 (
const unsigned char *) ripemd160_test_input[i],
611 strlen( ripemd160_test_input[i] ),
614 if( memcmp( output, ripemd160_test_hmac[j][i], 20 ) != 0 )
void ripemd160_hmac_finish(ripemd160_context *ctx, unsigned char output[20])
RIPEMD-160 HMAC final digest.
void ripemd160_hmac_starts(ripemd160_context *ctx, const unsigned char *key, size_t keylen)
RIPEMD-160 HMAC context setup.
void ripemd160_update(ripemd160_context *ctx, const unsigned char *input, size_t ilen)
RIPEMD-160 process buffer.
void ripemd160_hmac_reset(ripemd160_context *ctx)
RIPEMD-160 HMAC context reset.
RIPEMD-160 context structure.
Configuration options (set of defines)
void ripemd160(const unsigned char *input, size_t ilen, unsigned char output[20])
Output = RIPEMD-160( input buffer )
RIPE MD-160 message digest.
void ripemd160_hmac_update(ripemd160_context *ctx, const unsigned char *input, size_t ilen)
RIPEMD-160 HMAC process buffer.
void ripemd160_finish(ripemd160_context *ctx, unsigned char output[20])
RIPEMD-160 final digest.
void ripemd160_hmac(const unsigned char *key, size_t keylen, const unsigned char *input, size_t ilen, unsigned char output[20])
Output = HMAC-RIPEMD-160( hmac key, input buffer )
#define POLARSSL_ERR_RIPEMD160_FILE_IO_ERROR
Read/write error in file.
int ripemd160_self_test(int verbose)
Checkup routine.
void ripemd160_process(ripemd160_context *ctx, const unsigned char data[64])
void ripemd160_starts(ripemd160_context *ctx)
RIPEMD-160 context setup.
int ripemd160_file(const char *path, unsigned char output[20])
Output = RIPEMD-160( file contents )