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