cd8abeb015178f75442e9399e9770fd39189eb6b
[iotcloud.git] / version2 / src / C / pbkdf2-sha256.cc
1 /*
2  *  FIPS-180-2 compliant SHA-256 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-256 Secure Hash Standard was published by NIST in 2002.
27  *
28  *  http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
29  */
30
31 #include <string.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include "pbkdf2-sha256.h"
35
36 /*
37  * 32-bit integer manipulation macros (big endian)
38  */
39 #ifndef GET_ULONG_BE
40 #define GET_ULONG_BE(n,b,i)                             \
41 {                                                       \
42     (n) = ( (unsigned long) (b)[(i)    ] << 24 )        \
43         | ( (unsigned long) (b)[(i) + 1] << 16 )        \
44         | ( (unsigned long) (b)[(i) + 2] <<  8 )        \
45         | ( (unsigned long) (b)[(i) + 3]       );       \
46 }
47 #endif
48
49 #ifndef PUT_ULONG_BE
50 #define PUT_ULONG_BE(n,b,i)                             \
51 {                                                       \
52     (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
53     (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
54     (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
55     (b)[(i) + 3] = (unsigned char) ( (n)       );       \
56 }
57 #endif
58
59 /*
60  * SHA-256 context setup
61  */
62 void sha2_starts( sha2_context *ctx, int is224 )
63 {
64     ctx->total[0] = 0;
65     ctx->total[1] = 0;
66
67     if( is224 == 0 )
68     {
69         /* SHA-256 */
70         ctx->state[0] = 0x6A09E667;
71         ctx->state[1] = 0xBB67AE85;
72         ctx->state[2] = 0x3C6EF372;
73         ctx->state[3] = 0xA54FF53A;
74         ctx->state[4] = 0x510E527F;
75         ctx->state[5] = 0x9B05688C;
76         ctx->state[6] = 0x1F83D9AB;
77         ctx->state[7] = 0x5BE0CD19;
78     }
79     else
80     {
81         /* SHA-224 */
82         ctx->state[0] = 0xC1059ED8;
83         ctx->state[1] = 0x367CD507;
84         ctx->state[2] = 0x3070DD17;
85         ctx->state[3] = 0xF70E5939;
86         ctx->state[4] = 0xFFC00B31;
87         ctx->state[5] = 0x68581511;
88         ctx->state[6] = 0x64F98FA7;
89         ctx->state[7] = 0xBEFA4FA4;
90     }
91
92     ctx->is224 = is224;
93 }
94
95 static void sha2_process( sha2_context *ctx, const unsigned char data[64] )
96 {
97     unsigned long temp1, temp2, W[64];
98     unsigned long A, B, C, D, E, F, G, H;
99
100     GET_ULONG_BE( W[ 0], data,  0 );
101     GET_ULONG_BE( W[ 1], data,  4 );
102     GET_ULONG_BE( W[ 2], data,  8 );
103     GET_ULONG_BE( W[ 3], data, 12 );
104     GET_ULONG_BE( W[ 4], data, 16 );
105     GET_ULONG_BE( W[ 5], data, 20 );
106     GET_ULONG_BE( W[ 6], data, 24 );
107     GET_ULONG_BE( W[ 7], data, 28 );
108     GET_ULONG_BE( W[ 8], data, 32 );
109     GET_ULONG_BE( W[ 9], data, 36 );
110     GET_ULONG_BE( W[10], data, 40 );
111     GET_ULONG_BE( W[11], data, 44 );
112     GET_ULONG_BE( W[12], data, 48 );
113     GET_ULONG_BE( W[13], data, 52 );
114     GET_ULONG_BE( W[14], data, 56 );
115     GET_ULONG_BE( W[15], data, 60 );
116
117 #define  SHR(x,n) ((x & 0xFFFFFFFF) >> n)
118 #define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))
119
120 #define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^  SHR(x, 3))
121 #define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^  SHR(x,10))
122
123 #define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
124 #define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
125
126 #define F0(x,y,z) ((x & y) | (z & (x | y)))
127 #define F1(x,y,z) (z ^ (x & (y ^ z)))
128
129 #define R(t)                                    \
130 (                                               \
131     W[t] = S1(W[t -  2]) + W[t -  7] +          \
132            S0(W[t - 15]) + W[t - 16]            \
133 )
134
135 #define P(a,b,c,d,e,f,g,h,x,K)                  \
136 {                                               \
137     temp1 = h + S3(e) + F1(e,f,g) + K + x;      \
138     temp2 = S2(a) + F0(a,b,c);                  \
139     d += temp1; h = temp1 + temp2;              \
140 }
141
142         A = ctx->state[0];
143         B = ctx->state[1];
144         C = ctx->state[2];
145         D = ctx->state[3];
146         E = ctx->state[4];
147         F = ctx->state[5];
148         G = ctx->state[6];
149         H = ctx->state[7];
150
151     P( A, B, C, D, E, F, G, H, W[ 0], 0x428A2F98 );
152     P( H, A, B, C, D, E, F, G, W[ 1], 0x71374491 );
153     P( G, H, A, B, C, D, E, F, W[ 2], 0xB5C0FBCF );
154     P( F, G, H, A, B, C, D, E, W[ 3], 0xE9B5DBA5 );
155     P( E, F, G, H, A, B, C, D, W[ 4], 0x3956C25B );
156     P( D, E, F, G, H, A, B, C, W[ 5], 0x59F111F1 );
157     P( C, D, E, F, G, H, A, B, W[ 6], 0x923F82A4 );
158     P( B, C, D, E, F, G, H, A, W[ 7], 0xAB1C5ED5 );
159     P( A, B, C, D, E, F, G, H, W[ 8], 0xD807AA98 );
160     P( H, A, B, C, D, E, F, G, W[ 9], 0x12835B01 );
161     P( G, H, A, B, C, D, E, F, W[10], 0x243185BE );
162     P( F, G, H, A, B, C, D, E, W[11], 0x550C7DC3 );
163     P( E, F, G, H, A, B, C, D, W[12], 0x72BE5D74 );
164     P( D, E, F, G, H, A, B, C, W[13], 0x80DEB1FE );
165     P( C, D, E, F, G, H, A, B, W[14], 0x9BDC06A7 );
166     P( B, C, D, E, F, G, H, A, W[15], 0xC19BF174 );
167     P( A, B, C, D, E, F, G, H, R(16), 0xE49B69C1 );
168     P( H, A, B, C, D, E, F, G, R(17), 0xEFBE4786 );
169     P( G, H, A, B, C, D, E, F, R(18), 0x0FC19DC6 );
170     P( F, G, H, A, B, C, D, E, R(19), 0x240CA1CC );
171     P( E, F, G, H, A, B, C, D, R(20), 0x2DE92C6F );
172     P( D, E, F, G, H, A, B, C, R(21), 0x4A7484AA );
173     P( C, D, E, F, G, H, A, B, R(22), 0x5CB0A9DC );
174     P( B, C, D, E, F, G, H, A, R(23), 0x76F988DA );
175     P( A, B, C, D, E, F, G, H, R(24), 0x983E5152 );
176     P( H, A, B, C, D, E, F, G, R(25), 0xA831C66D );
177     P( G, H, A, B, C, D, E, F, R(26), 0xB00327C8 );
178     P( F, G, H, A, B, C, D, E, R(27), 0xBF597FC7 );
179     P( E, F, G, H, A, B, C, D, R(28), 0xC6E00BF3 );
180     P( D, E, F, G, H, A, B, C, R(29), 0xD5A79147 );
181     P( C, D, E, F, G, H, A, B, R(30), 0x06CA6351 );
182     P( B, C, D, E, F, G, H, A, R(31), 0x14292967 );
183     P( A, B, C, D, E, F, G, H, R(32), 0x27B70A85 );
184     P( H, A, B, C, D, E, F, G, R(33), 0x2E1B2138 );
185     P( G, H, A, B, C, D, E, F, R(34), 0x4D2C6DFC );
186     P( F, G, H, A, B, C, D, E, R(35), 0x53380D13 );
187     P( E, F, G, H, A, B, C, D, R(36), 0x650A7354 );
188     P( D, E, F, G, H, A, B, C, R(37), 0x766A0ABB );
189     P( C, D, E, F, G, H, A, B, R(38), 0x81C2C92E );
190     P( B, C, D, E, F, G, H, A, R(39), 0x92722C85 );
191     P( A, B, C, D, E, F, G, H, R(40), 0xA2BFE8A1 );
192     P( H, A, B, C, D, E, F, G, R(41), 0xA81A664B );
193     P( G, H, A, B, C, D, E, F, R(42), 0xC24B8B70 );
194     P( F, G, H, A, B, C, D, E, R(43), 0xC76C51A3 );
195     P( E, F, G, H, A, B, C, D, R(44), 0xD192E819 );
196     P( D, E, F, G, H, A, B, C, R(45), 0xD6990624 );
197     P( C, D, E, F, G, H, A, B, R(46), 0xF40E3585 );
198     P( B, C, D, E, F, G, H, A, R(47), 0x106AA070 );
199     P( A, B, C, D, E, F, G, H, R(48), 0x19A4C116 );
200     P( H, A, B, C, D, E, F, G, R(49), 0x1E376C08 );
201     P( G, H, A, B, C, D, E, F, R(50), 0x2748774C );
202     P( F, G, H, A, B, C, D, E, R(51), 0x34B0BCB5 );
203     P( E, F, G, H, A, B, C, D, R(52), 0x391C0CB3 );
204     P( D, E, F, G, H, A, B, C, R(53), 0x4ED8AA4A );
205     P( C, D, E, F, G, H, A, B, R(54), 0x5B9CCA4F );
206     P( B, C, D, E, F, G, H, A, R(55), 0x682E6FF3 );
207     P( A, B, C, D, E, F, G, H, R(56), 0x748F82EE );
208     P( H, A, B, C, D, E, F, G, R(57), 0x78A5636F );
209     P( G, H, A, B, C, D, E, F, R(58), 0x84C87814 );
210     P( F, G, H, A, B, C, D, E, R(59), 0x8CC70208 );
211     P( E, F, G, H, A, B, C, D, R(60), 0x90BEFFFA );
212     P( D, E, F, G, H, A, B, C, R(61), 0xA4506CEB );
213     P( C, D, E, F, G, H, A, B, R(62), 0xBEF9A3F7 );
214     P( B, C, D, E, F, G, H, A, R(63), 0xC67178F2 );
215
216     ctx->state[0] += A;
217     ctx->state[1] += B;
218     ctx->state[2] += C;
219     ctx->state[3] += D;
220     ctx->state[4] += E;
221     ctx->state[5] += F;
222     ctx->state[6] += G;
223     ctx->state[7] += H;
224 }
225
226 /*
227  * SHA-256 process buffer
228  */
229 void sha2_update( sha2_context *ctx, const unsigned char *input, size_t ilen )
230 {
231     size_t fill;
232     unsigned long left;
233
234     if( ilen <= 0 )
235         return;
236
237     left = ctx->total[0] & 0x3F;
238     fill = 64 - left;
239
240     ctx->total[0] += (unsigned long) ilen;
241     ctx->total[0] &= 0xFFFFFFFF;
242
243     if( ctx->total[0] < (unsigned long) ilen )
244         ctx->total[1]++;
245
246     if( left && ilen >= fill )
247     {
248         memcpy( (void *) (ctx->buffer + left),
249                 (void *) input, fill );
250         sha2_process( ctx, ctx->buffer );
251         input += fill;
252         ilen  -= fill;
253         left = 0;
254     }
255
256     while( ilen >= 64 )
257     {
258         sha2_process( ctx, input );
259         input += 64;
260         ilen  -= 64;
261     }
262
263     if( ilen > 0 )
264     {
265         memcpy( (void *) (ctx->buffer + left),
266                 (void *) input, ilen );
267     }
268 }
269
270 static const unsigned char sha2_padding[64] =
271 {
272  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
273     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
274     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
275     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
276 };
277
278 /*
279  * SHA-256 final digest
280  */
281 void sha2_finish( sha2_context *ctx, unsigned char output[32] )
282 {
283     unsigned long last, padn;
284     unsigned long high, low;
285     unsigned char msglen[8];
286
287     high = ( ctx->total[0] >> 29 )
288          | ( ctx->total[1] <<  3 );
289     low  = ( ctx->total[0] <<  3 );
290
291     PUT_ULONG_BE( high, msglen, 0 );
292     PUT_ULONG_BE( low,  msglen, 4 );
293
294     last = ctx->total[0] & 0x3F;
295     padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
296
297     sha2_update( ctx, (unsigned char *) sha2_padding, padn );
298     sha2_update( ctx, msglen, 8 );
299
300     PUT_ULONG_BE( ctx->state[0], output,  0 );
301     PUT_ULONG_BE( ctx->state[1], output,  4 );
302     PUT_ULONG_BE( ctx->state[2], output,  8 );
303     PUT_ULONG_BE( ctx->state[3], output, 12 );
304     PUT_ULONG_BE( ctx->state[4], output, 16 );
305     PUT_ULONG_BE( ctx->state[5], output, 20 );
306     PUT_ULONG_BE( ctx->state[6], output, 24 );
307
308     if( ctx->is224 == 0 )
309         PUT_ULONG_BE( ctx->state[7], output, 28 );
310 }
311
312 /*
313  * output = SHA-256( input buffer )
314  */
315 void sha2( const unsigned char *input, size_t ilen,
316            unsigned char output[32], int is224 )
317 {
318     sha2_context ctx;
319
320     sha2_starts( &ctx, is224 );
321     sha2_update( &ctx, input, ilen );
322     sha2_finish( &ctx, output );
323
324     memset( &ctx, 0, sizeof( sha2_context ) );
325 }
326
327 /*
328  * SHA-256 HMAC context setup
329  */
330 void sha2_hmac_starts( sha2_context *ctx, const unsigned char *key, size_t keylen,
331                        int is224 )
332 {
333     size_t i;
334     unsigned char sum[32];
335
336     if( keylen > 64 )
337     {
338         sha2( key, keylen, sum, is224 );
339         keylen = ( is224 ) ? 28 : 32;
340         key = sum;
341     }
342
343     memset( ctx->ipad, 0x36, 64 );
344     memset( ctx->opad, 0x5C, 64 );
345
346     for( i = 0; i < keylen; i++ )
347     {
348         ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
349         ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
350     }
351
352     sha2_starts( ctx, is224 );
353     sha2_update( ctx, ctx->ipad, 64 );
354
355     memset( sum, 0, sizeof( sum ) );
356 }
357
358 /*
359  * SHA-256 HMAC process buffer
360  */
361 void sha2_hmac_update( sha2_context *ctx, const unsigned char *input, size_t ilen )
362 {
363     sha2_update( ctx, input, ilen );
364 }
365
366 /*
367  * SHA-256 HMAC final digest
368  */
369 void sha2_hmac_finish( sha2_context *ctx, unsigned char output[32] )
370 {
371     int is224, hlen;
372     unsigned char tmpbuf[32];
373
374     is224 = ctx->is224;
375     hlen = ( is224 == 0 ) ? 32 : 28;
376
377     sha2_finish( ctx, tmpbuf );
378     sha2_starts( ctx, is224 );
379     sha2_update( ctx, ctx->opad, 64 );
380     sha2_update( ctx, tmpbuf, hlen );
381     sha2_finish( ctx, output );
382
383     memset( tmpbuf, 0, sizeof( tmpbuf ) );
384 }
385
386 /*
387  * SHA-256 HMAC context reset
388  */
389 void sha2_hmac_reset( sha2_context *ctx )
390 {
391     sha2_starts( ctx, ctx->is224 );
392     sha2_update( ctx, ctx->ipad, 64 );
393 }
394
395 /*
396  * output = HMAC-SHA-256( hmac key, input buffer )
397  */
398 void sha2_hmac( const unsigned char *key, size_t keylen,
399                 const unsigned char *input, size_t ilen,
400                 unsigned char output[32], int is224 )
401 {
402     sha2_context ctx;
403
404     sha2_hmac_starts( &ctx, key, keylen, is224 );
405     sha2_hmac_update( &ctx, input, ilen );
406     sha2_hmac_finish( &ctx, output );
407
408     memset( &ctx, 0, sizeof( sha2_context ) );
409 }
410
411
412
413
414
415 #ifndef min
416 #define min( a, b ) ( ((a) < (b)) ? (a) : (b) )
417 #endif
418
419 void PKCS5_PBKDF2_HMAC(unsigned char *password, size_t plen,
420     unsigned char *salt, size_t slen,
421     const unsigned long iteration_count, const unsigned long key_length,
422     unsigned char *output)
423 {
424         sha2_context ctx;
425         sha2_starts(&ctx, 0);
426
427         // Size of the generated digest
428         unsigned char md_size = 32;
429         unsigned char md1[32];
430         unsigned char work[32];
431
432         unsigned long counter = 1;
433         unsigned long generated_key_length = 0;
434         while (generated_key_length < key_length) {
435                 // U1 ends up in md1 and work
436                 unsigned char c[4];
437                 c[0] = (counter >> 24) & 0xff;
438                 c[1] = (counter >> 16) & 0xff;
439                 c[2] = (counter >> 8) & 0xff;
440                 c[3] = (counter >> 0) & 0xff;
441
442                 sha2_hmac_starts(&ctx, password, plen, 0);
443                 sha2_hmac_update(&ctx, salt, slen);
444                 sha2_hmac_update(&ctx, c, 4);
445                 sha2_hmac_finish(&ctx, md1);
446                 memcpy(work, md1, md_size);
447
448                 unsigned long ic = 1;
449                 for (ic = 1; ic < iteration_count; ic++) {
450                         // U2 ends up in md1
451                         sha2_hmac_starts(&ctx, password, plen, 0);
452                         sha2_hmac_update(&ctx, md1, md_size);
453                         sha2_hmac_finish(&ctx, md1);
454                         // U1 xor U2
455                         unsigned long i = 0;
456                         for (i = 0; i < md_size; i++) {
457                                 work[i] ^= md1[i];
458                         }
459                         // and so on until iteration_count
460                 }
461
462                 // Copy the generated bytes to the key
463                 unsigned long bytes_to_write =
464                     min((key_length - generated_key_length), md_size);
465                 memcpy(output + generated_key_length, work, bytes_to_write);
466                 generated_key_length += bytes_to_write;
467                 ++counter;
468         }
469 }
470
471
472
473
474
475
476
477
478
479 #ifdef TEST
480 /*
481  * FIPS-180-2 test vectors
482  */
483 static unsigned char sha2_test_buf[3][57] = 
484 {
485     { "abc" },
486     { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
487     { "" }
488 };
489
490 static const int sha2_test_buflen[3] =
491 {
492     3, 56, 1000
493 };
494
495 static const unsigned char sha2_test_sum[6][32] =
496 {
497     /*
498      * SHA-224 test vectors
499      */
500     { 0x23, 0x09, 0x7D, 0x22, 0x34, 0x05, 0xD8, 0x22,
501       0x86, 0x42, 0xA4, 0x77, 0xBD, 0xA2, 0x55, 0xB3,
502       0x2A, 0xAD, 0xBC, 0xE4, 0xBD, 0xA0, 0xB3, 0xF7,
503       0xE3, 0x6C, 0x9D, 0xA7 },
504     { 0x75, 0x38, 0x8B, 0x16, 0x51, 0x27, 0x76, 0xCC,
505       0x5D, 0xBA, 0x5D, 0xA1, 0xFD, 0x89, 0x01, 0x50,
506       0xB0, 0xC6, 0x45, 0x5C, 0xB4, 0xF5, 0x8B, 0x19,
507       0x52, 0x52, 0x25, 0x25 },
508     { 0x20, 0x79, 0x46, 0x55, 0x98, 0x0C, 0x91, 0xD8,
509       0xBB, 0xB4, 0xC1, 0xEA, 0x97, 0x61, 0x8A, 0x4B,
510       0xF0, 0x3F, 0x42, 0x58, 0x19, 0x48, 0xB2, 0xEE,
511       0x4E, 0xE7, 0xAD, 0x67 },
512
513     /*
514      * SHA-256 test vectors
515      */
516     { 0xBA, 0x78, 0x16, 0xBF, 0x8F, 0x01, 0xCF, 0xEA,
517       0x41, 0x41, 0x40, 0xDE, 0x5D, 0xAE, 0x22, 0x23,
518       0xB0, 0x03, 0x61, 0xA3, 0x96, 0x17, 0x7A, 0x9C,
519       0xB4, 0x10, 0xFF, 0x61, 0xF2, 0x00, 0x15, 0xAD },
520     { 0x24, 0x8D, 0x6A, 0x61, 0xD2, 0x06, 0x38, 0xB8,
521       0xE5, 0xC0, 0x26, 0x93, 0x0C, 0x3E, 0x60, 0x39,
522       0xA3, 0x3C, 0xE4, 0x59, 0x64, 0xFF, 0x21, 0x67,
523       0xF6, 0xEC, 0xED, 0xD4, 0x19, 0xDB, 0x06, 0xC1 },
524     { 0xCD, 0xC7, 0x6E, 0x5C, 0x99, 0x14, 0xFB, 0x92,
525       0x81, 0xA1, 0xC7, 0xE2, 0x84, 0xD7, 0x3E, 0x67,
526       0xF1, 0x80, 0x9A, 0x48, 0xA4, 0x97, 0x20, 0x0E,
527       0x04, 0x6D, 0x39, 0xCC, 0xC7, 0x11, 0x2C, 0xD0 }
528 };
529
530 /*
531  * RFC 4231 test vectors
532  */
533 static unsigned char sha2_hmac_test_key[7][26] = {
534         {"\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B"
535                     "\x0B\x0B\x0B\x0B"},
536         {"Jefe"},
537         {"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
538                     "\xAA\xAA\xAA\xAA"},
539         {"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10"
540                     "\x11\x12\x13\x14\x15\x16\x17\x18\x19"},
541         {"\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C"
542                     "\x0C\x0C\x0C\x0C"},
543         {""},                   /* 0xAA 131 times */
544         {""}
545 };
546
547 static const int sha2_hmac_test_keylen[7] = {
548         20, 4, 20, 25, 20, 131, 131
549 };
550
551 static unsigned char sha2_hmac_test_buf[7][153] =
552 {
553     { "Hi There" },
554     { "what do ya want for nothing?" },
555     { "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
556       "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
557       "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
558       "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
559       "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD" },
560     { "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
561       "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
562       "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
563       "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD"
564       "\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD" },
565     { "Test With Truncation" },
566     { "Test Using Larger Than Block-Size Key - Hash Key First" },
567     { "This is a test using a larger than block-size key "
568       "and a larger than block-size data. The key needs to "
569       "be hashed before being used by the HMAC algorithm." }
570 };
571
572 static const int sha2_hmac_test_buflen[7] =
573 {
574     8, 28, 50, 50, 20, 54, 152
575 };
576
577 static const unsigned char sha2_hmac_test_sum[14][32] =
578 {
579     /*
580      * HMAC-SHA-224 test vectors
581      */
582     { 0x89, 0x6F, 0xB1, 0x12, 0x8A, 0xBB, 0xDF, 0x19,
583       0x68, 0x32, 0x10, 0x7C, 0xD4, 0x9D, 0xF3, 0x3F,
584       0x47, 0xB4, 0xB1, 0x16, 0x99, 0x12, 0xBA, 0x4F,
585       0x53, 0x68, 0x4B, 0x22 },
586     { 0xA3, 0x0E, 0x01, 0x09, 0x8B, 0xC6, 0xDB, 0xBF,
587       0x45, 0x69, 0x0F, 0x3A, 0x7E, 0x9E, 0x6D, 0x0F,
588       0x8B, 0xBE, 0xA2, 0xA3, 0x9E, 0x61, 0x48, 0x00,
589       0x8F, 0xD0, 0x5E, 0x44 },
590     { 0x7F, 0xB3, 0xCB, 0x35, 0x88, 0xC6, 0xC1, 0xF6,
591       0xFF, 0xA9, 0x69, 0x4D, 0x7D, 0x6A, 0xD2, 0x64,
592       0x93, 0x65, 0xB0, 0xC1, 0xF6, 0x5D, 0x69, 0xD1,
593       0xEC, 0x83, 0x33, 0xEA },
594     { 0x6C, 0x11, 0x50, 0x68, 0x74, 0x01, 0x3C, 0xAC,
595       0x6A, 0x2A, 0xBC, 0x1B, 0xB3, 0x82, 0x62, 0x7C,
596       0xEC, 0x6A, 0x90, 0xD8, 0x6E, 0xFC, 0x01, 0x2D,
597       0xE7, 0xAF, 0xEC, 0x5A },
598     { 0x0E, 0x2A, 0xEA, 0x68, 0xA9, 0x0C, 0x8D, 0x37,
599       0xC9, 0x88, 0xBC, 0xDB, 0x9F, 0xCA, 0x6F, 0xA8 },
600     { 0x95, 0xE9, 0xA0, 0xDB, 0x96, 0x20, 0x95, 0xAD,
601       0xAE, 0xBE, 0x9B, 0x2D, 0x6F, 0x0D, 0xBC, 0xE2,
602       0xD4, 0x99, 0xF1, 0x12, 0xF2, 0xD2, 0xB7, 0x27,
603       0x3F, 0xA6, 0x87, 0x0E },
604     { 0x3A, 0x85, 0x41, 0x66, 0xAC, 0x5D, 0x9F, 0x02,
605       0x3F, 0x54, 0xD5, 0x17, 0xD0, 0xB3, 0x9D, 0xBD,
606       0x94, 0x67, 0x70, 0xDB, 0x9C, 0x2B, 0x95, 0xC9,
607       0xF6, 0xF5, 0x65, 0xD1 },
608
609     /*
610      * HMAC-SHA-256 test vectors
611      */
612     { 0xB0, 0x34, 0x4C, 0x61, 0xD8, 0xDB, 0x38, 0x53,
613       0x5C, 0xA8, 0xAF, 0xCE, 0xAF, 0x0B, 0xF1, 0x2B,
614       0x88, 0x1D, 0xC2, 0x00, 0xC9, 0x83, 0x3D, 0xA7,
615       0x26, 0xE9, 0x37, 0x6C, 0x2E, 0x32, 0xCF, 0xF7 },
616     { 0x5B, 0xDC, 0xC1, 0x46, 0xBF, 0x60, 0x75, 0x4E,
617       0x6A, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xC7,
618       0x5A, 0x00, 0x3F, 0x08, 0x9D, 0x27, 0x39, 0x83,
619       0x9D, 0xEC, 0x58, 0xB9, 0x64, 0xEC, 0x38, 0x43 },
620     { 0x77, 0x3E, 0xA9, 0x1E, 0x36, 0x80, 0x0E, 0x46,
621       0x85, 0x4D, 0xB8, 0xEB, 0xD0, 0x91, 0x81, 0xA7,
622       0x29, 0x59, 0x09, 0x8B, 0x3E, 0xF8, 0xC1, 0x22,
623       0xD9, 0x63, 0x55, 0x14, 0xCE, 0xD5, 0x65, 0xFE },
624     { 0x82, 0x55, 0x8A, 0x38, 0x9A, 0x44, 0x3C, 0x0E,
625       0xA4, 0xCC, 0x81, 0x98, 0x99, 0xF2, 0x08, 0x3A,
626       0x85, 0xF0, 0xFA, 0xA3, 0xE5, 0x78, 0xF8, 0x07,
627       0x7A, 0x2E, 0x3F, 0xF4, 0x67, 0x29, 0x66, 0x5B },
628     { 0xA3, 0xB6, 0x16, 0x74, 0x73, 0x10, 0x0E, 0xE0,
629       0x6E, 0x0C, 0x79, 0x6C, 0x29, 0x55, 0x55, 0x2B },
630     { 0x60, 0xE4, 0x31, 0x59, 0x1E, 0xE0, 0xB6, 0x7F,
631       0x0D, 0x8A, 0x26, 0xAA, 0xCB, 0xF5, 0xB7, 0x7F,
632       0x8E, 0x0B, 0xC6, 0x21, 0x37, 0x28, 0xC5, 0x14,
633       0x05, 0x46, 0x04, 0x0F, 0x0E, 0xE3, 0x7F, 0x54 },
634     { 0x9B, 0x09, 0xFF, 0xA7, 0x1B, 0x94, 0x2F, 0xCB,
635       0x27, 0x63, 0x5F, 0xBC, 0xD5, 0xB0, 0xE9, 0x44,
636       0xBF, 0xDC, 0x63, 0x64, 0x4F, 0x07, 0x13, 0x93,
637       0x8A, 0x7F, 0x51, 0x53, 0x5C, 0x3A, 0x35, 0xE2 }
638 };
639 typedef struct {
640         char *t;
641         char *p;
642         int plen;
643         char *s;
644         int slen;
645         int c;
646         int dkLen;
647         char dk[1024];          // Remember to set this to max dkLen
648 } testvector;
649
650 int do_test(testvector * tv)
651 {
652         printf("Started %s\n", tv->t);
653         fflush(stdout);
654         char *key = malloc(tv->dkLen);
655         if (key == 0) {
656                 return -1;
657         }
658
659         PKCS5_PBKDF2_HMAC((unsigned char*)tv->p, tv->plen,
660                         (unsigned char*)tv->s, tv->slen, tv->c,
661                         tv->dkLen, (unsigned char*)key);
662
663         if (memcmp(tv->dk, key, tv->dkLen) != 0) {
664                 // Failed
665                 return -1;
666         }
667
668         return 0;
669 }
670
671 /*
672  * Checkup routine
673  */
674 int main()
675 {
676         int verbose = 1;
677         int i, j, k, buflen;
678         unsigned char buf[1024];
679         unsigned char sha2sum[32];
680         sha2_context ctx;
681
682         for (i = 0; i < 6; i++) {
683                 j = i % 3;
684                 k = i < 3;
685
686                 if (verbose != 0)
687                         printf("  SHA-%d test #%d: ", 256 - k * 32, j + 1);
688
689                 sha2_starts(&ctx, k);
690
691                 if (j == 2) {
692                         memset(buf, 'a', buflen = 1000);
693
694                         for (j = 0; j < 1000; j++)
695                                 sha2_update(&ctx, buf, buflen);
696                 } else
697                         sha2_update(&ctx, sha2_test_buf[j],
698                             sha2_test_buflen[j]);
699
700                 sha2_finish(&ctx, sha2sum);
701
702                 if (memcmp(sha2sum, sha2_test_sum[i], 32 - k * 4) != 0) {
703                         if (verbose != 0)
704                                 printf("failed\n");
705
706                         return (1);
707                 }
708
709                 if (verbose != 0)
710                         printf("passed\n");
711         }
712
713         if (verbose != 0)
714                 printf("\n");
715
716         for (i = 0; i < 14; i++) {
717                 j = i % 7;
718                 k = i < 7;
719
720                 if (verbose != 0)
721                         printf("  HMAC-SHA-%d test #%d: ", 256 - k * 32,
722                             j + 1);
723
724                 if (j == 5 || j == 6) {
725                         memset(buf, '\xAA', buflen = 131);
726                         sha2_hmac_starts(&ctx, buf, buflen, k);
727                 } else
728                         sha2_hmac_starts(&ctx, sha2_hmac_test_key[j],
729                             sha2_hmac_test_keylen[j], k);
730
731                 sha2_hmac_update(&ctx, sha2_hmac_test_buf[j],
732                     sha2_hmac_test_buflen[j]);
733
734                 sha2_hmac_finish(&ctx, sha2sum);
735
736                 buflen = (j == 4) ? 16 : 32 - k * 4;
737
738                 if (memcmp(sha2sum, sha2_hmac_test_sum[i], buflen) != 0) {
739                         if (verbose != 0)
740                                 printf("failed\n");
741
742                         return (1);
743                 }
744
745                 if (verbose != 0)
746                         printf("passed\n");
747         }
748
749         if (verbose != 0)
750                 printf("\n");
751
752         testvector *tv = 0;
753         int res = 0;
754
755         testvector t1 = {
756                 "Test 1",
757                 "password", 8, "salt", 4, 1, 32,
758                 .dk = { 0x12, 0x0f, 0xb6, 0xcf, 0xfc, 0xf8, 0xb3, 0x2c,
759                         0x43, 0xe7, 0x22, 0x52, 0x56, 0xc4, 0xf8, 0x37,
760                         0xa8, 0x65, 0x48, 0xc9, 0x2c, 0xcc, 0x35, 0x48,
761                         0x08, 0x05, 0x98, 0x7c, 0xb7, 0x0b, 0xe1, 0x7b }
762         };
763
764         tv = &t1;
765         res = do_test(tv);
766         if (res != 0) {
767                 printf("%s failed\n", tv->t);
768                 return res;
769         }
770
771         testvector t2 = {
772                 "Test 2",
773                 "password", 8, "salt", 4, 2, 32, {
774                         0xae, 0x4d, 0x0c, 0x95, 0xaf, 0x6b, 0x46, 0xd3,
775                         0x2d, 0x0a, 0xdf, 0xf9, 0x28, 0xf0, 0x6d, 0xd0,
776                         0x2a, 0x30, 0x3f, 0x8e, 0xf3, 0xc2, 0x51, 0xdf,
777                         0xd6, 0xe2, 0xd8, 0x5a, 0x95, 0x47, 0x4c, 0x43 }
778         };
779
780         tv = &t2;
781         res = do_test(tv);
782         if (res != 0) {
783                 printf("%s failed\n", tv->t);
784                 return res;
785         }
786
787         testvector t3 = {
788                 "Test 3",
789                 "password", 8, "salt", 4, 4096, 32, {
790                         0xc5, 0xe4, 0x78, 0xd5, 0x92, 0x88, 0xc8, 0x41,
791                         0xaa, 0x53, 0x0d, 0xb6, 0x84, 0x5c, 0x4c, 0x8d,
792                         0x96, 0x28, 0x93, 0xa0, 0x01, 0xce, 0x4e, 0x11,
793                         0xa4, 0x96, 0x38, 0x73, 0xaa, 0x98, 0x13, 0x4a }
794         };
795
796         tv = &t3;
797         res = do_test(tv);
798         if (res != 0) {
799                 printf("%s failed\n", tv->t);
800                 return res;
801         }
802
803         testvector t4 = {
804                 "Test 4",
805                 "password", 8, "salt", 4, 16777216, 32, {
806                         0xcf, 0x81, 0xc6, 0x6f, 0xe8, 0xcf, 0xc0, 0x4d,
807                         0x1f, 0x31, 0xec, 0xb6, 0x5d, 0xab, 0x40, 0x89,
808                         0xf7, 0xf1, 0x79, 0xe8, 0x9b, 0x3b, 0x0b, 0xcb,
809                         0x17, 0xad, 0x10, 0xe3, 0xac, 0x6e, 0xba, 0x46 }
810         };
811
812         tv = &t4;
813         // res = do_test(tv);
814         if (res != 0) {
815                 printf("%s failed\n", tv->t);
816                 return res;
817         }
818
819         testvector t5 = {
820                 "Test 5",
821                 "passwordPASSWORDpassword", 24,
822                 "saltSALTsaltSALTsaltSALTsaltSALTsalt", 36, 4096, 40, {
823                         0x34, 0x8c, 0x89, 0xdb, 0xcb, 0xd3, 0x2b, 0x2f,
824                         0x32, 0xd8, 0x14, 0xb8, 0x11, 0x6e, 0x84, 0xcf,
825                         0x2b, 0x17, 0x34, 0x7e, 0xbc, 0x18, 0x00, 0x18,
826                         0x1c, 0x4e, 0x2a, 0x1f, 0xb8, 0xdd, 0x53, 0xe1,
827                         0xc6, 0x35, 0x51, 0x8c, 0x7d, 0xac, 0x47, 0xe9 }
828         };
829
830         tv = &t5;
831         res = do_test(tv);
832         if (res != 0) {
833                 printf("%s failed\n", tv->t);
834                 return res;
835         }
836
837         testvector t6 = {
838                 "Test 6",
839                 "pass\0word", 9, "sa\0lt", 5, 4096, 16, {
840                         0x89, 0xb6, 0x9d, 0x05, 0x16, 0xf8, 0x29, 0x89,
841                         0x3c, 0x69, 0x62, 0x26, 0x65, 0x0a, 0x86, 0x87 }
842         };
843
844         tv = &t6;
845         res = do_test(tv);
846         if (res != 0) {
847                 printf("%s failed\n", tv->t);
848                 return res;
849         }
850
851         return (0);
852 }
853
854 #endif