Fixed HMAC for SHA-384 and SHA-512 with keys longer than 64 bytes.
[libgcrypt.git] / cipher / hmac-tests.c
1 /* hmac-tests.c - HMAC selftests.
2  * Copyright (C) 2008 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 /* 
21    Although algorithm self-tests are usually implemented in the module
22    implementing the algorithm, the case for HMAC is different because
23    HMAC is implemnetd on a higher level using a special feature of the
24    gcry_md_ functions.  It would be possible to do this also in the
25    digest algorithm modules, but that would blow up the code too much
26    and spread the hmac tests over several modules.
27
28    Thus we implement all HMAC tests in this test module and provide a
29    function to run the tests.
30 */
31
32 #include <config.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #ifdef HAVE_STDINT_H 
37 # include <stdint.h>
38 #endif
39
40 #include "g10lib.h"
41 #include "cipher.h"
42 #include "hmac256.h"
43
44 /* Check one HMAC with digest ALGO using the regualr HAMC
45    API. (DATA,DATALEN) is the data to be MACed, (KEY,KEYLEN) the key
46    and (EXPECT,EXPECTLEN) the expected result.  Returns NULL on
47    succdess or a string describing the failure.  */
48 static const char *
49 check_one (int algo,
50            const void *data, size_t datalen, 
51            const void *key, size_t keylen,
52            const void *expect, size_t expectlen)
53 {
54   gcry_md_hd_t hd;
55   const unsigned char *digest;
56
57 /*   printf ("HMAC algo %d\n", algo); */
58   if (_gcry_md_get_algo_dlen (algo) != expectlen)
59     return "invalid tests data";
60   if (_gcry_md_open (&hd, algo, GCRY_MD_FLAG_HMAC))
61     return "gcry_md_open failed";
62   if (_gcry_md_setkey (hd, key, keylen))
63     {
64       _gcry_md_close (hd);
65       return "gcry_md_setkey failed";
66     }
67   _gcry_md_write (hd, data, datalen);
68   digest = _gcry_md_read (hd, algo);
69   if (!digest)
70     {
71       _gcry_md_close (hd);
72       return "gcry_md_read failed";
73     }
74   if (memcmp (digest, expect, expectlen))
75     {
76 /*       int i; */
77
78 /*       fputs ("        {", stdout); */
79 /*       for (i=0; i < expectlen-1; i++) */
80 /*         { */
81 /*           if (i && !(i % 8)) */
82 /*             fputs ("\n         ", stdout); */
83 /*           printf (" 0x%02x,", digest[i]); */
84 /*         } */
85 /*       printf (" 0x%02x } },\n", digest[i]); */
86
87       _gcry_md_close (hd);
88       return "does not match";
89     }
90   _gcry_md_close (hd);
91   return NULL;  
92 }
93
94
95 static gpg_err_code_t
96 selftests_sha1 (int extended, selftest_report_func_t report)
97 {
98   const char *what;
99   const char *errtxt;
100   unsigned char key[128];
101   int i, j;
102
103   what = "FIPS-198a, A.1";
104   for (i=0; i < 64; i++)
105     key[i] = i;
106   errtxt = check_one (GCRY_MD_SHA1,
107                       "Sample #1", 9,
108                       key, 64,
109                       "\x4f\x4c\xa3\xd5\xd6\x8b\xa7\xcc\x0a\x12"
110                       "\x08\xc9\xc6\x1e\x9c\x5d\xa0\x40\x3c\x0a", 20);
111   if (errtxt)
112     goto failed;
113
114   if (extended)
115     {
116       what = "FIPS-198a, A.2";
117       for (i=0, j=0x30; i < 20; i++)
118         key[i] = j++;
119       errtxt = check_one (GCRY_MD_SHA1,
120                           "Sample #2", 9,
121                           key, 20,
122                           "\x09\x22\xd3\x40\x5f\xaa\x3d\x19\x4f\x82"
123                           "\xa4\x58\x30\x73\x7d\x5c\xc6\xc7\x5d\x24", 20);
124       if (errtxt)
125         goto failed;
126       
127       what = "FIPS-198a, A.3";
128       for (i=0, j=0x50; i < 100; i++)
129         key[i] = j++;
130       errtxt = check_one (GCRY_MD_SHA1,
131                           "Sample #3", 9,
132                           key, 100,
133                           "\xbc\xf4\x1e\xab\x8b\xb2\xd8\x02\xf3\xd0"
134                           "\x5c\xaf\x7c\xb0\x92\xec\xf8\xd1\xa3\xaa", 20 );
135       if (errtxt)
136         goto failed;
137       
138       what = "FIPS-198a, A.4";
139       for (i=0, j=0x70; i < 49; i++)
140         key[i] = j++;
141       errtxt = check_one (GCRY_MD_SHA1,
142                           "Sample #4", 9,
143                           key, 49,
144                           "\x9e\xa8\x86\xef\xe2\x68\xdb\xec\xce\x42"
145                           "\x0c\x75\x24\xdf\x32\xe0\x75\x1a\x2a\x26", 20 );
146       if (errtxt)
147         goto failed;
148     }
149
150   return 0; /* Succeeded. */
151
152  failed:
153   if (report)
154     report ("hmac", GCRY_MD_SHA1, what, errtxt);
155   return GPG_ERR_SELFTEST_FAILED;
156 }
157
158
159
160 static gpg_err_code_t
161 selftests_sha224 (int extended, selftest_report_func_t report)
162 {
163   static struct 
164   {
165     const char * const desc;
166     const char * const data;
167     const char * const key;
168     const char expect[28];
169   } tv[] =
170     {
171       { "data-28 key-4",
172         "what do ya want for nothing?", 
173         "Jefe",
174         { 0xa3, 0x0e, 0x01, 0x09, 0x8b, 0xc6, 0xdb, 0xbf,
175           0x45, 0x69, 0x0f, 0x3a, 0x7e, 0x9e, 0x6d, 0x0f,
176           0x8b, 0xbe, 0xa2, 0xa3, 0x9e, 0x61, 0x48, 0x00,
177           0x8f, 0xd0, 0x5e, 0x44 } },
178
179       { "data-9 key-20",
180         "Hi There",
181         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
182         "\x0b\x0b\x0b\x0b",
183         { 0x89, 0x6f, 0xb1, 0x12, 0x8a, 0xbb, 0xdf, 0x19,
184           0x68, 0x32, 0x10, 0x7c, 0xd4, 0x9d, 0xf3, 0x3f,
185           0x47, 0xb4, 0xb1, 0x16, 0x99, 0x12, 0xba, 0x4f,
186           0x53, 0x68, 0x4b, 0x22 } },
187
188       { "data-50 key-20",
189         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
190         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
191         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
192         "\xdd\xdd",
193         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
194         "\xaa\xaa\xaa\xaa",
195         { 0x7f, 0xb3, 0xcb, 0x35, 0x88, 0xc6, 0xc1, 0xf6,
196           0xff, 0xa9, 0x69, 0x4d, 0x7d, 0x6a, 0xd2, 0x64,
197           0x93, 0x65, 0xb0, 0xc1, 0xf6, 0x5d, 0x69, 0xd1,
198           0xec, 0x83, 0x33, 0xea } },
199
200       { "data-50 key-26",
201         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
202         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
203         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
204         "\xcd\xcd",
205         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
206         "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
207         { 0x6c, 0x11, 0x50, 0x68, 0x74, 0x01, 0x3c, 0xac,
208           0x6a, 0x2a, 0xbc, 0x1b, 0xb3, 0x82, 0x62, 0x7c,
209           0xec, 0x6a, 0x90, 0xd8, 0x6e, 0xfc, 0x01, 0x2d,
210           0xe7, 0xaf, 0xec, 0x5a } },
211
212       { "data-54 key-131",
213         "Test Using Larger Than Block-Size Key - Hash Key First",
214         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
215         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
216         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
217         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
218         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
219         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
220         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
221         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
222         "\xaa\xaa\xaa",
223         { 0x95, 0xe9, 0xa0, 0xdb, 0x96, 0x20, 0x95, 0xad,
224           0xae, 0xbe, 0x9b, 0x2d, 0x6f, 0x0d, 0xbc, 0xe2,
225           0xd4, 0x99, 0xf1, 0x12, 0xf2, 0xd2, 0xb7, 0x27,
226           0x3f, 0xa6, 0x87, 0x0e } },
227
228       { "data-152 key-131",
229         "This is a test using a larger than block-size key and a larger "
230         "than block-size data. The key needs to be hashed before being "
231         "used by the HMAC algorithm.",
232         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
233         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
234         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
235         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
236         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
237         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
238         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
239         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
240         "\xaa\xaa\xaa",
241         { 0x3a, 0x85, 0x41, 0x66, 0xac, 0x5d, 0x9f, 0x02,
242           0x3f, 0x54, 0xd5, 0x17, 0xd0, 0xb3, 0x9d, 0xbd,
243           0x94, 0x67, 0x70, 0xdb, 0x9c, 0x2b, 0x95, 0xc9,
244           0xf6, 0xf5, 0x65, 0xd1 } },
245
246       { NULL }
247     };
248   const char *what;
249   const char *errtxt;
250   int tvidx;
251   
252   for (tvidx=0; tv[tvidx].desc; tvidx++)
253     {
254       what = tv[tvidx].desc;
255       errtxt = check_one (GCRY_MD_SHA224,
256                           tv[tvidx].data, strlen (tv[tvidx].data),
257                           tv[tvidx].key, strlen (tv[tvidx].key),
258                           tv[tvidx].expect, DIM (tv[tvidx].expect) );
259       if (errtxt)
260         goto failed;
261       if (!extended)
262         break;
263     }
264
265   return 0; /* Succeeded. */
266
267  failed:
268   if (report)
269     report ("hmac", GCRY_MD_SHA224, what, errtxt);
270   return GPG_ERR_SELFTEST_FAILED;
271 }
272
273
274 static gpg_err_code_t
275 selftests_sha256 (int extended, selftest_report_func_t report)
276 {
277   static struct 
278   {
279     const char * const desc;
280     const char * const data;
281     const char * const key;
282     const char expect[32];
283   } tv[] =
284     {
285       { "data-28 key-4",
286         "what do ya want for nothing?", 
287         "Jefe",
288         { 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
289           0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7,
290           0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83,
291           0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43 } },
292
293       { "data-9 key-20",
294         "Hi There",
295         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
296         "\x0b\x0b\x0b\x0b",
297         { 0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
298           0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b,
299           0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7,
300           0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7 } },
301
302       { "data-50 key-20",
303         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
304         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
305         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
306         "\xdd\xdd",
307         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
308         "\xaa\xaa\xaa\xaa",
309         { 0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46,
310           0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7,
311           0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22,
312           0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe } },
313
314       { "data-50 key-26",
315         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
316         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
317         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
318         "\xcd\xcd",
319         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
320         "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
321         { 0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e,
322           0xa4, 0xcc, 0x81, 0x98, 0x99, 0xf2, 0x08, 0x3a,
323           0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07,
324           0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b } },
325
326       { "data-54 key-131",
327         "Test Using Larger Than Block-Size Key - Hash Key First",
328         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
329         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
330         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
331         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
332         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
333         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
334         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
335         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
336         "\xaa\xaa\xaa",
337         { 0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f,
338           0x0d, 0x8a, 0x26, 0xaa, 0xcb, 0xf5, 0xb7, 0x7f,
339           0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14,
340           0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54 } },
341
342       { "data-152 key-131",
343         "This is a test using a larger than block-size key and a larger "
344         "than block-size data. The key needs to be hashed before being "
345         "used by the HMAC algorithm.",
346         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
347         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
348         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
349         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
350         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
351         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
352         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
353         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
354         "\xaa\xaa\xaa",
355         { 0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb,
356           0x27, 0x63, 0x5f, 0xbc, 0xd5, 0xb0, 0xe9, 0x44,
357           0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93,
358           0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2 } },
359
360       { NULL }
361     };
362   const char *what;
363   const char *errtxt;
364   int tvidx;
365   
366   for (tvidx=0; tv[tvidx].desc; tvidx++)
367     {
368       hmac256_context_t hmachd;
369       const unsigned char *digest;
370       size_t dlen;
371
372       what = tv[tvidx].desc;
373       errtxt = check_one (GCRY_MD_SHA256,
374                           tv[tvidx].data, strlen (tv[tvidx].data),
375                           tv[tvidx].key, strlen (tv[tvidx].key),
376                           tv[tvidx].expect, DIM (tv[tvidx].expect) );
377       if (errtxt)
378         goto failed;
379
380       hmachd = _gcry_hmac256_new (tv[tvidx].key, strlen (tv[tvidx].key));
381       if (!hmachd)
382         {
383           errtxt = "_gcry_hmac256_new failed";
384           goto failed;
385         }
386       _gcry_hmac256_update (hmachd, tv[tvidx].data, strlen (tv[tvidx].data));
387       digest = _gcry_hmac256_finalize (hmachd, &dlen);
388       if (!digest)
389         {
390           errtxt = "_gcry_hmac256_finalize failed";
391           _gcry_hmac256_release (hmachd);
392           goto failed;
393         }
394       if (dlen != DIM (tv[tvidx].expect)
395           || memcmp (digest, tv[tvidx].expect, DIM (tv[tvidx].expect)))
396         {
397           errtxt = "does not match in second implementation";
398           _gcry_hmac256_release (hmachd);
399           goto failed;
400         }
401       _gcry_hmac256_release (hmachd);
402
403       if (!extended)
404         break;
405     }
406
407   return 0; /* Succeeded. */
408
409  failed:
410   if (report)
411     report ("hmac", GCRY_MD_SHA256, what, errtxt);
412   return GPG_ERR_SELFTEST_FAILED;
413 }
414
415
416 static gpg_err_code_t
417 selftests_sha384 (int extended, selftest_report_func_t report)
418 {
419   static struct 
420   {
421     const char * const desc;
422     const char * const data;
423     const char * const key;
424     const char expect[48];
425   } tv[] =
426     {
427       { "data-28 key-4",
428         "what do ya want for nothing?", 
429         "Jefe",
430         { 0xaf, 0x45, 0xd2, 0xe3, 0x76, 0x48, 0x40, 0x31,
431           0x61, 0x7f, 0x78, 0xd2, 0xb5, 0x8a, 0x6b, 0x1b,
432           0x9c, 0x7e, 0xf4, 0x64, 0xf5, 0xa0, 0x1b, 0x47,
433           0xe4, 0x2e, 0xc3, 0x73, 0x63, 0x22, 0x44, 0x5e,
434           0x8e, 0x22, 0x40, 0xca, 0x5e, 0x69, 0xe2, 0xc7,
435           0x8b, 0x32, 0x39, 0xec, 0xfa, 0xb2, 0x16, 0x49 } },
436
437       { "data-9 key-20",
438         "Hi There",
439         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
440         "\x0b\x0b\x0b\x0b",
441         { 0xaf, 0xd0, 0x39, 0x44, 0xd8, 0x48, 0x95, 0x62,
442           0x6b, 0x08, 0x25, 0xf4, 0xab, 0x46, 0x90, 0x7f,
443           0x15, 0xf9, 0xda, 0xdb, 0xe4, 0x10, 0x1e, 0xc6,
444           0x82, 0xaa, 0x03, 0x4c, 0x7c, 0xeb, 0xc5, 0x9c,
445           0xfa, 0xea, 0x9e, 0xa9, 0x07, 0x6e, 0xde, 0x7f,
446           0x4a, 0xf1, 0x52, 0xe8, 0xb2, 0xfa, 0x9c, 0xb6 } },
447
448       { "data-50 key-20",
449         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
450         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
451         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
452         "\xdd\xdd",
453         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
454         "\xaa\xaa\xaa\xaa",
455         { 0x88, 0x06, 0x26, 0x08, 0xd3, 0xe6, 0xad, 0x8a,
456           0x0a, 0xa2, 0xac, 0xe0, 0x14, 0xc8, 0xa8, 0x6f,
457           0x0a, 0xa6, 0x35, 0xd9, 0x47, 0xac, 0x9f, 0xeb,
458           0xe8, 0x3e, 0xf4, 0xe5, 0x59, 0x66, 0x14, 0x4b,
459           0x2a, 0x5a, 0xb3, 0x9d, 0xc1, 0x38, 0x14, 0xb9,
460           0x4e, 0x3a, 0xb6, 0xe1, 0x01, 0xa3, 0x4f, 0x27 } },
461
462       { "data-50 key-26",
463         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
464         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
465         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
466         "\xcd\xcd",
467         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
468         "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
469         { 0x3e, 0x8a, 0x69, 0xb7, 0x78, 0x3c, 0x25, 0x85,
470           0x19, 0x33, 0xab, 0x62, 0x90, 0xaf, 0x6c, 0xa7,
471           0x7a, 0x99, 0x81, 0x48, 0x08, 0x50, 0x00, 0x9c,
472           0xc5, 0x57, 0x7c, 0x6e, 0x1f, 0x57, 0x3b, 0x4e,
473           0x68, 0x01, 0xdd, 0x23, 0xc4, 0xa7, 0xd6, 0x79,
474           0xcc, 0xf8, 0xa3, 0x86, 0xc6, 0x74, 0xcf, 0xfb } },
475
476       { "data-54 key-131",
477         "Test Using Larger Than Block-Size Key - Hash Key First",
478         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
479         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
480         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
481         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
482         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
483         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
484         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
485         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
486         "\xaa\xaa\xaa",
487         { 0x4e, 0xce, 0x08, 0x44, 0x85, 0x81, 0x3e, 0x90,
488           0x88, 0xd2, 0xc6, 0x3a, 0x04, 0x1b, 0xc5, 0xb4,
489           0x4f, 0x9e, 0xf1, 0x01, 0x2a, 0x2b, 0x58, 0x8f,
490           0x3c, 0xd1, 0x1f, 0x05, 0x03, 0x3a, 0xc4, 0xc6,
491           0x0c, 0x2e, 0xf6, 0xab, 0x40, 0x30, 0xfe, 0x82,
492           0x96, 0x24, 0x8d, 0xf1, 0x63, 0xf4, 0x49, 0x52 } },
493
494       { "data-152 key-131",
495         "This is a test using a larger than block-size key and a larger "
496         "than block-size data. The key needs to be hashed before being "
497         "used by the HMAC algorithm.",
498         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
499         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
500         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
501         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
502         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
503         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
504         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
505         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
506         "\xaa\xaa\xaa",
507         { 0x66, 0x17, 0x17, 0x8e, 0x94, 0x1f, 0x02, 0x0d,
508           0x35, 0x1e, 0x2f, 0x25, 0x4e, 0x8f, 0xd3, 0x2c,
509           0x60, 0x24, 0x20, 0xfe, 0xb0, 0xb8, 0xfb, 0x9a,
510           0xdc, 0xce, 0xbb, 0x82, 0x46, 0x1e, 0x99, 0xc5,
511           0xa6, 0x78, 0xcc, 0x31, 0xe7, 0x99, 0x17, 0x6d,
512           0x38, 0x60, 0xe6, 0x11, 0x0c, 0x46, 0x52, 0x3e } },
513
514       { NULL }
515     };
516   const char *what;
517   const char *errtxt;
518   int tvidx;
519   
520   for (tvidx=0; tv[tvidx].desc; tvidx++)
521     {
522       what = tv[tvidx].desc;
523       errtxt = check_one (GCRY_MD_SHA384,
524                           tv[tvidx].data, strlen (tv[tvidx].data),
525                           tv[tvidx].key, strlen (tv[tvidx].key),
526                           tv[tvidx].expect, DIM (tv[tvidx].expect) );
527       if (errtxt)
528         goto failed;
529       if (!extended)
530         break;
531     }
532
533   return 0; /* Succeeded. */
534
535  failed:
536   if (report)
537     report ("hmac", GCRY_MD_SHA384, what, errtxt);
538   return GPG_ERR_SELFTEST_FAILED;
539 }
540
541
542 static gpg_err_code_t
543 selftests_sha512 (int extended, selftest_report_func_t report)
544 {
545   static struct 
546   {
547     const char * const desc;
548     const char * const data;
549     const char * const key;
550     const char expect[64];
551   } tv[] =
552     {
553       { "data-28 key-4",
554         "what do ya want for nothing?", 
555         "Jefe",
556         { 0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2,
557           0xe3, 0x95, 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3,
558           0x87, 0xbd, 0x64, 0x22, 0x2e, 0x83, 0x1f, 0xd6,
559           0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, 0x05, 0x54,
560           0x97, 0x58, 0xbf, 0x75, 0xc0, 0x5a, 0x99, 0x4a,
561           0x6d, 0x03, 0x4f, 0x65, 0xf8, 0xf0, 0xe6, 0xfd,
562           0xca, 0xea, 0xb1, 0xa3, 0x4d, 0x4a, 0x6b, 0x4b,
563           0x63, 0x6e, 0x07, 0x0a, 0x38, 0xbc, 0xe7, 0x37 } },
564
565       { "data-9 key-20",
566         "Hi There",
567         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
568         "\x0b\x0b\x0b\x0b",
569         { 0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d,
570           0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0,
571           0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78,
572           0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde,
573           0xda, 0xa8, 0x33, 0xb7, 0xd6, 0xb8, 0xa7, 0x02,
574           0x03, 0x8b, 0x27, 0x4e, 0xae, 0xa3, 0xf4, 0xe4,
575           0xbe, 0x9d, 0x91, 0x4e, 0xeb, 0x61, 0xf1, 0x70,
576           0x2e, 0x69, 0x6c, 0x20, 0x3a, 0x12, 0x68, 0x54 } },
577
578       { "data-50 key-20",
579         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
580         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
581         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
582         "\xdd\xdd",
583         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
584         "\xaa\xaa\xaa\xaa",
585         { 0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84,
586           0xef, 0xb0, 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9,
587           0xb1, 0xb5, 0xdb, 0xdd, 0x8e, 0xe8, 0x1a, 0x36,
588           0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, 0x9d, 0x39,
589           0xbf, 0x3e, 0x84, 0x82, 0x79, 0xa7, 0x22, 0xc8,
590           0x06, 0xb4, 0x85, 0xa4, 0x7e, 0x67, 0xc8, 0x07,
591           0xb9, 0x46, 0xa3, 0x37, 0xbe, 0xe8, 0x94, 0x26,
592           0x74, 0x27, 0x88, 0x59, 0xe1, 0x32, 0x92, 0xfb } },
593
594       { "data-50 key-26",
595         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
596         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
597         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
598         "\xcd\xcd",
599         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
600         "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
601         { 0xb0, 0xba, 0x46, 0x56, 0x37, 0x45, 0x8c, 0x69,
602           0x90, 0xe5, 0xa8, 0xc5, 0xf6, 0x1d, 0x4a, 0xf7,
603           0xe5, 0x76, 0xd9, 0x7f, 0xf9, 0x4b, 0x87, 0x2d,
604           0xe7, 0x6f, 0x80, 0x50, 0x36, 0x1e, 0xe3, 0xdb,
605           0xa9, 0x1c, 0xa5, 0xc1, 0x1a, 0xa2, 0x5e, 0xb4,
606           0xd6, 0x79, 0x27, 0x5c, 0xc5, 0x78, 0x80, 0x63,
607           0xa5, 0xf1, 0x97, 0x41, 0x12, 0x0c, 0x4f, 0x2d,
608           0xe2, 0xad, 0xeb, 0xeb, 0x10, 0xa2, 0x98, 0xdd } },
609
610       { "data-54 key-131",
611         "Test Using Larger Than Block-Size Key - Hash Key First",
612         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
613         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
614         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
615         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
616         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
617         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
618         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
619         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
620         "\xaa\xaa\xaa",
621         { 0x80, 0xb2, 0x42, 0x63, 0xc7, 0xc1, 0xa3, 0xeb,
622           0xb7, 0x14, 0x93, 0xc1, 0xdd, 0x7b, 0xe8, 0xb4,
623           0x9b, 0x46, 0xd1, 0xf4, 0x1b, 0x4a, 0xee, 0xc1,
624           0x12, 0x1b, 0x01, 0x37, 0x83, 0xf8, 0xf3, 0x52,
625           0x6b, 0x56, 0xd0, 0x37, 0xe0, 0x5f, 0x25, 0x98,
626           0xbd, 0x0f, 0xd2, 0x21, 0x5d, 0x6a, 0x1e, 0x52,
627           0x95, 0xe6, 0x4f, 0x73, 0xf6, 0x3f, 0x0a, 0xec,
628           0x8b, 0x91, 0x5a, 0x98, 0x5d, 0x78, 0x65, 0x98 } },
629
630       { "data-152 key-131",
631         "This is a test using a larger than block-size key and a larger "
632         "than block-size data. The key needs to be hashed before being "
633         "used by the HMAC algorithm.",
634         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
635         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
636         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
637         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
638         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
639         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
640         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
641         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
642         "\xaa\xaa\xaa",
643         { 0xe3, 0x7b, 0x6a, 0x77, 0x5d, 0xc8, 0x7d, 0xba,
644           0xa4, 0xdf, 0xa9, 0xf9, 0x6e, 0x5e, 0x3f, 0xfd,
645           0xde, 0xbd, 0x71, 0xf8, 0x86, 0x72, 0x89, 0x86,
646           0x5d, 0xf5, 0xa3, 0x2d, 0x20, 0xcd, 0xc9, 0x44,
647           0xb6, 0x02, 0x2c, 0xac, 0x3c, 0x49, 0x82, 0xb1,
648           0x0d, 0x5e, 0xeb, 0x55, 0xc3, 0xe4, 0xde, 0x15,
649           0x13, 0x46, 0x76, 0xfb, 0x6d, 0xe0, 0x44, 0x60,
650           0x65, 0xc9, 0x74, 0x40, 0xfa, 0x8c, 0x6a, 0x58 } },
651
652       { NULL }
653     };
654   const char *what;
655   const char *errtxt;
656   int tvidx;
657   
658   for (tvidx=0; tv[tvidx].desc; tvidx++)
659     {
660       what = tv[tvidx].desc;
661       errtxt = check_one (GCRY_MD_SHA512,
662                           tv[tvidx].data, strlen (tv[tvidx].data),
663                           tv[tvidx].key, strlen (tv[tvidx].key),
664                           tv[tvidx].expect, DIM (tv[tvidx].expect) );
665       if (errtxt)
666         goto failed;
667       if (!extended)
668         break;
669     }
670
671   return 0; /* Succeeded. */
672
673  failed:
674   if (report)
675     report ("hmac", GCRY_MD_SHA512, what, errtxt);
676   return GPG_ERR_SELFTEST_FAILED;
677 }
678
679
680
681 /* Run a full self-test for ALGO and return 0 on success.  */
682 static gpg_err_code_t
683 run_selftests (int algo, int extended, selftest_report_func_t report)
684 {
685   gpg_err_code_t ec;
686
687   switch (algo)
688     {
689     case GCRY_MD_SHA1:
690       ec = selftests_sha1 (extended, report);
691       break;
692     case GCRY_MD_SHA224:
693       ec = selftests_sha224 (extended, report);
694       break;
695     case GCRY_MD_SHA256:
696       ec = selftests_sha256 (extended, report);
697       break;
698     case GCRY_MD_SHA384:
699       ec = selftests_sha384 (extended, report);
700       break;
701     case GCRY_MD_SHA512:
702       ec = selftests_sha512 (extended, report);
703       break;
704     default:
705       ec = GPG_ERR_DIGEST_ALGO;
706       break;
707     }
708   return ec;
709 }
710
711
712
713
714 /* Run the selftests for HMAC with digest algorithm ALGO with optional
715    reporting function REPORT.  */
716 gpg_error_t
717 _gcry_hmac_selftest (int algo, int extended, selftest_report_func_t report)
718 {
719   gcry_err_code_t ec = 0;
720
721   if (!gcry_md_test_algo (algo))
722     {
723       ec = run_selftests (algo, extended, report);
724     }
725   else
726     {
727       ec = GPG_ERR_DIGEST_ALGO;
728       if (report)
729         report ("hmac", algo, "module", "algorithm not available");
730     }
731   return gpg_error (ec);
732 }