Merge pull request #278 from nmav/ocserv
[project/luci.git] / libs / px5g / 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