pkgconfig: Fix libgcrypt.pc.
[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 implemented 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    To run all the Libgcrypt selftest in a verbose mode, use
32
33    $ tests/basic --selftest
34
35 */
36
37 #include <config.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #ifdef HAVE_STDINT_H
42 # include <stdint.h>
43 #endif
44
45 #include "g10lib.h"
46 #include "cipher.h"
47 #include "hmac256.h"
48
49 /* Check one HMAC with digest ALGO using the regualr HAMC
50  * API. (DATA,DATALEN) is the data to be MACed, (KEY,KEYLEN) the key
51  * and (EXPECT,EXPECTLEN) the expected result.  If TRUNC is set, the
52  * EXPECTLEN may be less than the digest length.  Returns NULL on
53  * success or a string describing the failure.  */
54 static const char *
55 check_one (int algo,
56            const void *data, size_t datalen,
57            const void *key, size_t keylen,
58            const void *expect, size_t expectlen, int trunc)
59 {
60   gcry_md_hd_t hd;
61   const unsigned char *digest;
62
63 /*   printf ("HMAC algo %d\n", algo); */
64   if (trunc)
65     {
66       if (_gcry_md_get_algo_dlen (algo) < expectlen)
67         return "invalid tests data";
68     }
69   else
70     {
71       if (_gcry_md_get_algo_dlen (algo) != expectlen)
72         return "invalid tests data";
73     }
74   if (_gcry_md_open (&hd, algo, GCRY_MD_FLAG_HMAC))
75     return "gcry_md_open failed";
76   if (_gcry_md_setkey (hd, key, keylen))
77     {
78       _gcry_md_close (hd);
79       return "gcry_md_setkey failed";
80     }
81   _gcry_md_write (hd, data, datalen);
82   digest = _gcry_md_read (hd, algo);
83   if (!digest)
84     {
85       _gcry_md_close (hd);
86       return "gcry_md_read failed";
87     }
88   if (memcmp (digest, expect, expectlen))
89     {
90 /*       int i; */
91
92 /*       fputs ("        {", stdout); */
93 /*       for (i=0; i < expectlen-1; i++) */
94 /*         { */
95 /*           if (i && !(i % 8)) */
96 /*             fputs ("\n         ", stdout); */
97 /*           printf (" 0x%02x,", digest[i]); */
98 /*         } */
99 /*       printf (" 0x%02x } },\n", digest[i]); */
100
101       _gcry_md_close (hd);
102       return "does not match";
103     }
104   _gcry_md_close (hd);
105   return NULL;
106 }
107
108
109 static gpg_err_code_t
110 selftests_sha1 (int extended, selftest_report_func_t report)
111 {
112   const char *what;
113   const char *errtxt;
114   unsigned char key[128];
115   int i, j;
116
117   what = "FIPS-198a, A.1";
118   for (i=0; i < 64; i++)
119     key[i] = i;
120   errtxt = check_one (GCRY_MD_SHA1,
121                       "Sample #1", 9,
122                       key, 64,
123                       "\x4f\x4c\xa3\xd5\xd6\x8b\xa7\xcc\x0a\x12"
124                       "\x08\xc9\xc6\x1e\x9c\x5d\xa0\x40\x3c\x0a", 20, 0);
125   if (errtxt)
126     goto failed;
127
128   if (extended)
129     {
130       what = "FIPS-198a, A.2";
131       for (i=0, j=0x30; i < 20; i++)
132         key[i] = j++;
133       errtxt = check_one (GCRY_MD_SHA1,
134                           "Sample #2", 9,
135                           key, 20,
136                           "\x09\x22\xd3\x40\x5f\xaa\x3d\x19\x4f\x82"
137                           "\xa4\x58\x30\x73\x7d\x5c\xc6\xc7\x5d\x24", 20, 0);
138       if (errtxt)
139         goto failed;
140
141       what = "FIPS-198a, A.3";
142       for (i=0, j=0x50; i < 100; i++)
143         key[i] = j++;
144       errtxt = check_one (GCRY_MD_SHA1,
145                           "Sample #3", 9,
146                           key, 100,
147                           "\xbc\xf4\x1e\xab\x8b\xb2\xd8\x02\xf3\xd0"
148                           "\x5c\xaf\x7c\xb0\x92\xec\xf8\xd1\xa3\xaa", 20, 0);
149       if (errtxt)
150         goto failed;
151
152       what = "FIPS-198a, A.4";
153       for (i=0, j=0x70; i < 49; i++)
154         key[i] = j++;
155       errtxt = check_one (GCRY_MD_SHA1,
156                           "Sample #4", 9,
157                           key, 49,
158                           "\x9e\xa8\x86\xef\xe2\x68\xdb\xec\xce\x42"
159                           "\x0c\x75\x24\xdf\x32\xe0\x75\x1a\x2a\x26", 20, 0);
160       if (errtxt)
161         goto failed;
162     }
163
164   return 0; /* Succeeded. */
165
166  failed:
167   if (report)
168     report ("hmac", GCRY_MD_SHA1, what, errtxt);
169   return GPG_ERR_SELFTEST_FAILED;
170 }
171
172
173
174 static gpg_err_code_t
175 selftests_sha224 (int extended, selftest_report_func_t report)
176 {
177   static struct
178   {
179     const char * const desc;
180     const char * const data;
181     const char * const key;
182     const char expect[28];
183   } tv[] =
184     {
185       { "data-28 key-4",
186         "what do ya want for nothing?",
187         "Jefe",
188         { 0xa3, 0x0e, 0x01, 0x09, 0x8b, 0xc6, 0xdb, 0xbf,
189           0x45, 0x69, 0x0f, 0x3a, 0x7e, 0x9e, 0x6d, 0x0f,
190           0x8b, 0xbe, 0xa2, 0xa3, 0x9e, 0x61, 0x48, 0x00,
191           0x8f, 0xd0, 0x5e, 0x44 } },
192
193       { "data-9 key-20",
194         "Hi There",
195         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
196         "\x0b\x0b\x0b\x0b",
197         { 0x89, 0x6f, 0xb1, 0x12, 0x8a, 0xbb, 0xdf, 0x19,
198           0x68, 0x32, 0x10, 0x7c, 0xd4, 0x9d, 0xf3, 0x3f,
199           0x47, 0xb4, 0xb1, 0x16, 0x99, 0x12, 0xba, 0x4f,
200           0x53, 0x68, 0x4b, 0x22 } },
201
202       { "data-50 key-20",
203         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
204         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
205         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
206         "\xdd\xdd",
207         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
208         "\xaa\xaa\xaa\xaa",
209         { 0x7f, 0xb3, 0xcb, 0x35, 0x88, 0xc6, 0xc1, 0xf6,
210           0xff, 0xa9, 0x69, 0x4d, 0x7d, 0x6a, 0xd2, 0x64,
211           0x93, 0x65, 0xb0, 0xc1, 0xf6, 0x5d, 0x69, 0xd1,
212           0xec, 0x83, 0x33, 0xea } },
213
214       { "data-50 key-26",
215         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
216         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
217         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
218         "\xcd\xcd",
219         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
220         "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
221         { 0x6c, 0x11, 0x50, 0x68, 0x74, 0x01, 0x3c, 0xac,
222           0x6a, 0x2a, 0xbc, 0x1b, 0xb3, 0x82, 0x62, 0x7c,
223           0xec, 0x6a, 0x90, 0xd8, 0x6e, 0xfc, 0x01, 0x2d,
224           0xe7, 0xaf, 0xec, 0x5a } },
225
226       { "data-54 key-131",
227         "Test Using Larger Than Block-Size Key - Hash Key First",
228         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
229         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
230         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
231         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
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",
237         { 0x95, 0xe9, 0xa0, 0xdb, 0x96, 0x20, 0x95, 0xad,
238           0xae, 0xbe, 0x9b, 0x2d, 0x6f, 0x0d, 0xbc, 0xe2,
239           0xd4, 0x99, 0xf1, 0x12, 0xf2, 0xd2, 0xb7, 0x27,
240           0x3f, 0xa6, 0x87, 0x0e } },
241
242       { "data-152 key-131",
243         "This is a test using a larger than block-size key and a larger "
244         "than block-size data. The key needs to be hashed before being "
245         "used by the HMAC algorithm.",
246         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
247         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
248         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
249         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
250         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
251         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
252         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
253         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
254         "\xaa\xaa\xaa",
255         { 0x3a, 0x85, 0x41, 0x66, 0xac, 0x5d, 0x9f, 0x02,
256           0x3f, 0x54, 0xd5, 0x17, 0xd0, 0xb3, 0x9d, 0xbd,
257           0x94, 0x67, 0x70, 0xdb, 0x9c, 0x2b, 0x95, 0xc9,
258           0xf6, 0xf5, 0x65, 0xd1 } },
259
260       { NULL }
261     };
262   const char *what;
263   const char *errtxt;
264   int tvidx;
265
266   for (tvidx=0; tv[tvidx].desc; tvidx++)
267     {
268       what = tv[tvidx].desc;
269       errtxt = check_one (GCRY_MD_SHA224,
270                           tv[tvidx].data, strlen (tv[tvidx].data),
271                           tv[tvidx].key, strlen (tv[tvidx].key),
272                           tv[tvidx].expect, DIM (tv[tvidx].expect), 0);
273       if (errtxt)
274         goto failed;
275       if (!extended)
276         break;
277     }
278
279   return 0; /* Succeeded. */
280
281  failed:
282   if (report)
283     report ("hmac", GCRY_MD_SHA224, what, errtxt);
284   return GPG_ERR_SELFTEST_FAILED;
285 }
286
287
288 static gpg_err_code_t
289 selftests_sha256 (int extended, selftest_report_func_t report)
290 {
291   static struct
292   {
293     const char * const desc;
294     const char * const data;
295     const char * const key;
296     const char expect[32];
297   } tv[] =
298     {
299       { "data-28 key-4",
300         "what do ya want for nothing?",
301         "Jefe",
302         { 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
303           0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7,
304           0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83,
305           0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43 } },
306
307       { "data-9 key-20",
308         "Hi There",
309         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
310         "\x0b\x0b\x0b\x0b",
311         { 0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
312           0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b,
313           0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7,
314           0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7 } },
315
316       { "data-50 key-20",
317         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
318         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
319         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
320         "\xdd\xdd",
321         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
322         "\xaa\xaa\xaa\xaa",
323         { 0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46,
324           0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7,
325           0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22,
326           0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe } },
327
328       { "data-50 key-26",
329         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
330         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
331         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
332         "\xcd\xcd",
333         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
334         "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
335         { 0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e,
336           0xa4, 0xcc, 0x81, 0x98, 0x99, 0xf2, 0x08, 0x3a,
337           0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07,
338           0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b } },
339
340       { "data-54 key-131",
341         "Test Using Larger Than Block-Size Key - Hash Key First",
342         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
343         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
344         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
345         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
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",
351         { 0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f,
352           0x0d, 0x8a, 0x26, 0xaa, 0xcb, 0xf5, 0xb7, 0x7f,
353           0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14,
354           0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54 } },
355
356       { "data-152 key-131",
357         "This is a test using a larger than block-size key and a larger "
358         "than block-size data. The key needs to be hashed before being "
359         "used by the HMAC algorithm.",
360         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
361         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
362         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
363         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
364         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
365         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
366         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
367         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
368         "\xaa\xaa\xaa",
369         { 0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb,
370           0x27, 0x63, 0x5f, 0xbc, 0xd5, 0xb0, 0xe9, 0x44,
371           0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93,
372           0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2 } },
373
374       { NULL }
375     };
376   const char *what;
377   const char *errtxt;
378   int tvidx;
379
380   for (tvidx=0; tv[tvidx].desc; tvidx++)
381     {
382       hmac256_context_t hmachd;
383       const unsigned char *digest;
384       size_t dlen;
385
386       what = tv[tvidx].desc;
387       errtxt = check_one (GCRY_MD_SHA256,
388                           tv[tvidx].data, strlen (tv[tvidx].data),
389                           tv[tvidx].key, strlen (tv[tvidx].key),
390                           tv[tvidx].expect, DIM (tv[tvidx].expect), 0);
391       if (errtxt)
392         goto failed;
393
394       hmachd = _gcry_hmac256_new (tv[tvidx].key, strlen (tv[tvidx].key));
395       if (!hmachd)
396         {
397           errtxt = "_gcry_hmac256_new failed";
398           goto failed;
399         }
400       _gcry_hmac256_update (hmachd, tv[tvidx].data, strlen (tv[tvidx].data));
401       digest = _gcry_hmac256_finalize (hmachd, &dlen);
402       if (!digest)
403         {
404           errtxt = "_gcry_hmac256_finalize failed";
405           _gcry_hmac256_release (hmachd);
406           goto failed;
407         }
408       if (dlen != DIM (tv[tvidx].expect)
409           || memcmp (digest, tv[tvidx].expect, DIM (tv[tvidx].expect)))
410         {
411           errtxt = "does not match in second implementation";
412           _gcry_hmac256_release (hmachd);
413           goto failed;
414         }
415       _gcry_hmac256_release (hmachd);
416
417       if (!extended)
418         break;
419     }
420
421   return 0; /* Succeeded. */
422
423  failed:
424   if (report)
425     report ("hmac", GCRY_MD_SHA256, what, errtxt);
426   return GPG_ERR_SELFTEST_FAILED;
427 }
428
429
430 static gpg_err_code_t
431 selftests_sha384 (int extended, selftest_report_func_t report)
432 {
433   static struct
434   {
435     const char * const desc;
436     const char * const data;
437     const char * const key;
438     const char expect[48];
439   } tv[] =
440     {
441       { "data-28 key-4",
442         "what do ya want for nothing?",
443         "Jefe",
444         { 0xaf, 0x45, 0xd2, 0xe3, 0x76, 0x48, 0x40, 0x31,
445           0x61, 0x7f, 0x78, 0xd2, 0xb5, 0x8a, 0x6b, 0x1b,
446           0x9c, 0x7e, 0xf4, 0x64, 0xf5, 0xa0, 0x1b, 0x47,
447           0xe4, 0x2e, 0xc3, 0x73, 0x63, 0x22, 0x44, 0x5e,
448           0x8e, 0x22, 0x40, 0xca, 0x5e, 0x69, 0xe2, 0xc7,
449           0x8b, 0x32, 0x39, 0xec, 0xfa, 0xb2, 0x16, 0x49 } },
450
451       { "data-9 key-20",
452         "Hi There",
453         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
454         "\x0b\x0b\x0b\x0b",
455         { 0xaf, 0xd0, 0x39, 0x44, 0xd8, 0x48, 0x95, 0x62,
456           0x6b, 0x08, 0x25, 0xf4, 0xab, 0x46, 0x90, 0x7f,
457           0x15, 0xf9, 0xda, 0xdb, 0xe4, 0x10, 0x1e, 0xc6,
458           0x82, 0xaa, 0x03, 0x4c, 0x7c, 0xeb, 0xc5, 0x9c,
459           0xfa, 0xea, 0x9e, 0xa9, 0x07, 0x6e, 0xde, 0x7f,
460           0x4a, 0xf1, 0x52, 0xe8, 0xb2, 0xfa, 0x9c, 0xb6 } },
461
462       { "data-50 key-20",
463         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
464         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
465         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
466         "\xdd\xdd",
467         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
468         "\xaa\xaa\xaa\xaa",
469         { 0x88, 0x06, 0x26, 0x08, 0xd3, 0xe6, 0xad, 0x8a,
470           0x0a, 0xa2, 0xac, 0xe0, 0x14, 0xc8, 0xa8, 0x6f,
471           0x0a, 0xa6, 0x35, 0xd9, 0x47, 0xac, 0x9f, 0xeb,
472           0xe8, 0x3e, 0xf4, 0xe5, 0x59, 0x66, 0x14, 0x4b,
473           0x2a, 0x5a, 0xb3, 0x9d, 0xc1, 0x38, 0x14, 0xb9,
474           0x4e, 0x3a, 0xb6, 0xe1, 0x01, 0xa3, 0x4f, 0x27 } },
475
476       { "data-50 key-26",
477         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
478         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
479         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
480         "\xcd\xcd",
481         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
482         "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
483         { 0x3e, 0x8a, 0x69, 0xb7, 0x78, 0x3c, 0x25, 0x85,
484           0x19, 0x33, 0xab, 0x62, 0x90, 0xaf, 0x6c, 0xa7,
485           0x7a, 0x99, 0x81, 0x48, 0x08, 0x50, 0x00, 0x9c,
486           0xc5, 0x57, 0x7c, 0x6e, 0x1f, 0x57, 0x3b, 0x4e,
487           0x68, 0x01, 0xdd, 0x23, 0xc4, 0xa7, 0xd6, 0x79,
488           0xcc, 0xf8, 0xa3, 0x86, 0xc6, 0x74, 0xcf, 0xfb } },
489
490       { "data-54 key-131",
491         "Test Using Larger Than Block-Size Key - Hash Key First",
492         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
493         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
494         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
495         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
496         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
497         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
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",
501         { 0x4e, 0xce, 0x08, 0x44, 0x85, 0x81, 0x3e, 0x90,
502           0x88, 0xd2, 0xc6, 0x3a, 0x04, 0x1b, 0xc5, 0xb4,
503           0x4f, 0x9e, 0xf1, 0x01, 0x2a, 0x2b, 0x58, 0x8f,
504           0x3c, 0xd1, 0x1f, 0x05, 0x03, 0x3a, 0xc4, 0xc6,
505           0x0c, 0x2e, 0xf6, 0xab, 0x40, 0x30, 0xfe, 0x82,
506           0x96, 0x24, 0x8d, 0xf1, 0x63, 0xf4, 0x49, 0x52 } },
507
508       { "data-152 key-131",
509         "This is a test using a larger than block-size key and a larger "
510         "than block-size data. The key needs to be hashed before being "
511         "used by the HMAC algorithm.",
512         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
513         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
514         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
515         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
516         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
517         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
518         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
519         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
520         "\xaa\xaa\xaa",
521         { 0x66, 0x17, 0x17, 0x8e, 0x94, 0x1f, 0x02, 0x0d,
522           0x35, 0x1e, 0x2f, 0x25, 0x4e, 0x8f, 0xd3, 0x2c,
523           0x60, 0x24, 0x20, 0xfe, 0xb0, 0xb8, 0xfb, 0x9a,
524           0xdc, 0xce, 0xbb, 0x82, 0x46, 0x1e, 0x99, 0xc5,
525           0xa6, 0x78, 0xcc, 0x31, 0xe7, 0x99, 0x17, 0x6d,
526           0x38, 0x60, 0xe6, 0x11, 0x0c, 0x46, 0x52, 0x3e } },
527
528       { NULL }
529     };
530   const char *what;
531   const char *errtxt;
532   int tvidx;
533
534   for (tvidx=0; tv[tvidx].desc; tvidx++)
535     {
536       what = tv[tvidx].desc;
537       errtxt = check_one (GCRY_MD_SHA384,
538                           tv[tvidx].data, strlen (tv[tvidx].data),
539                           tv[tvidx].key, strlen (tv[tvidx].key),
540                           tv[tvidx].expect, DIM (tv[tvidx].expect), 0);
541       if (errtxt)
542         goto failed;
543       if (!extended)
544         break;
545     }
546
547   return 0; /* Succeeded. */
548
549  failed:
550   if (report)
551     report ("hmac", GCRY_MD_SHA384, what, errtxt);
552   return GPG_ERR_SELFTEST_FAILED;
553 }
554
555
556 static gpg_err_code_t
557 selftests_sha512 (int extended, selftest_report_func_t report)
558 {
559   static struct
560   {
561     const char * const desc;
562     const char * const data;
563     const char * const key;
564     const char expect[64];
565   } tv[] =
566     {
567       { "data-28 key-4",
568         "what do ya want for nothing?",
569         "Jefe",
570         { 0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2,
571           0xe3, 0x95, 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3,
572           0x87, 0xbd, 0x64, 0x22, 0x2e, 0x83, 0x1f, 0xd6,
573           0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, 0x05, 0x54,
574           0x97, 0x58, 0xbf, 0x75, 0xc0, 0x5a, 0x99, 0x4a,
575           0x6d, 0x03, 0x4f, 0x65, 0xf8, 0xf0, 0xe6, 0xfd,
576           0xca, 0xea, 0xb1, 0xa3, 0x4d, 0x4a, 0x6b, 0x4b,
577           0x63, 0x6e, 0x07, 0x0a, 0x38, 0xbc, 0xe7, 0x37 } },
578
579       { "data-9 key-20",
580         "Hi There",
581         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
582         "\x0b\x0b\x0b\x0b",
583         { 0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d,
584           0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0,
585           0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78,
586           0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde,
587           0xda, 0xa8, 0x33, 0xb7, 0xd6, 0xb8, 0xa7, 0x02,
588           0x03, 0x8b, 0x27, 0x4e, 0xae, 0xa3, 0xf4, 0xe4,
589           0xbe, 0x9d, 0x91, 0x4e, 0xeb, 0x61, 0xf1, 0x70,
590           0x2e, 0x69, 0x6c, 0x20, 0x3a, 0x12, 0x68, 0x54 } },
591
592       { "data-50 key-20",
593         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
594         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
595         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
596         "\xdd\xdd",
597         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
598         "\xaa\xaa\xaa\xaa",
599         { 0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84,
600           0xef, 0xb0, 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9,
601           0xb1, 0xb5, 0xdb, 0xdd, 0x8e, 0xe8, 0x1a, 0x36,
602           0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, 0x9d, 0x39,
603           0xbf, 0x3e, 0x84, 0x82, 0x79, 0xa7, 0x22, 0xc8,
604           0x06, 0xb4, 0x85, 0xa4, 0x7e, 0x67, 0xc8, 0x07,
605           0xb9, 0x46, 0xa3, 0x37, 0xbe, 0xe8, 0x94, 0x26,
606           0x74, 0x27, 0x88, 0x59, 0xe1, 0x32, 0x92, 0xfb } },
607
608       { "data-50 key-26",
609         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
610         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
611         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
612         "\xcd\xcd",
613         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
614         "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
615         { 0xb0, 0xba, 0x46, 0x56, 0x37, 0x45, 0x8c, 0x69,
616           0x90, 0xe5, 0xa8, 0xc5, 0xf6, 0x1d, 0x4a, 0xf7,
617           0xe5, 0x76, 0xd9, 0x7f, 0xf9, 0x4b, 0x87, 0x2d,
618           0xe7, 0x6f, 0x80, 0x50, 0x36, 0x1e, 0xe3, 0xdb,
619           0xa9, 0x1c, 0xa5, 0xc1, 0x1a, 0xa2, 0x5e, 0xb4,
620           0xd6, 0x79, 0x27, 0x5c, 0xc5, 0x78, 0x80, 0x63,
621           0xa5, 0xf1, 0x97, 0x41, 0x12, 0x0c, 0x4f, 0x2d,
622           0xe2, 0xad, 0xeb, 0xeb, 0x10, 0xa2, 0x98, 0xdd } },
623
624       { "data-54 key-131",
625         "Test Using Larger Than Block-Size Key - Hash Key First",
626         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
627         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
628         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
629         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
630         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
631         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
632         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
633         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
634         "\xaa\xaa\xaa",
635         { 0x80, 0xb2, 0x42, 0x63, 0xc7, 0xc1, 0xa3, 0xeb,
636           0xb7, 0x14, 0x93, 0xc1, 0xdd, 0x7b, 0xe8, 0xb4,
637           0x9b, 0x46, 0xd1, 0xf4, 0x1b, 0x4a, 0xee, 0xc1,
638           0x12, 0x1b, 0x01, 0x37, 0x83, 0xf8, 0xf3, 0x52,
639           0x6b, 0x56, 0xd0, 0x37, 0xe0, 0x5f, 0x25, 0x98,
640           0xbd, 0x0f, 0xd2, 0x21, 0x5d, 0x6a, 0x1e, 0x52,
641           0x95, 0xe6, 0x4f, 0x73, 0xf6, 0x3f, 0x0a, 0xec,
642           0x8b, 0x91, 0x5a, 0x98, 0x5d, 0x78, 0x65, 0x98 } },
643
644       { "data-152 key-131",
645         "This is a test using a larger than block-size key and a larger "
646         "than block-size data. The key needs to be hashed before being "
647         "used by the HMAC algorithm.",
648         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
649         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
650         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
651         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
652         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
653         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
654         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
655         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
656         "\xaa\xaa\xaa",
657         { 0xe3, 0x7b, 0x6a, 0x77, 0x5d, 0xc8, 0x7d, 0xba,
658           0xa4, 0xdf, 0xa9, 0xf9, 0x6e, 0x5e, 0x3f, 0xfd,
659           0xde, 0xbd, 0x71, 0xf8, 0x86, 0x72, 0x89, 0x86,
660           0x5d, 0xf5, 0xa3, 0x2d, 0x20, 0xcd, 0xc9, 0x44,
661           0xb6, 0x02, 0x2c, 0xac, 0x3c, 0x49, 0x82, 0xb1,
662           0x0d, 0x5e, 0xeb, 0x55, 0xc3, 0xe4, 0xde, 0x15,
663           0x13, 0x46, 0x76, 0xfb, 0x6d, 0xe0, 0x44, 0x60,
664           0x65, 0xc9, 0x74, 0x40, 0xfa, 0x8c, 0x6a, 0x58 } },
665
666       { NULL }
667     };
668   const char *what;
669   const char *errtxt;
670   int tvidx;
671
672   for (tvidx=0; tv[tvidx].desc; tvidx++)
673     {
674       what = tv[tvidx].desc;
675       errtxt = check_one (GCRY_MD_SHA512,
676                           tv[tvidx].data, strlen (tv[tvidx].data),
677                           tv[tvidx].key, strlen (tv[tvidx].key),
678                           tv[tvidx].expect, DIM (tv[tvidx].expect), 0);
679       if (errtxt)
680         goto failed;
681       if (!extended)
682         break;
683     }
684
685   return 0; /* Succeeded. */
686
687  failed:
688   if (report)
689     report ("hmac", GCRY_MD_SHA512, what, errtxt);
690   return GPG_ERR_SELFTEST_FAILED;
691 }
692
693
694
695 /* Test for the SHA3 algorithms.  Vectors taken on 2017-07-18 from
696  * http://www.wolfgang-ehrhardt.de/hmac-sha3-testvectors.html  */
697 static gpg_err_code_t
698 selftests_sha3 (int hashalgo, int extended, selftest_report_func_t report)
699 {
700   static struct
701   {
702     const char * const desc;
703     const char * const data;
704     const char * const key;
705     const char expect_224[28];
706     const char expect_256[32];
707     const char expect_384[48];
708     const char expect_512[64];
709     unsigned char trunc;
710   } tv[] =
711     {
712       { "data-9 key-20", /* Test 1 */
713         "Hi There",
714         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
715         "\x0b\x0b\x0b\x0b",
716
717         { 0x3b, 0x16, 0x54, 0x6b, 0xbc, 0x7b, 0xe2, 0x70,
718           0x6a, 0x03, 0x1d, 0xca, 0xfd, 0x56, 0x37, 0x3d,
719           0x98, 0x84, 0x36, 0x76, 0x41, 0xd8, 0xc5, 0x9a,
720           0xf3, 0xc8, 0x60, 0xf7                          },
721         { 0xba, 0x85, 0x19, 0x23, 0x10, 0xdf, 0xfa, 0x96,
722           0xe2, 0xa3, 0xa4, 0x0e, 0x69, 0x77, 0x43, 0x51,
723           0x14, 0x0b, 0xb7, 0x18, 0x5e, 0x12, 0x02, 0xcd,
724           0xcc, 0x91, 0x75, 0x89, 0xf9, 0x5e, 0x16, 0xbb  },
725         { 0x68, 0xd2, 0xdc, 0xf7, 0xfd, 0x4d, 0xdd, 0x0a,
726           0x22, 0x40, 0xc8, 0xa4, 0x37, 0x30, 0x5f, 0x61,
727           0xfb, 0x73, 0x34, 0xcf, 0xb5, 0xd0, 0x22, 0x6e,
728           0x1b, 0xc2, 0x7d, 0xc1, 0x0a, 0x2e, 0x72, 0x3a,
729           0x20, 0xd3, 0x70, 0xb4, 0x77, 0x43, 0x13, 0x0e,
730           0x26, 0xac, 0x7e, 0x3d, 0x53, 0x28, 0x86, 0xbd  },
731         { 0xeb, 0x3f, 0xbd, 0x4b, 0x2e, 0xaa, 0xb8, 0xf5,
732           0xc5, 0x04, 0xbd, 0x3a, 0x41, 0x46, 0x5a, 0xac,
733           0xec, 0x15, 0x77, 0x0a, 0x7c, 0xab, 0xac, 0x53,
734           0x1e, 0x48, 0x2f, 0x86, 0x0b, 0x5e, 0xc7, 0xba,
735           0x47, 0xcc, 0xb2, 0xc6, 0xf2, 0xaf, 0xce, 0x8f,
736           0x88, 0xd2, 0x2b, 0x6d, 0xc6, 0x13, 0x80, 0xf2,
737           0x3a, 0x66, 0x8f, 0xd3, 0x88, 0x8b, 0xb8, 0x05,
738           0x37, 0xc0, 0xa0, 0xb8, 0x64, 0x07, 0x68, 0x9e  }
739       },
740
741       { "data-28 key-4",  /* Test 2  */
742         /* Test with a key shorter than the length of the HMAC output. */
743         "what do ya want for nothing?",
744         "Jefe",
745
746         { 0x7f, 0xdb, 0x8d, 0xd8, 0x8b, 0xd2, 0xf6, 0x0d,
747           0x1b, 0x79, 0x86, 0x34, 0xad, 0x38, 0x68, 0x11,
748           0xc2, 0xcf, 0xc8, 0x5b, 0xfa, 0xf5, 0xd5, 0x2b,
749           0xba, 0xce, 0x5e, 0x66                          },
750         { 0xc7, 0xd4, 0x07, 0x2e, 0x78, 0x88, 0x77, 0xae,
751           0x35, 0x96, 0xbb, 0xb0, 0xda, 0x73, 0xb8, 0x87,
752           0xc9, 0x17, 0x1f, 0x93, 0x09, 0x5b, 0x29, 0x4a,
753           0xe8, 0x57, 0xfb, 0xe2, 0x64, 0x5e, 0x1b, 0xa5  },
754         { 0xf1, 0x10, 0x1f, 0x8c, 0xbf, 0x97, 0x66, 0xfd,
755           0x67, 0x64, 0xd2, 0xed, 0x61, 0x90, 0x3f, 0x21,
756           0xca, 0x9b, 0x18, 0xf5, 0x7c, 0xf3, 0xe1, 0xa2,
757           0x3c, 0xa1, 0x35, 0x08, 0xa9, 0x32, 0x43, 0xce,
758           0x48, 0xc0, 0x45, 0xdc, 0x00, 0x7f, 0x26, 0xa2,
759           0x1b, 0x3f, 0x5e, 0x0e, 0x9d, 0xf4, 0xc2, 0x0a  },
760         { 0x5a, 0x4b, 0xfe, 0xab, 0x61, 0x66, 0x42, 0x7c,
761           0x7a, 0x36, 0x47, 0xb7, 0x47, 0x29, 0x2b, 0x83,
762           0x84, 0x53, 0x7c, 0xdb, 0x89, 0xaf, 0xb3, 0xbf,
763           0x56, 0x65, 0xe4, 0xc5, 0xe7, 0x09, 0x35, 0x0b,
764           0x28, 0x7b, 0xae, 0xc9, 0x21, 0xfd, 0x7c, 0xa0,
765           0xee, 0x7a, 0x0c, 0x31, 0xd0, 0x22, 0xa9, 0x5e,
766           0x1f, 0xc9, 0x2b, 0xa9, 0xd7, 0x7d, 0xf8, 0x83,
767           0x96, 0x02, 0x75, 0xbe, 0xb4, 0xe6, 0x20, 0x24  }
768       },
769
770       { "data-50 key-20",  /* Test 3 */
771         /* Test with a combined length of key and data that is larger
772          * than 64 bytes (= block-size of SHA-224 and SHA-256).  */
773         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
774         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
775         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
776         "\xdd\xdd",
777         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
778         "\xaa\xaa\xaa\xaa",
779
780         { 0x67, 0x6c, 0xfc, 0x7d, 0x16, 0x15, 0x36, 0x38,
781           0x78, 0x03, 0x90, 0x69, 0x2b, 0xe1, 0x42, 0xd2,
782           0xdf, 0x7c, 0xe9, 0x24, 0xb9, 0x09, 0xc0, 0xc0,
783           0x8d, 0xbf, 0xdc, 0x1a  },
784         { 0x84, 0xec, 0x79, 0x12, 0x4a, 0x27, 0x10, 0x78,
785           0x65, 0xce, 0xdd, 0x8b, 0xd8, 0x2d, 0xa9, 0x96,
786           0x5e, 0x5e, 0xd8, 0xc3, 0x7b, 0x0a, 0xc9, 0x80,
787           0x05, 0xa7, 0xf3, 0x9e, 0xd5, 0x8a, 0x42, 0x07  },
788         { 0x27, 0x5c, 0xd0, 0xe6, 0x61, 0xbb, 0x8b, 0x15,
789           0x1c, 0x64, 0xd2, 0x88, 0xf1, 0xf7, 0x82, 0xfb,
790           0x91, 0xa8, 0xab, 0xd5, 0x68, 0x58, 0xd7, 0x2b,
791           0xab, 0xb2, 0xd4, 0x76, 0xf0, 0x45, 0x83, 0x73,
792           0xb4, 0x1b, 0x6a, 0xb5, 0xbf, 0x17, 0x4b, 0xec,
793           0x42, 0x2e, 0x53, 0xfc, 0x31, 0x35, 0xac, 0x6e  },
794         { 0x30, 0x9e, 0x99, 0xf9, 0xec, 0x07, 0x5e, 0xc6,
795           0xc6, 0xd4, 0x75, 0xed, 0xa1, 0x18, 0x06, 0x87,
796           0xfc, 0xf1, 0x53, 0x11, 0x95, 0x80, 0x2a, 0x99,
797           0xb5, 0x67, 0x74, 0x49, 0xa8, 0x62, 0x51, 0x82,
798           0x85, 0x1c, 0xb3, 0x32, 0xaf, 0xb6, 0xa8, 0x9c,
799           0x41, 0x13, 0x25, 0xfb, 0xcb, 0xcd, 0x42, 0xaf,
800           0xcb, 0x7b, 0x6e, 0x5a, 0xab, 0x7e, 0xa4, 0x2c,
801           0x66, 0x0f, 0x97, 0xfd, 0x85, 0x84, 0xbf, 0x03  }
802       },
803
804       { "data-50 key-25",  /* Test 4 */
805         /* Test with a combined length of key and data that is larger
806          * than 64 bytes (= block-size of SHA-224 and SHA-256).  */
807         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
808         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
809         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
810         "\xcd\xcd",
811         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
812         "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
813
814         { 0xa9, 0xd7, 0x68, 0x5a, 0x19, 0xc4, 0xe0, 0xdb,
815           0xd9, 0xdf, 0x25, 0x56, 0xcc, 0x8a, 0x7d, 0x2a,
816           0x77, 0x33, 0xb6, 0x76, 0x25, 0xce, 0x59, 0x4c,
817           0x78, 0x27, 0x0e, 0xeb   },
818         { 0x57, 0x36, 0x6a, 0x45, 0xe2, 0x30, 0x53, 0x21,
819           0xa4, 0xbc, 0x5a, 0xa5, 0xfe, 0x2e, 0xf8, 0xa9,
820           0x21, 0xf6, 0xaf, 0x82, 0x73, 0xd7, 0xfe, 0x7b,
821           0xe6, 0xcf, 0xed, 0xb3, 0xf0, 0xae, 0xa6, 0xd7  },
822         { 0x3a, 0x5d, 0x7a, 0x87, 0x97, 0x02, 0xc0, 0x86,
823           0xbc, 0x96, 0xd1, 0xdd, 0x8a, 0xa1, 0x5d, 0x9c,
824           0x46, 0x44, 0x6b, 0x95, 0x52, 0x13, 0x11, 0xc6,
825           0x06, 0xfd, 0xc4, 0xe3, 0x08, 0xf4, 0xb9, 0x84,
826           0xda, 0x2d, 0x0f, 0x94, 0x49, 0xb3, 0xba, 0x84,
827           0x25, 0xec, 0x7f, 0xb8, 0xc3, 0x1b, 0xc1, 0x36  },
828         { 0xb2, 0x7e, 0xab, 0x1d, 0x6e, 0x8d, 0x87, 0x46,
829           0x1c, 0x29, 0xf7, 0xf5, 0x73, 0x9d, 0xd5, 0x8e,
830           0x98, 0xaa, 0x35, 0xf8, 0xe8, 0x23, 0xad, 0x38,
831           0xc5, 0x49, 0x2a, 0x20, 0x88, 0xfa, 0x02, 0x81,
832           0x99, 0x3b, 0xbf, 0xff, 0x9a, 0x0e, 0x9c, 0x6b,
833           0xf1, 0x21, 0xae, 0x9e, 0xc9, 0xbb, 0x09, 0xd8,
834           0x4a, 0x5e, 0xba, 0xc8, 0x17, 0x18, 0x2e, 0xa9,
835           0x74, 0x67, 0x3f, 0xb1, 0x33, 0xca, 0x0d, 0x1d  }
836       },
837
838       { "data-20 key-20 trunc",  /* Test 5 */
839         /* Test with a truncation of output to 128 bits.  */
840         "Test With Truncation",
841         "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c"
842         "\x0c\x0c\x0c\x0c",
843
844         { 0x49, 0xfd, 0xd3, 0xab, 0xd0, 0x05, 0xeb, 0xb8,
845           0xae, 0x63, 0xfe, 0xa9, 0x46, 0xd1, 0x88, 0x3c  },
846         { 0x6e, 0x02, 0xc6, 0x45, 0x37, 0xfb, 0x11, 0x80,
847           0x57, 0xab, 0xb7, 0xfb, 0x66, 0xa2, 0x3b, 0x3c  },
848         { 0x47, 0xc5, 0x1a, 0xce, 0x1f, 0xfa, 0xcf, 0xfd,
849           0x74, 0x94, 0x72, 0x46, 0x82, 0x61, 0x57, 0x83  },
850         { 0x0f, 0xa7, 0x47, 0x59, 0x48, 0xf4, 0x3f, 0x48,
851           0xca, 0x05, 0x16, 0x67, 0x1e, 0x18, 0x97, 0x8c  },
852         16
853       },
854
855       { "data-54 key-131",  /* Test 6 */
856         /* Test with a key larger than 128 bytes (= block-size of
857          * SHA-384 and SHA-512).  */
858         "Test Using Larger Than Block-Size Key - Hash Key First",
859         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
860         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
861         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
862         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
863         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
864         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
865         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
866         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
867         "\xaa\xaa\xaa",
868
869         { 0xb4, 0xa1, 0xf0, 0x4c, 0x00, 0x28, 0x7a, 0x9b,
870           0x7f, 0x60, 0x75, 0xb3, 0x13, 0xd2, 0x79, 0xb8,
871           0x33, 0xbc, 0x8f, 0x75, 0x12, 0x43, 0x52, 0xd0,
872           0x5f, 0xb9, 0x99, 0x5f  },
873         { 0xed, 0x73, 0xa3, 0x74, 0xb9, 0x6c, 0x00, 0x52,
874           0x35, 0xf9, 0x48, 0x03, 0x2f, 0x09, 0x67, 0x4a,
875           0x58, 0xc0, 0xce, 0x55, 0x5c, 0xfc, 0x1f, 0x22,
876           0x3b, 0x02, 0x35, 0x65, 0x60, 0x31, 0x2c, 0x3b  },
877         { 0x0f, 0xc1, 0x95, 0x13, 0xbf, 0x6b, 0xd8, 0x78,
878           0x03, 0x70, 0x16, 0x70, 0x6a, 0x0e, 0x57, 0xbc,
879           0x52, 0x81, 0x39, 0x83, 0x6b, 0x9a, 0x42, 0xc3,
880           0xd4, 0x19, 0xe4, 0x98, 0xe0, 0xe1, 0xfb, 0x96,
881           0x16, 0xfd, 0x66, 0x91, 0x38, 0xd3, 0x3a, 0x11,
882           0x05, 0xe0, 0x7c, 0x72, 0xb6, 0x95, 0x3b, 0xcc  },
883         { 0x00, 0xf7, 0x51, 0xa9, 0xe5, 0x06, 0x95, 0xb0,
884           0x90, 0xed, 0x69, 0x11, 0xa4, 0xb6, 0x55, 0x24,
885           0x95, 0x1c, 0xdc, 0x15, 0xa7, 0x3a, 0x5d, 0x58,
886           0xbb, 0x55, 0x21, 0x5e, 0xa2, 0xcd, 0x83, 0x9a,
887           0xc7, 0x9d, 0x2b, 0x44, 0xa3, 0x9b, 0xaf, 0xab,
888           0x27, 0xe8, 0x3f, 0xde, 0x9e, 0x11, 0xf6, 0x34,
889           0x0b, 0x11, 0xd9, 0x91, 0xb1, 0xb9, 0x1b, 0xf2,
890           0xee, 0xe7, 0xfc, 0x87, 0x24, 0x26, 0xc3, 0xa4  }
891       },
892
893       { "data-54 key-147",  /* Test 6a */
894         /* Test with a key larger than 144 bytes (= block-size of
895          * SHA3-224).  */
896         "Test Using Larger Than Block-Size Key - Hash Key First",
897         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
898         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
899         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
900         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
901         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
902         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
903         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
904         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
905         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
906         "\xaa\xaa\xaa",
907
908         { 0xb9, 0x6d, 0x73, 0x0c, 0x14, 0x8c, 0x2d, 0xaa,
909           0xd8, 0x64, 0x9d, 0x83, 0xde, 0xfa, 0xa3, 0x71,
910           0x97, 0x38, 0xd3, 0x47, 0x75, 0x39, 0x7b, 0x75,
911           0x71, 0xc3, 0x85, 0x15  },
912         { 0xa6, 0x07, 0x2f, 0x86, 0xde, 0x52, 0xb3, 0x8b,
913           0xb3, 0x49, 0xfe, 0x84, 0xcd, 0x6d, 0x97, 0xfb,
914           0x6a, 0x37, 0xc4, 0xc0, 0xf6, 0x2a, 0xae, 0x93,
915           0x98, 0x11, 0x93, 0xa7, 0x22, 0x9d, 0x34, 0x67  },
916         { 0x71, 0x3d, 0xff, 0x03, 0x02, 0xc8, 0x50, 0x86,
917           0xec, 0x5a, 0xd0, 0x76, 0x8d, 0xd6, 0x5a, 0x13,
918           0xdd, 0xd7, 0x90, 0x68, 0xd8, 0xd4, 0xc6, 0x21,
919           0x2b, 0x71, 0x2e, 0x41, 0x64, 0x94, 0x49, 0x11,
920           0x14, 0x80, 0x23, 0x00, 0x44, 0x18, 0x5a, 0x99,
921           0x10, 0x3e, 0xd8, 0x20, 0x04, 0xdd, 0xbf, 0xcc  },
922         { 0xb1, 0x48, 0x35, 0xc8, 0x19, 0xa2, 0x90, 0xef,
923           0xb0, 0x10, 0xac, 0xe6, 0xd8, 0x56, 0x8d, 0xc6,
924           0xb8, 0x4d, 0xe6, 0x0b, 0xc4, 0x9b, 0x00, 0x4c,
925           0x3b, 0x13, 0xed, 0xa7, 0x63, 0x58, 0x94, 0x51,
926           0xe5, 0xdd, 0x74, 0x29, 0x28, 0x84, 0xd1, 0xbd,
927           0xce, 0x64, 0xe6, 0xb9, 0x19, 0xdd, 0x61, 0xdc,
928           0x9c, 0x56, 0xa2, 0x82, 0xa8, 0x1c, 0x0b, 0xd1,
929           0x4f, 0x1f, 0x36, 0x5b, 0x49, 0xb8, 0x3a, 0x5b  }
930       },
931
932       { "data-152 key-131",  /* Test 7  */
933         /* Test with a key and data that is larger than 128 bytes (=
934          * block-size of SHA-384 and SHA-512).  */
935         "This is a test using a larger than block-size key and a larger "
936         "than block-size data. The key needs to be hashed before being "
937         "used by the HMAC algorithm.",
938         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
939         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
940         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
941         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
942         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
943         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
944         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
945         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
946         "\xaa\xaa\xaa",
947
948         { 0x05, 0xd8, 0xcd, 0x6d, 0x00, 0xfa, 0xea, 0x8d,
949           0x1e, 0xb6, 0x8a, 0xde, 0x28, 0x73, 0x0b, 0xbd,
950           0x3c, 0xba, 0xb6, 0x92, 0x9f, 0x0a, 0x08, 0x6b,
951           0x29, 0xcd, 0x62, 0xa0  },
952         { 0x65, 0xc5, 0xb0, 0x6d, 0x4c, 0x3d, 0xe3, 0x2a,
953           0x7a, 0xef, 0x87, 0x63, 0x26, 0x1e, 0x49, 0xad,
954           0xb6, 0xe2, 0x29, 0x3e, 0xc8, 0xe7, 0xc6, 0x1e,
955           0x8d, 0xe6, 0x17, 0x01, 0xfc, 0x63, 0xe1, 0x23  },
956         { 0x02, 0x6f, 0xdf, 0x6b, 0x50, 0x74, 0x1e, 0x37,
957           0x38, 0x99, 0xc9, 0xf7, 0xd5, 0x40, 0x6d, 0x4e,
958           0xb0, 0x9f, 0xc6, 0x66, 0x56, 0x36, 0xfc, 0x1a,
959           0x53, 0x00, 0x29, 0xdd, 0xf5, 0xcf, 0x3c, 0xa5,
960           0xa9, 0x00, 0xed, 0xce, 0x01, 0xf5, 0xf6, 0x1e,
961           0x2f, 0x40, 0x8c, 0xdf, 0x2f, 0xd3, 0xe7, 0xe8  },
962         { 0x38, 0xa4, 0x56, 0xa0, 0x04, 0xbd, 0x10, 0xd3,
963           0x2c, 0x9a, 0xb8, 0x33, 0x66, 0x84, 0x11, 0x28,
964           0x62, 0xc3, 0xdb, 0x61, 0xad, 0xcc, 0xa3, 0x18,
965           0x29, 0x35, 0x5e, 0xaf, 0x46, 0xfd, 0x5c, 0x73,
966           0xd0, 0x6a, 0x1f, 0x0d, 0x13, 0xfe, 0xc9, 0xa6,
967           0x52, 0xfb, 0x38, 0x11, 0xb5, 0x77, 0xb1, 0xb1,
968           0xd1, 0xb9, 0x78, 0x9f, 0x97, 0xae, 0x5b, 0x83,
969           0xc6, 0xf4, 0x4d, 0xfc, 0xf1, 0xd6, 0x7e, 0xba  }
970       },
971
972       { "data-152 key-147",  /* Test 7a  */
973         /* Test with a key larger than 144 bytes (= block-size of
974          * SHA3-224). */
975         "This is a test using a larger than block-size key and a larger "
976         "than block-size data. The key needs to be hashed before being "
977         "used by the HMAC algorithm.",
978         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
979         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
980         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
981         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
982         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
983         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
984         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
985         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
986         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
987         "\xaa\xaa\xaa",
988
989         { 0xc7, 0x9c, 0x9b, 0x09, 0x34, 0x24, 0xe5, 0x88,
990           0xa9, 0x87, 0x8b, 0xbc, 0xb0, 0x89, 0xe0, 0x18,
991           0x27, 0x00, 0x96, 0xe9, 0xb4, 0xb1, 0xa9, 0xe8,
992           0x22, 0x0c, 0x86, 0x6a  },
993         { 0xe6, 0xa3, 0x6d, 0x9b, 0x91, 0x5f, 0x86, 0xa0,
994           0x93, 0xca, 0xc7, 0xd1, 0x10, 0xe9, 0xe0, 0x4c,
995           0xf1, 0xd6, 0x10, 0x0d, 0x30, 0x47, 0x55, 0x09,
996           0xc2, 0x47, 0x5f, 0x57, 0x1b, 0x75, 0x8b, 0x5a  },
997         { 0xca, 0xd1, 0x8a, 0x8f, 0xf6, 0xc4, 0xcc, 0x3a,
998           0xd4, 0x87, 0xb9, 0x5f, 0x97, 0x69, 0xe9, 0xb6,
999           0x1c, 0x06, 0x2a, 0xef, 0xd6, 0x95, 0x25, 0x69,
1000           0xe6, 0xe6, 0x42, 0x18, 0x97, 0x05, 0x4c, 0xfc,
1001           0x70, 0xb5, 0xfd, 0xc6, 0x60, 0x5c, 0x18, 0x45,
1002           0x71, 0x12, 0xfc, 0x6a, 0xaa, 0xd4, 0x55, 0x85  },
1003         { 0xdc, 0x03, 0x0e, 0xe7, 0x88, 0x70, 0x34, 0xf3,
1004           0x2c, 0xf4, 0x02, 0xdf, 0x34, 0x62, 0x2f, 0x31,
1005           0x1f, 0x3e, 0x6c, 0xf0, 0x48, 0x60, 0xc6, 0xbb,
1006           0xd7, 0xfa, 0x48, 0x86, 0x74, 0x78, 0x2b, 0x46,
1007           0x59, 0xfd, 0xbd, 0xf3, 0xfd, 0x87, 0x78, 0x52,
1008           0x88, 0x5c, 0xfe, 0x6e, 0x22, 0x18, 0x5f, 0xe7,
1009           0xb2, 0xee, 0x95, 0x20, 0x43, 0x62, 0x9b, 0xc9,
1010           0xd5, 0xf3, 0x29, 0x8a, 0x41, 0xd0, 0x2c, 0x66  }
1011       }/*,*/
1012
1013       /* Our API does not allow to specify a bit count and thus we
1014        * can't use the following test.  */
1015       /* { "data-5bit key-4",  /\* Test 8  *\/ */
1016       /*   /\* Test with data bit size no multiple of 8, the data bits are */
1017       /*    * '11001' from the NIST example using SHA-3 order (= 5 bits */
1018       /*    * from LSB hex byte 13 or 5 bits from MSB hex byte c8).  *\/ */
1019       /*   "\xc8", */
1020       /*   "Jefe", */
1021
1022       /*   { 0x5f, 0x8c, 0x0e, 0xa7, 0xfa, 0xfe, 0xcd, 0x0c, */
1023       /*     0x34, 0x63, 0xaa, 0xd0, 0x97, 0x42, 0xce, 0xce, */
1024       /*     0xb1, 0x42, 0xfe, 0x0a, 0xb6, 0xf4, 0x53, 0x94, */
1025       /*     0x38, 0xc5, 0x9d, 0xe8  }, */
1026       /*   { 0xec, 0x82, 0x22, 0x77, 0x3f, 0xac, 0x68, 0xb3, */
1027       /*     0xd3, 0xdc, 0xb1, 0x82, 0xae, 0xc8, 0xb0, 0x50, */
1028       /*     0x7a, 0xce, 0x44, 0x48, 0xd2, 0x0a, 0x11, 0x47, */
1029       /*     0xe6, 0x82, 0x11, 0x8d, 0xa4, 0xe3, 0xf4, 0x4c  }, */
1030       /*   { 0x21, 0xfb, 0xd3, 0xbf, 0x3e, 0xbb, 0xa3, 0xcf, */
1031       /*     0xc9, 0xef, 0x64, 0xc0, 0x59, 0x1c, 0x92, 0xc5, */
1032       /*     0xac, 0xb2, 0x65, 0xe9, 0x2d, 0x87, 0x61, 0xd1, */
1033       /*     0xf9, 0x1a, 0x52, 0xa1, 0x03, 0xa6, 0xc7, 0x96, */
1034       /*     0x94, 0xcf, 0xd6, 0x7a, 0x9a, 0x2a, 0xc1, 0x32, */
1035       /*     0x4f, 0x02, 0xfe, 0xa6, 0x3b, 0x81, 0xef, 0xfc  }, */
1036       /*   { 0x27, 0xf9, 0x38, 0x8c, 0x15, 0x67, 0xef, 0x4e, */
1037       /*     0xf2, 0x00, 0x60, 0x2a, 0x6c, 0xf8, 0x71, 0xd6, */
1038       /*     0x8a, 0x6f, 0xb0, 0x48, 0xd4, 0x73, 0x7a, 0xc4, */
1039       /*     0x41, 0x8a, 0x2f, 0x02, 0x12, 0x89, 0xd1, 0x3d, */
1040       /*     0x1f, 0xd1, 0x12, 0x0f, 0xec, 0xb9, 0xcf, 0x96, */
1041       /*     0x4c, 0x5b, 0x11, 0x7a, 0xb5, 0xb1, 0x1c, 0x61, */
1042       /*     0x4b, 0x2d, 0xa3, 0x9d, 0xad, 0xd5, 0x1f, 0x2f, */
1043       /*     0x5e, 0x22, 0xaa, 0xcc, 0xec, 0x7d, 0x57, 0x6e  } */
1044       /* } */
1045
1046     };
1047   const char *what;
1048   const char *errtxt;
1049   int tvidx;
1050   const char *expect;
1051   int nexpect;
1052
1053   for (tvidx=0; tvidx < DIM(tv); tvidx++)
1054     {
1055       what = tv[tvidx].desc;
1056       if (hashalgo == GCRY_MD_SHA3_224)
1057         {
1058           expect = tv[tvidx].expect_224;
1059           nexpect = DIM (tv[tvidx].expect_224);
1060         }
1061       else if (hashalgo == GCRY_MD_SHA3_256)
1062         {
1063           expect = tv[tvidx].expect_256;
1064           nexpect = DIM (tv[tvidx].expect_256);
1065         }
1066       else if (hashalgo == GCRY_MD_SHA3_384)
1067         {
1068           expect = tv[tvidx].expect_384;
1069           nexpect = DIM (tv[tvidx].expect_384);
1070         }
1071       else if (hashalgo == GCRY_MD_SHA3_512)
1072         {
1073           expect = tv[tvidx].expect_512;
1074           nexpect = DIM (tv[tvidx].expect_512);
1075         }
1076       else
1077         BUG();
1078
1079       if (tv[tvidx].trunc && tv[tvidx].trunc < nexpect)
1080         nexpect = tv[tvidx].trunc;
1081
1082       errtxt = check_one (hashalgo,
1083                           tv[tvidx].data, strlen (tv[tvidx].data),
1084                           tv[tvidx].key, strlen (tv[tvidx].key),
1085                           expect, nexpect, !!tv[tvidx].trunc);
1086       if (errtxt)
1087         goto failed;
1088       if (!extended)
1089         break;
1090     }
1091
1092   return 0; /* Succeeded. */
1093
1094  failed:
1095   if (report)
1096     report ("hmac", hashalgo, what, errtxt);
1097   return GPG_ERR_SELFTEST_FAILED;
1098 }
1099
1100
1101 /* Run a full self-test for ALGO and return 0 on success.  */
1102 static gpg_err_code_t
1103 run_selftests (int algo, int extended, selftest_report_func_t report)
1104 {
1105   gpg_err_code_t ec;
1106
1107   switch (algo)
1108     {
1109     case GCRY_MD_SHA1:
1110       ec = selftests_sha1 (extended, report);
1111       break;
1112     case GCRY_MD_SHA224:
1113       ec = selftests_sha224 (extended, report);
1114       break;
1115     case GCRY_MD_SHA256:
1116       ec = selftests_sha256 (extended, report);
1117       break;
1118     case GCRY_MD_SHA384:
1119       ec = selftests_sha384 (extended, report);
1120       break;
1121     case GCRY_MD_SHA512:
1122       ec = selftests_sha512 (extended, report);
1123       break;
1124
1125     case GCRY_MD_SHA3_224:
1126     case GCRY_MD_SHA3_256:
1127     case GCRY_MD_SHA3_384:
1128     case GCRY_MD_SHA3_512:
1129       ec = selftests_sha3 (algo, extended, report);
1130       break;
1131
1132     default:
1133       ec = GPG_ERR_DIGEST_ALGO;
1134       break;
1135     }
1136   return ec;
1137 }
1138
1139
1140
1141
1142 /* Run the selftests for HMAC with digest algorithm ALGO with optional
1143    reporting function REPORT.  */
1144 gpg_error_t
1145 _gcry_hmac_selftest (int algo, int extended, selftest_report_func_t report)
1146 {
1147   gcry_err_code_t ec = 0;
1148
1149   if (!_gcry_md_test_algo (algo))
1150     {
1151       ec = run_selftests (algo, extended, report);
1152     }
1153   else
1154     {
1155       ec = GPG_ERR_DIGEST_ALGO;
1156       if (report)
1157         report ("hmac", algo, "module", "algorithm not available");
1158     }
1159   return gpg_error (ec);
1160 }