1 /*
2 * FIPS-180-1 compliant SHA-1 implementation
3 *
4 * Copyright (C) 2006-2010, Brainspark B.V.
5 *
6 * This file is part of PolarSSL (http://www.polarssl.org)
7 * Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
8 *
9 * All rights reserved.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License along
22 * with this program; if not, write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 */
25 /*
26 * The SHA-1 standard was published by NIST in 1993.
27 *
28 * http://www.itl.nist.gov/fipspubs/fip180-1.htm
29 */
30
31 //#include "polarssl/config.h"
32
33 //#if defined(POLARSSL_SHA1_C)
34
35 //#include "polarssl/sha1.h"
36 #include "sha1.h" /* modified for md5deep */
37
38 #if defined(POLARSSL_FS_IO) || defined(POLARSSL_SELF_TEST)
39 #include <stdio.h>
40 #endif
41
42 /*
43 * 32-bit integer manipulation macros (big endian)
44 */
45 #ifndef GET_ULONG_BE
46 #define GET_ULONG_BE(n,b,i) \
47 { \
48 (n) = ( (unsigned long) (b)[(i) ] << 24 ) \
49 | ( (unsigned long) (b)[(i) + 1] << 16 ) \
50 | ( (unsigned long) (b)[(i) + 2] << 8 ) \
51 | ( (unsigned long) (b)[(i) + 3] ); \
52 }
53 #endif
54
55 #ifndef PUT_ULONG_BE
56 #define PUT_ULONG_BE(n,b,i) \
57 { \
58 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
59 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
60 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
61 (b)[(i) + 3] = (unsigned char) ( (n) ); \
62 }
63 #endif
64
65 /*
66 * SHA-1 context setup
67 */
sha1_starts(sha1_context * ctx)68 void sha1_starts( sha1_context *ctx )
69 {
70 ctx->total[0] = 0;
71 ctx->total[1] = 0;
72
73 ctx->state[0] = 0x67452301;
74 ctx->state[1] = 0xEFCDAB89;
75 ctx->state[2] = 0x98BADCFE;
76 ctx->state[3] = 0x10325476;
77 ctx->state[4] = 0xC3D2E1F0;
78 }
79
sha1_process(sha1_context * ctx,const unsigned char data[64])80 static void sha1_process( sha1_context *ctx, const unsigned char data[64] )
81 {
82 unsigned long temp, W[16], A, B, C, D, E;
83
84 GET_ULONG_BE( W[ 0], data, 0 );
85 GET_ULONG_BE( W[ 1], data, 4 );
86 GET_ULONG_BE( W[ 2], data, 8 );
87 GET_ULONG_BE( W[ 3], data, 12 );
88 GET_ULONG_BE( W[ 4], data, 16 );
89 GET_ULONG_BE( W[ 5], data, 20 );
90 GET_ULONG_BE( W[ 6], data, 24 );
91 GET_ULONG_BE( W[ 7], data, 28 );
92 GET_ULONG_BE( W[ 8], data, 32 );
93 GET_ULONG_BE( W[ 9], data, 36 );
94 GET_ULONG_BE( W[10], data, 40 );
95 GET_ULONG_BE( W[11], data, 44 );
96 GET_ULONG_BE( W[12], data, 48 );
97 GET_ULONG_BE( W[13], data, 52 );
98 GET_ULONG_BE( W[14], data, 56 );
99 GET_ULONG_BE( W[15], data, 60 );
100
101 #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
102
103 #define R(t) \
104 ( \
105 temp = W[(t - 3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ \
106 W[(t - 14) & 0x0F] ^ W[ t & 0x0F], \
107 ( W[t & 0x0F] = S(temp,1) ) \
108 )
109
110 #define P(a,b,c,d,e,x) \
111 { \
112 e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \
113 }
114
115 A = ctx->state[0];
116 B = ctx->state[1];
117 C = ctx->state[2];
118 D = ctx->state[3];
119 E = ctx->state[4];
120
121 #define F(x,y,z) (z ^ (x & (y ^ z)))
122 #define K 0x5A827999
123
124 P( A, B, C, D, E, W[0] );
125 P( E, A, B, C, D, W[1] );
126 P( D, E, A, B, C, W[2] );
127 P( C, D, E, A, B, W[3] );
128 P( B, C, D, E, A, W[4] );
129 P( A, B, C, D, E, W[5] );
130 P( E, A, B, C, D, W[6] );
131 P( D, E, A, B, C, W[7] );
132 P( C, D, E, A, B, W[8] );
133 P( B, C, D, E, A, W[9] );
134 P( A, B, C, D, E, W[10] );
135 P( E, A, B, C, D, W[11] );
136 P( D, E, A, B, C, W[12] );
137 P( C, D, E, A, B, W[13] );
138 P( B, C, D, E, A, W[14] );
139 P( A, B, C, D, E, W[15] );
140 P( E, A, B, C, D, R(16) );
141 P( D, E, A, B, C, R(17) );
142 P( C, D, E, A, B, R(18) );
143 P( B, C, D, E, A, R(19) );
144
145 #undef K
146 #undef F
147
148 #define F(x,y,z) (x ^ y ^ z)
149 #define K 0x6ED9EBA1
150
151 P( A, B, C, D, E, R(20) );
152 P( E, A, B, C, D, R(21) );
153 P( D, E, A, B, C, R(22) );
154 P( C, D, E, A, B, R(23) );
155 P( B, C, D, E, A, R(24) );
156 P( A, B, C, D, E, R(25) );
157 P( E, A, B, C, D, R(26) );
158 P( D, E, A, B, C, R(27) );
159 P( C, D, E, A, B, R(28) );
160 P( B, C, D, E, A, R(29) );
161 P( A, B, C, D, E, R(30) );
162 P( E, A, B, C, D, R(31) );
163 P( D, E, A, B, C, R(32) );
164 P( C, D, E, A, B, R(33) );
165 P( B, C, D, E, A, R(34) );
166 P( A, B, C, D, E, R(35) );
167 P( E, A, B, C, D, R(36) );
168 P( D, E, A, B, C, R(37) );
169 P( C, D, E, A, B, R(38) );
170 P( B, C, D, E, A, R(39) );
171
172 #undef K
173 #undef F
174
175 #define F(x,y,z) ((x & y) | (z & (x | y)))
176 #define K 0x8F1BBCDC
177
178 P( A, B, C, D, E, R(40) );
179 P( E, A, B, C, D, R(41) );
180 P( D, E, A, B, C, R(42) );
181 P( C, D, E, A, B, R(43) );
182 P( B, C, D, E, A, R(44) );
183 P( A, B, C, D, E, R(45) );
184 P( E, A, B, C, D, R(46) );
185 P( D, E, A, B, C, R(47) );
186 P( C, D, E, A, B, R(48) );
187 P( B, C, D, E, A, R(49) );
188 P( A, B, C, D, E, R(50) );
189 P( E, A, B, C, D, R(51) );
190 P( D, E, A, B, C, R(52) );
191 P( C, D, E, A, B, R(53) );
192 P( B, C, D, E, A, R(54) );
193 P( A, B, C, D, E, R(55) );
194 P( E, A, B, C, D, R(56) );
195 P( D, E, A, B, C, R(57) );
196 P( C, D, E, A, B, R(58) );
197 P( B, C, D, E, A, R(59) );
198
199 #undef K
200 #undef F
201
202 #define F(x,y,z) (x ^ y ^ z)
203 #define K 0xCA62C1D6
204
205 P( A, B, C, D, E, R(60) );
206 P( E, A, B, C, D, R(61) );
207 P( D, E, A, B, C, R(62) );
208 P( C, D, E, A, B, R(63) );
209 P( B, C, D, E, A, R(64) );
210 P( A, B, C, D, E, R(65) );
211 P( E, A, B, C, D, R(66) );
212 P( D, E, A, B, C, R(67) );
213 P( C, D, E, A, B, R(68) );
214 P( B, C, D, E, A, R(69) );
215 P( A, B, C, D, E, R(70) );
216 P( E, A, B, C, D, R(71) );
217 P( D, E, A, B, C, R(72) );
218 P( C, D, E, A, B, R(73) );
219 P( B, C, D, E, A, R(74) );
220 P( A, B, C, D, E, R(75) );
221 P( E, A, B, C, D, R(76) );
222 P( D, E, A, B, C, R(77) );
223 P( C, D, E, A, B, R(78) );
224 P( B, C, D, E, A, R(79) );
225
226 #undef K
227 #undef F
228
229 ctx->state[0] += A;
230 ctx->state[1] += B;
231 ctx->state[2] += C;
232 ctx->state[3] += D;
233 ctx->state[4] += E;
234 }
235
236 /*
237 * SHA-1 process buffer
238 */
sha1_update(sha1_context * ctx,const unsigned char * input,size_t ilen)239 void sha1_update( sha1_context *ctx, const unsigned char *input, size_t ilen )
240 {
241 size_t fill;
242 unsigned long left;
243
244 if( ilen <= 0 )
245 return;
246
247 left = ctx->total[0] & 0x3F;
248 fill = 64 - left;
249
250 ctx->total[0] += (unsigned long) ilen;
251 ctx->total[0] &= 0xFFFFFFFF;
252
253 if( ctx->total[0] < (unsigned long) ilen )
254 ctx->total[1]++;
255
256 if( left && ilen >= fill )
257 {
258 memcpy( (void *) (ctx->buffer + left),
259 (const void *) input, fill );
260 sha1_process( ctx, ctx->buffer );
261 input += fill;
262 ilen -= fill;
263 left = 0;
264 }
265
266 while( ilen >= 64 )
267 {
268 sha1_process( ctx, input );
269 input += 64;
270 ilen -= 64;
271 }
272
273 if( ilen > 0 )
274 {
275 memcpy( (void *) (ctx->buffer + left),
276 (const void *) input, ilen );
277 }
278 }
279
280 static const unsigned char sha1_padding[64] =
281 {
282 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
283 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
284 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
285 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
286 };
287
288 /*
289 * SHA-1 final digest
290 */
sha1_finish(sha1_context * ctx,unsigned char output[20])291 void sha1_finish( sha1_context *ctx, unsigned char output[20] )
292 {
293 unsigned long last, padn;
294 unsigned long high, low;
295 unsigned char msglen[8];
296
297 high = ( ctx->total[0] >> 29 )
298 | ( ctx->total[1] << 3 );
299 low = ( ctx->total[0] << 3 );
300
301 PUT_ULONG_BE( high, msglen, 0 );
302 PUT_ULONG_BE( low, msglen, 4 );
303
304 last = ctx->total[0] & 0x3F;
305 padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
306
307 sha1_update( ctx, (const unsigned char *) sha1_padding, padn );
308 sha1_update( ctx, msglen, 8 );
309
310 PUT_ULONG_BE( ctx->state[0], output, 0 );
311 PUT_ULONG_BE( ctx->state[1], output, 4 );
312 PUT_ULONG_BE( ctx->state[2], output, 8 );
313 PUT_ULONG_BE( ctx->state[3], output, 12 );
314 PUT_ULONG_BE( ctx->state[4], output, 16 );
315 }
316
317 /*
318 * output = SHA-1( input buffer )
319 */
sha1(const unsigned char * input,size_t ilen,unsigned char output[20])320 void sha1( const unsigned char *input, size_t ilen, unsigned char output[20] )
321 {
322 sha1_context ctx;
323
324 sha1_starts( &ctx );
325 sha1_update( &ctx, input, ilen );
326 sha1_finish( &ctx, output );
327
328 memset( &ctx, 0, sizeof( sha1_context ) );
329 }
330
331 #if defined(POLARSSL_FS_IO)
332 /*
333 * output = SHA-1( file contents )
334 */
sha1_file(const char * path,unsigned char output[20])335 int sha1_file( const char *path, unsigned char output[20] )
336 {
337 FILE *f;
338 size_t n;
339 sha1_context ctx;
340 unsigned char buf[1024];
341
342 if( ( f = fopen( path, "rb" ) ) == NULL )
343 return( 1 );
344
345 sha1_starts( &ctx );
346
347 while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
348 sha1_update( &ctx, buf, n );
349
350 sha1_finish( &ctx, output );
351
352 memset( &ctx, 0, sizeof( sha1_context ) );
353
354 if( ferror( f ) != 0 )
355 {
356 fclose( f );
357 return( 2 );
358 }
359
360 fclose( f );
361 return( 0 );
362 }
363 #endif /* POLARSSL_FS_IO */
364
365 /*
366 * SHA-1 HMAC context setup
367 */
sha1_hmac_starts(sha1_context * ctx,const unsigned char * key,size_t keylen)368 void sha1_hmac_starts( sha1_context *ctx, const unsigned char *key, size_t keylen )
369 {
370 size_t i;
371 unsigned char sum[20];
372
373 if( keylen > 64 )
374 {
375 sha1( key, keylen, sum );
376 keylen = 20;
377 key = sum;
378 }
379
380 memset( ctx->ipad, 0x36, 64 );
381 memset( ctx->opad, 0x5C, 64 );
382
383 for( i = 0; i < keylen; i++ )
384 {
385 ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
386 ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
387 }
388
389 sha1_starts( ctx );
390 sha1_update( ctx, ctx->ipad, 64 );
391
392 memset( sum, 0, sizeof( sum ) );
393 }
394
395 /*
396 * SHA-1 HMAC process buffer
397 */
sha1_hmac_update(sha1_context * ctx,const unsigned char * input,size_t ilen)398 void sha1_hmac_update( sha1_context *ctx, const unsigned char *input, size_t ilen )
399 {
400 sha1_update( ctx, input, ilen );
401 }
402
403 /*
404 * SHA-1 HMAC final digest
405 */
sha1_hmac_finish(sha1_context * ctx,unsigned char output[20])406 void sha1_hmac_finish( sha1_context *ctx, unsigned char output[20] )
407 {
408 unsigned char tmpbuf[20];
409
410 sha1_finish( ctx, tmpbuf );
411 sha1_starts( ctx );
412 sha1_update( ctx, ctx->opad, 64 );
413 sha1_update( ctx, tmpbuf, 20 );
414 sha1_finish( ctx, output );
415
416 memset( tmpbuf, 0, sizeof( tmpbuf ) );
417 }
418
419 /*
420 * SHA1 HMAC context reset
421 */
sha1_hmac_reset(sha1_context * ctx)422 void sha1_hmac_reset( sha1_context *ctx )
423 {
424 sha1_starts( ctx );
425 sha1_update( ctx, ctx->ipad, 64 );
426 }
427
428 /*
429 * output = HMAC-SHA-1( hmac key, input buffer )
430 */
sha1_hmac(const unsigned char * key,size_t keylen,const unsigned char * input,size_t ilen,unsigned char output[20])431 void sha1_hmac( const unsigned char *key, size_t keylen,
432 const unsigned char *input, size_t ilen,
433 unsigned char output[20] )
434 {
435 sha1_context ctx;
436
437 sha1_hmac_starts( &ctx, key, keylen );
438 sha1_hmac_update( &ctx, input, ilen );
439 sha1_hmac_finish( &ctx, output );
440
441 memset( &ctx, 0, sizeof( sha1_context ) );
442 }
443
444 #if defined(POLARSSL_SELF_TEST)
445 /*
446 * FIPS-180-1 test vectors
447 */
448 static unsigned char sha1_test_buf[3][57] =
449 {
450 { "abc" },
451 { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
452 { "" }
453 };
454
455 static const int sha1_test_buflen[3] =
456 {
457 3, 56, 1000
458 };
459
460 static const unsigned char sha1_test_sum[3][20] =
461 {
462 { 0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
463 0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D },
464 { 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
465 0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1 },
466 { 0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
467 0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F }
468 };
469
470 /*
471 * RFC 2202 test vectors
472 */
473 static unsigned char sha1_hmac_test_key[7][26] =
474 {
475 { "\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B"
476 "\x0B\x0B\x0B\x0B" },
477 { "Jefe" },
478 { "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
479 "\xAA\xAA\xAA\xAA" },
480 { "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10"
481 "\x11\x12\x13\x14\x15\x16\x17\x18\x19" },
482 { "\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C"
483 "\x0C\x0C\x0C\x0C" },
484 { "" }, /* 0xAA 80 times */
485 { "" }
486 };
487
488 static const int sha1_hmac_test_keylen[7] =
489 {
490 20, 4, 20, 25, 20, 80, 80
491 };
492
493 static unsigned char sha1_hmac_test_buf[7][74] =
494 {
495 { "Hi There" },
496 { "what do ya want for nothing?" },
497 { "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
498 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
499 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
500 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
501 "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD" },
502 { "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
503 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
504 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
505 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
506 "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD" },
507 { "Test With Truncation" },
508 { "Test Using Larger Than Block-Size Key - Hash Key First" },
509 { "Test Using Larger Than Block-Size Key and Larger"
510 " Than One Block-Size Data" }
511 };
512
513 static const int sha1_hmac_test_buflen[7] =
514 {
515 8, 28, 50, 50, 20, 54, 73
516 };
517
518 static const unsigned char sha1_hmac_test_sum[7][20] =
519 {
520 { 0xB6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64, 0xE2, 0x8B,
521 0xC0, 0xB6, 0xFB, 0x37, 0x8C, 0x8E, 0xF1, 0x46, 0xBE, 0x00 },
522 { 0xEF, 0xFC, 0xDF, 0x6A, 0xE5, 0xEB, 0x2F, 0xA2, 0xD2, 0x74,
523 0x16, 0xD5, 0xF1, 0x84, 0xDF, 0x9C, 0x25, 0x9A, 0x7C, 0x79 },
524 { 0x12, 0x5D, 0x73, 0x42, 0xB9, 0xAC, 0x11, 0xCD, 0x91, 0xA3,
525 0x9A, 0xF4, 0x8A, 0xA1, 0x7B, 0x4F, 0x63, 0xF1, 0x75, 0xD3 },
526 { 0x4C, 0x90, 0x07, 0xF4, 0x02, 0x62, 0x50, 0xC6, 0xBC, 0x84,
527 0x14, 0xF9, 0xBF, 0x50, 0xC8, 0x6C, 0x2D, 0x72, 0x35, 0xDA },
528 { 0x4C, 0x1A, 0x03, 0x42, 0x4B, 0x55, 0xE0, 0x7F, 0xE7, 0xF2,
529 0x7B, 0xE1 },
530 { 0xAA, 0x4A, 0xE5, 0xE1, 0x52, 0x72, 0xD0, 0x0E, 0x95, 0x70,
531 0x56, 0x37, 0xCE, 0x8A, 0x3B, 0x55, 0xED, 0x40, 0x21, 0x12 },
532 { 0xE8, 0xE9, 0x9D, 0x0F, 0x45, 0x23, 0x7D, 0x78, 0x6D, 0x6B,
533 0xBA, 0xA7, 0x96, 0x5C, 0x78, 0x08, 0xBB, 0xFF, 0x1A, 0x91 }
534 };
535
536 /*
537 * Checkup routine
538 */
sha1_self_test(int verbose)539 int sha1_self_test( int verbose )
540 {
541 int i, j, buflen;
542 unsigned char buf[1024];
543 unsigned char sha1sum[20];
544 sha1_context ctx;
545
546 /*
547 * SHA-1
548 */
549 for( i = 0; i < 3; i++ )
550 {
551 if( verbose != 0 )
552 printf( " SHA-1 test #%d: ", i + 1 );
553
554 sha1_starts( &ctx );
555
556 if( i == 2 )
557 {
558 memset( buf, 'a', buflen = 1000 );
559
560 for( j = 0; j < 1000; j++ )
561 sha1_update( &ctx, buf, buflen );
562 }
563 else
564 sha1_update( &ctx, sha1_test_buf[i],
565 sha1_test_buflen[i] );
566
567 sha1_finish( &ctx, sha1sum );
568
569 if( memcmp( sha1sum, sha1_test_sum[i], 20 ) != 0 )
570 {
571 if( verbose != 0 )
572 printf( "failed\n" );
573
574 return( 1 );
575 }
576
577 if( verbose != 0 )
578 printf( "passed\n" );
579 }
580
581 if( verbose != 0 )
582 printf( "\n" );
583
584 for( i = 0; i < 7; i++ )
585 {
586 if( verbose != 0 )
587 printf( " HMAC-SHA-1 test #%d: ", i + 1 );
588
589 if( i == 5 || i == 6 )
590 {
591 memset( buf, '\xAA', buflen = 80 );
592 sha1_hmac_starts( &ctx, buf, buflen );
593 }
594 else
595 sha1_hmac_starts( &ctx, sha1_hmac_test_key[i],
596 sha1_hmac_test_keylen[i] );
597
598 sha1_hmac_update( &ctx, sha1_hmac_test_buf[i],
599 sha1_hmac_test_buflen[i] );
600
601 sha1_hmac_finish( &ctx, sha1sum );
602
603 buflen = ( i == 4 ) ? 12 : 20;
604
605 if( memcmp( sha1sum, sha1_hmac_test_sum[i], buflen ) != 0 )
606 {
607 if( verbose != 0 )
608 printf( "failed\n" );
609
610 return( 1 );
611 }
612
613 if( verbose != 0 )
614 printf( "passed\n" );
615 }
616
617 if( verbose != 0 )
618 printf( "\n" );
619
620 return( 0 );
621 }
622
623 #endif
624
625 //#endif
626