Applied pacthes from Brad Hards.
[libgcrypt.git] / tests / basic.c
1 /* basic.c  -  basic regression tests
2  *      Copyright (C) 2001, 2002, 2003, 2005 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <stdarg.h>
28
29 #include "../src/gcrypt.h"
30
31 typedef struct test_spec_pubkey_key
32 {
33   const char *secret;
34   const char *public;
35   const char *grip;
36 }
37 test_spec_pubkey_key_t;
38
39 typedef struct test_spec_pubkey
40 {
41   int id;
42   int flags;
43   test_spec_pubkey_key_t key;
44 }
45 test_spec_pubkey_t;
46
47 #define FLAG_CRYPT (1 << 0)
48 #define FLAG_SIGN  (1 << 1)
49 #define FLAG_GRIP  (1 << 2)
50
51 static int verbose;
52 static int error_count;
53
54 static void
55 fail (const char *format, ...)
56 {
57   va_list arg_ptr;
58
59   va_start (arg_ptr, format);
60   vfprintf (stderr, format, arg_ptr);
61   va_end (arg_ptr);
62   error_count++;
63 }
64
65 static void
66 die (const char *format, ...)
67 {
68   va_list arg_ptr;
69
70   va_start (arg_ptr, format);
71   vfprintf (stderr, format, arg_ptr);
72   va_end (arg_ptr);
73   exit (1);
74 }
75
76 #define MAX_DATA_LEN 100
77
78 void
79 progress_handler (void *cb_data, const char *what, int printchar,
80                   int current, int total)
81 {
82   putchar (printchar);
83 }
84
85 static void
86 check_cbc_mac_cipher (void)
87 {
88   struct tv
89   {
90     int algo;
91     char key[MAX_DATA_LEN];
92     unsigned char plaintext[MAX_DATA_LEN];
93     size_t plaintextlen;
94     char mac[MAX_DATA_LEN];
95   }
96   tv[] =
97     {
98       { GCRY_CIPHER_AES,
99         "chicken teriyaki",
100         "This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
101         0, "\x23\x8f\x6d\xc7\x53\x6a\x62\x97\x11\xc4\xa5\x16\x43\xea\xb0\xb6" },
102       { GCRY_CIPHER_3DES,
103         "abcdefghABCDEFGH01234567",
104         "This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
105         0, "\x5c\x11\xf0\x01\x47\xbd\x3d\x3a" },
106       { GCRY_CIPHER_DES,
107         "abcdefgh",
108         "This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
109         0, "\xfa\x4b\xdf\x9d\xfa\xab\x01\x70" }
110     };
111   gcry_cipher_hd_t hd;
112   unsigned char out[MAX_DATA_LEN];
113   int i, blklen, keylen;
114   gcry_error_t err = 0;
115
116   if (verbose)
117     fprintf (stderr, "Starting CBC MAC checks.\n");
118
119   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
120     {
121       err = gcry_cipher_open (&hd,
122                               tv[i].algo,
123                               GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_MAC);
124       if (!hd)
125         {
126           fail ("cbc-mac algo %d, grcy_open_cipher failed: %s\n",
127                 tv[i].algo, gpg_strerror (err));
128           return;
129         }
130
131       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
132       if (!blklen)
133         {
134           fail ("cbc-mac algo %d, gcry_cipher_get_algo_blklen failed\n",
135                  tv[i].algo);
136           gcry_cipher_close (hd);
137           return;
138         }
139
140       keylen = gcry_cipher_get_algo_keylen (tv[i].algo);
141       if (!keylen)
142         {
143           fail ("cbc-mac algo %d, gcry_cipher_get_algo_keylen failed\n",
144                 tv[i].algo);
145           return;
146         }
147
148       err = gcry_cipher_setkey (hd, tv[i].key, keylen);
149       if (err)
150         {
151           fail ("cbc-mac algo %d, gcry_cipher_setkey failed: %s\n",
152                 tv[i].algo, gpg_strerror (err));
153           gcry_cipher_close (hd);
154           return;
155         }
156
157       err = gcry_cipher_setiv (hd, NULL, 0);
158       if (err)
159         {
160           fail ("cbc-mac algo %d, gcry_cipher_setiv failed: %s\n",
161                 tv[i].algo, gpg_strerror (err));
162           gcry_cipher_close (hd);
163           return;
164         }
165
166       if (verbose)
167         fprintf (stderr, "  checking CBC MAC for %s [%i]\n", 
168                  gcry_cipher_algo_name (tv[i].algo),
169                  tv[i].algo);
170       err = gcry_cipher_encrypt (hd,
171                                  out, blklen,
172                                  tv[i].plaintext,
173                                  tv[i].plaintextlen ?
174                                  tv[i].plaintextlen :
175                                  strlen ((char*)tv[i].plaintext));
176       if (err)
177         {
178           fail ("cbc-mac algo %d, gcry_cipher_encrypt failed: %s\n",
179                 tv[i].algo, gpg_strerror (err));
180           gcry_cipher_close (hd);
181           return;
182         }
183
184 #if 0
185       {
186         int j;
187         for (j = 0; j < gcry_cipher_get_algo_blklen (tv[i].algo); j++)
188           printf ("\\x%02x", out[j] & 0xFF);
189         printf ("\n");
190       }
191 #endif
192
193       if (memcmp (tv[i].mac, out, blklen))
194         fail ("cbc-mac algo %d, encrypt mismatch entry %d\n", tv[i].algo, i);
195
196       gcry_cipher_close (hd);
197     }
198   if (verbose)
199     fprintf (stderr, "Completed CBC MAC checks.\n");
200 }
201
202 static void
203 check_aes128_cbc_cts_cipher (void)
204 {
205   char key[128 / 8] = "chicken teriyaki";
206   unsigned char plaintext[] =
207     "I would like the General Gau's Chicken, please, and wonton soup.";
208   struct tv
209   {
210     unsigned char out[MAX_DATA_LEN];
211     int inlen;
212   } tv[] =
213     {
214       { "\xc6\x35\x35\x68\xf2\xbf\x8c\xb4\xd8\xa5\x80\x36\x2d\xa7\xff\x7f"
215         "\x97",
216         17 },
217       { "\xfc\x00\x78\x3e\x0e\xfd\xb2\xc1\xd4\x45\xd4\xc8\xef\xf7\xed\x22"
218         "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5",
219         31 },
220       { "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8"
221         "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84",
222         32 },
223       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
224         "\xb3\xff\xfd\x94\x0c\x16\xa1\x8c\x1b\x55\x49\xd2\xf8\x38\x02\x9e"
225         "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5",
226         47 },
227       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
228         "\x9d\xad\x8b\xbb\x96\xc4\xcd\xc0\x3b\xc1\x03\xe1\xa1\x94\xbb\xd8"
229         "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8",
230         48 },
231       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
232         "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8"
233         "\x48\x07\xef\xe8\x36\xee\x89\xa5\x26\x73\x0d\xbc\x2f\x7b\xc8\x40"
234         "\x9d\xad\x8b\xbb\x96\xc4\xcd\xc0\x3b\xc1\x03\xe1\xa1\x94\xbb\xd8",
235         64 },
236     };
237   gcry_cipher_hd_t hd;
238   unsigned char out[MAX_DATA_LEN];
239   int i;
240   gcry_error_t err = 0;
241
242   if (verbose)
243     fprintf (stderr, "Starting AES128 CBC CTS checks.\n");
244   err = gcry_cipher_open (&hd,
245                           GCRY_CIPHER_AES,
246                           GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_CTS);
247   if (err)
248     {
249       fail ("aes-cbc-cts, grcy_open_cipher failed: %s\n", gpg_strerror (err));
250       return;
251     }
252
253   err = gcry_cipher_setkey (hd, key, 128 / 8);
254   if (err)
255     {
256       fail ("aes-cbc-cts, gcry_cipher_setkey failed: %s\n",
257             gpg_strerror (err));
258       gcry_cipher_close (hd);
259       return;
260     }
261
262   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
263     {
264       err = gcry_cipher_setiv (hd, NULL, 0);
265       if (err)
266         {
267           fail ("aes-cbc-cts, gcry_cipher_setiv failed: %s\n",
268                 gpg_strerror (err));
269           gcry_cipher_close (hd);
270           return;
271         }
272
273       if (verbose)
274         fprintf (stderr, "  checking encryption for length %i\n", tv[i].inlen);
275       err = gcry_cipher_encrypt (hd, out, MAX_DATA_LEN,
276                                  plaintext, tv[i].inlen);
277       if (err)
278         {
279           fail ("aes-cbc-cts, gcry_cipher_encrypt failed: %s\n",
280                 gpg_strerror (err));
281           gcry_cipher_close (hd);
282           return;
283         }
284
285       if (memcmp (tv[i].out, out, tv[i].inlen))
286         fail ("aes-cbc-cts, encrypt mismatch entry %d\n", i);
287
288       err = gcry_cipher_setiv (hd, NULL, 0);
289       if (err)
290         {
291           fail ("aes-cbc-cts, gcry_cipher_setiv failed: %s\n",
292                 gpg_strerror (err));
293           gcry_cipher_close (hd);
294           return;
295         }
296       if (verbose)
297         fprintf (stderr, "  checking decryption for length %i\n", tv[i].inlen);
298       err = gcry_cipher_decrypt (hd, out, tv[i].inlen, NULL, 0);
299       if (err)
300         {
301           fail ("aes-cbc-cts, gcry_cipher_decrypt failed: %s\n",
302                 gpg_strerror (err));
303           gcry_cipher_close (hd);
304           return;
305         }
306
307       if (memcmp (plaintext, out, tv[i].inlen))
308         fail ("aes-cbc-cts, decrypt mismatch entry %d\n", i);
309     }
310
311   gcry_cipher_close (hd);
312   if (verbose)
313     fprintf (stderr, "Completed AES128 CBC CTS checks.\n");
314 }
315
316 static void
317 check_ctr_cipher (void)
318 {
319   struct tv
320   {
321     int algo;
322     char key[MAX_DATA_LEN];
323     char ctr[MAX_DATA_LEN];
324     struct data
325     {
326       unsigned char plaintext[MAX_DATA_LEN];
327       int inlen;
328       char out[MAX_DATA_LEN];
329     }
330     data[MAX_DATA_LEN];
331   } tv[] =
332     {
333       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
334       { GCRY_CIPHER_AES,
335         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
336         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
337         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
338             16,
339             "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
340           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
341             16,
342             "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd\xff" },
343           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
344             16,
345             "\x5a\xe4\xdf\x3e\xdb\xd5\xd3\x5e\x5b\x4f\x09\x02\x0d\xb0\x3e\xab" },
346           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
347             16,
348             "\x1e\x03\x1d\xda\x2f\xbe\x03\xd1\x79\x21\x70\xa0\xf3\x00\x9c\xee" },
349         }
350       },
351       { GCRY_CIPHER_AES192,
352         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
353         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
354         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
355         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
356             16,
357             "\x1a\xbc\x93\x24\x17\x52\x1c\xa2\x4f\x2b\x04\x59\xfe\x7e\x6e\x0b" },
358           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
359             16,
360             "\x09\x03\x39\xec\x0a\xa6\xfa\xef\xd5\xcc\xc2\xc6\xf4\xce\x8e\x94" },
361           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
362             16,
363             "\x1e\x36\xb2\x6b\xd1\xeb\xc6\x70\xd1\xbd\x1d\x66\x56\x20\xab\xf7" },
364           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
365             16,
366             "\x4f\x78\xa7\xf6\xd2\x98\x09\x58\x5a\x97\xda\xec\x58\xc6\xb0\x50" },
367         }
368       },
369       { GCRY_CIPHER_AES256,
370         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
371         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
372         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
373         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
374             16,
375             "\x60\x1e\xc3\x13\x77\x57\x89\xa5\xb7\xa7\xf5\x04\xbb\xf3\xd2\x28" },
376           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
377             16,
378             "\xf4\x43\xe3\xca\x4d\x62\xb5\x9a\xca\x84\xe9\x90\xca\xca\xf5\xc5" },
379           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
380             16,
381             "\x2b\x09\x30\xda\xa2\x3d\xe9\x4c\xe8\x70\x17\xba\x2d\x84\x98\x8d" },
382           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
383             16,
384             "\xdf\xc9\xc5\x8d\xb6\x7a\xad\xa6\x13\xc2\xdd\x08\x45\x79\x41\xa6" }
385         }
386       }
387     };
388   gcry_cipher_hd_t hde, hdd;
389   unsigned char out[MAX_DATA_LEN];
390   int i, j, keylen, blklen;
391   gcry_error_t err = 0;
392
393   if (verbose)
394     fprintf (stderr, "Starting CTR cipher checks.\n");
395   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
396     {
397       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_CTR, 0);
398       if (!err)
399         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_CTR, 0);
400       if (err)
401         {
402           fail ("aes-ctr, grcy_open_cipher failed: %s\n", gpg_strerror (err));
403           return;
404         }
405
406       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
407       if (!keylen)
408         {
409           fail ("aes-ctr, gcry_cipher_get_algo_keylen failed\n");
410           return;
411         }
412
413       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
414       if (!err)
415         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
416       if (err)
417         {
418           fail ("aes-ctr, gcry_cipher_setkey failed: %s\n",
419                 gpg_strerror (err));
420           gcry_cipher_close (hde);
421           gcry_cipher_close (hdd);
422           return;
423         }
424
425       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
426       if (!blklen)
427         {
428           fail ("aes-ctr, gcry_cipher_get_algo_blklen failed\n");
429           return;
430         }
431
432       err = gcry_cipher_setctr (hde, tv[i].ctr, blklen);
433       if (!err)
434         err = gcry_cipher_setctr (hdd, tv[i].ctr, blklen);
435       if (err)
436         {
437           fail ("aes-ctr, gcry_cipher_setctr failed: %s\n",
438                 gpg_strerror (err));
439           gcry_cipher_close (hde);
440           gcry_cipher_close (hdd);
441           return;
442         }
443
444       if (verbose)
445         fprintf (stderr, "  checking CTR mode for for %s [%i]\n", 
446                  gcry_cipher_algo_name (tv[i].algo),
447                  tv[i].algo);
448       for (j = 0; tv[i].data[j].inlen; j++)
449         {
450           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
451                                      tv[i].data[j].plaintext,
452                                      tv[i].data[j].inlen == -1 ?
453                                      strlen ((char*)tv[i].data[j].plaintext) :
454                                      tv[i].data[j].inlen);
455           if (err)
456             {
457               fail ("aes-ctr, gcry_cipher_encrypt (%d, %d) failed: %s\n",
458                     i, j, gpg_strerror (err));
459               gcry_cipher_close (hde);
460               gcry_cipher_close (hdd);
461               return;
462             }
463
464           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
465             fail ("aes-ctr, encrypt mismatch entry %d:%d\n", i, j);
466
467           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
468           if (err)
469             {
470               fail ("aes-ctr, gcry_cipher_decrypt (%d, %d) failed: %s\n",
471                     i, j, gpg_strerror (err));
472               gcry_cipher_close (hde);
473               gcry_cipher_close (hdd);
474               return;
475             }
476
477           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
478             fail ("aes-ctr, decrypt mismatch entry %d:%d\n", i, j);
479         }
480
481       gcry_cipher_close (hde);
482       gcry_cipher_close (hdd);
483     }
484   if (verbose)
485     fprintf (stderr, "Completed CTR cipher checks.\n");
486 }
487
488 static void
489 check_cfb_cipher (void)
490 {
491   struct tv
492   {
493     int algo;
494     char key[MAX_DATA_LEN];
495     char iv[MAX_DATA_LEN];
496     struct data
497     {
498       unsigned char plaintext[MAX_DATA_LEN];
499       int inlen;
500       char out[MAX_DATA_LEN];
501     }
502     data[MAX_DATA_LEN];
503   } tv[] =
504     {
505       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
506       { GCRY_CIPHER_AES,
507         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
508         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
509         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
510             16,
511             "\x3b\x3f\xd9\x2e\xb7\x2d\xad\x20\x33\x34\x49\xf8\xe8\x3c\xfb\x4a" },
512           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
513             16,
514             "\xc8\xa6\x45\x37\xa0\xb3\xa9\x3f\xcd\xe3\xcd\xad\x9f\x1c\xe5\x8b"},
515           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
516             16,
517             "\x26\x75\x1f\x67\xa3\xcb\xb1\x40\xb1\x80\x8c\xf1\x87\xa4\xf4\xdf" },
518           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
519             16,
520             "\xc0\x4b\x05\x35\x7c\x5d\x1c\x0e\xea\xc4\xc6\x6f\x9f\xf7\xf2\xe6" },
521         }
522       },
523       { GCRY_CIPHER_AES192,
524         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
525         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
526         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
527         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
528             16,
529             "\xcd\xc8\x0d\x6f\xdd\xf1\x8c\xab\x34\xc2\x59\x09\xc9\x9a\x41\x74" },
530           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
531             16,
532             "\x67\xce\x7f\x7f\x81\x17\x36\x21\x96\x1a\x2b\x70\x17\x1d\x3d\x7a" },
533           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
534             16,
535             "\x2e\x1e\x8a\x1d\xd5\x9b\x88\xb1\xc8\xe6\x0f\xed\x1e\xfa\xc4\xc9" },
536           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
537             16,
538             "\xc0\x5f\x9f\x9c\xa9\x83\x4f\xa0\x42\xae\x8f\xba\x58\x4b\x09\xff" },
539         }
540       },
541       { GCRY_CIPHER_AES256,
542         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
543         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
544         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
545         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
546             16,
547             "\xdc\x7e\x84\xbf\xda\x79\x16\x4b\x7e\xcd\x84\x86\x98\x5d\x38\x60" },
548           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
549             16,
550             "\x39\xff\xed\x14\x3b\x28\xb1\xc8\x32\x11\x3c\x63\x31\xe5\x40\x7b" },
551           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
552             16,
553             "\xdf\x10\x13\x24\x15\xe5\x4b\x92\xa1\x3e\xd0\xa8\x26\x7a\xe2\xf9" },
554           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
555             16,
556             "\x75\xa3\x85\x74\x1a\xb9\xce\xf8\x20\x31\x62\x3d\x55\xb1\xe4\x71" }
557         }
558       }
559     };
560   gcry_cipher_hd_t hde, hdd;
561   unsigned char out[MAX_DATA_LEN];
562   int i, j, keylen, blklen;
563   gcry_error_t err = 0;
564
565   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
566     {
567       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_CFB, 0);
568       if (!err)
569         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_CFB, 0);
570       if (err)
571         {
572           fail ("aes-cfb, grcy_open_cipher failed: %s\n", gpg_strerror (err));
573           return;
574         }
575
576       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
577       if (!keylen)
578         {
579           fail ("aes-cfb, gcry_cipher_get_algo_keylen failed\n");
580           return;
581         }
582
583       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
584       if (!err)
585         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
586       if (err)
587         {
588           fail ("aes-cfb, gcry_cipher_setkey failed: %s\n",
589                 gpg_strerror (err));
590           gcry_cipher_close (hde);
591           gcry_cipher_close (hdd);
592           return;
593         }
594
595       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
596       if (!blklen)
597         {
598           fail ("aes-cfb, gcry_cipher_get_algo_blklen failed\n");
599           return;
600         }
601
602       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
603       if (!err)
604         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
605       if (err)
606         {
607           fail ("aes-cfb, gcry_cipher_setiv failed: %s\n",
608                 gpg_strerror (err));
609           gcry_cipher_close (hde);
610           gcry_cipher_close (hdd);
611           return;
612         }
613
614       for (j = 0; tv[i].data[j].inlen; j++)
615         {
616           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
617                                      tv[i].data[j].plaintext,
618                                      tv[i].data[j].inlen);
619           if (err)
620             {
621               fail ("aes-cfb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
622                     i, j, gpg_strerror (err));
623               gcry_cipher_close (hde);
624               gcry_cipher_close (hdd);
625               return;
626             }
627
628           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen)) {
629             fail ("aes-cfb, encrypt mismatch entry %d:%d\n", i, j);
630           }
631           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
632           if (err)
633             {
634               fail ("aes-cfb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
635                     i, j, gpg_strerror (err));
636               gcry_cipher_close (hde);
637               gcry_cipher_close (hdd);
638               return;
639             }
640
641           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
642             fail ("aes-cfb, decrypt mismatch entry %d:%d\n", i, j);
643         }
644
645       gcry_cipher_close (hde);
646       gcry_cipher_close (hdd);
647     }
648 }
649
650 static void
651 check_ofb_cipher (void)
652 {
653   struct tv
654   {
655     int algo;
656     char key[MAX_DATA_LEN];
657     char iv[MAX_DATA_LEN];
658     struct data
659     {
660       unsigned char plaintext[MAX_DATA_LEN];
661       int inlen;
662       char out[MAX_DATA_LEN];
663     }
664     data[MAX_DATA_LEN];
665   } tv[] =
666     {
667       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
668       { GCRY_CIPHER_AES,
669         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
670         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
671         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
672             16,
673             "\x3b\x3f\xd9\x2e\xb7\x2d\xad\x20\x33\x34\x49\xf8\xe8\x3c\xfb\x4a" },
674           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
675             16,
676             "\x77\x89\x50\x8d\x16\x91\x8f\x03\xf5\x3c\x52\xda\xc5\x4e\xd8\x25"},
677           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
678             16,
679             "\x97\x40\x05\x1e\x9c\x5f\xec\xf6\x43\x44\xf7\xa8\x22\x60\xed\xcc" },
680           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
681             16,
682             "\x30\x4c\x65\x28\xf6\x59\xc7\x78\x66\xa5\x10\xd9\xc1\xd6\xae\x5e" },
683         }
684       },
685       { GCRY_CIPHER_AES192,
686         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
687         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
688         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
689         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
690             16,
691             "\xcd\xc8\x0d\x6f\xdd\xf1\x8c\xab\x34\xc2\x59\x09\xc9\x9a\x41\x74" },
692           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
693             16,
694             "\xfc\xc2\x8b\x8d\x4c\x63\x83\x7c\x09\xe8\x17\x00\xc1\x10\x04\x01" },
695           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
696             16,
697             "\x8d\x9a\x9a\xea\xc0\xf6\x59\x6f\x55\x9c\x6d\x4d\xaf\x59\xa5\xf2" },
698           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
699             16,
700             "\x6d\x9f\x20\x08\x57\xca\x6c\x3e\x9c\xac\x52\x4b\xd9\xac\xc9\x2a" },
701         }
702       },
703       { GCRY_CIPHER_AES256,
704         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
705         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
706         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
707         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
708             16,
709             "\xdc\x7e\x84\xbf\xda\x79\x16\x4b\x7e\xcd\x84\x86\x98\x5d\x38\x60" },
710           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
711             16,
712             "\x4f\xeb\xdc\x67\x40\xd2\x0b\x3a\xc8\x8f\x6a\xd8\x2a\x4f\xb0\x8d" },
713           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
714             16,
715             "\x71\xab\x47\xa0\x86\xe8\x6e\xed\xf3\x9d\x1c\x5b\xba\x97\xc4\x08" },
716           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
717             16,
718             "\x01\x26\x14\x1d\x67\xf3\x7b\xe8\x53\x8f\x5a\x8b\xe7\x40\xe4\x84" }
719         }
720       }
721     };
722   gcry_cipher_hd_t hde, hdd;
723   unsigned char out[MAX_DATA_LEN];
724   int i, j, keylen, blklen;
725   gcry_error_t err = 0;
726
727   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
728     {
729       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_OFB, 0);
730       if (!err)
731         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_OFB, 0);
732       if (err)
733         {
734           fail ("aes-ofb, grcy_open_cipher failed: %s\n", gpg_strerror (err));
735           return;
736         }
737
738       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
739       if (!keylen)
740         {
741           fail ("aes-ofb, gcry_cipher_get_algo_keylen failed\n");
742           return;
743         }
744
745       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
746       if (!err)
747         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
748       if (err)
749         {
750           fail ("aes-ofb, gcry_cipher_setkey failed: %s\n",
751                 gpg_strerror (err));
752           gcry_cipher_close (hde);
753           gcry_cipher_close (hdd);
754           return;
755         }
756
757       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
758       if (!blklen)
759         {
760           fail ("aes-ofb, gcry_cipher_get_algo_blklen failed\n");
761           return;
762         }
763
764       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
765       if (!err)
766         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
767       if (err)
768         {
769           fail ("aes-ofb, gcry_cipher_setiv failed: %s\n",
770                 gpg_strerror (err));
771           gcry_cipher_close (hde);
772           gcry_cipher_close (hdd);
773           return;
774         }
775
776       for (j = 0; tv[i].data[j].inlen; j++)
777         {
778           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
779                                      tv[i].data[j].plaintext,
780                                      tv[i].data[j].inlen);
781           if (err)
782             {
783               fail ("aes-ofb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
784                     i, j, gpg_strerror (err));
785               gcry_cipher_close (hde);
786               gcry_cipher_close (hdd);
787               return;
788             }
789
790           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
791             fail ("aes-ofb, encrypt mismatch entry %d:%d\n", i, j);
792
793           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
794           if (err)
795             {
796               fail ("aes-ofb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
797                     i, j, gpg_strerror (err));
798               gcry_cipher_close (hde);
799               gcry_cipher_close (hdd);
800               return;
801             }
802
803           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
804             fail ("aes-ofb, decrypt mismatch entry %d:%d\n", i, j);
805         }
806
807       err = gcry_cipher_reset(hde);
808       if (!err)
809         err = gcry_cipher_reset(hdd);
810       if (err)
811         {
812           fail ("aes-ofb, gcry_cipher_reset (%d, %d) failed: %s\n",
813                 i, j, gpg_strerror (err));
814           gcry_cipher_close (hde);
815           gcry_cipher_close (hdd);
816           return;
817         }
818
819       /* gcry_cipher_reset clears the IV */
820       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
821       if (!err)
822         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
823       if (err)
824         {
825           fail ("aes-ofb, gcry_cipher_setiv failed: %s\n",
826                 gpg_strerror (err));
827           gcry_cipher_close (hde);
828           gcry_cipher_close (hdd);
829           return;
830         }
831
832       /* this time we encrypt and decrypt one byte at a time */
833       for (j = 0; tv[i].data[j].inlen; j++)
834         {
835           int byteNum;
836           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum) 
837             {
838               err = gcry_cipher_encrypt (hde, out+byteNum, 1,
839                                          (tv[i].data[j].plaintext) + byteNum,
840                                          1);
841               if (err)
842                 {
843                   fail ("aes-ofb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
844                         i, j, gpg_strerror (err));
845                   gcry_cipher_close (hde);
846                   gcry_cipher_close (hdd);
847                   return;
848                 }
849             }
850
851           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
852             fail ("aes-ofb, encrypt mismatch entry %d:%d\n", i, j);
853
854           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum) 
855             {
856               err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
857               if (err)
858                 {
859                   fail ("aes-ofb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
860                         i, j, gpg_strerror (err));
861                   gcry_cipher_close (hde);
862                   gcry_cipher_close (hdd);
863                   return;
864                 }
865             }
866
867           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
868             fail ("aes-ofb, decrypt mismatch entry %d:%d\n", i, j);
869         }
870
871       gcry_cipher_close (hde);
872       gcry_cipher_close (hdd);
873     }
874 }
875
876 static void
877 check_one_cipher (int algo, int mode, int flags)
878 {
879   gcry_cipher_hd_t hd;
880   char key[32];
881   unsigned char plain[16], in[16], out[16];
882   int keylen;
883   gcry_error_t err = 0;
884
885   memcpy (key, "0123456789abcdef.,;/[]{}-=ABCDEF", 32);
886   memcpy (plain, "foobar42FOOBAR17", 16);
887
888   keylen = gcry_cipher_get_algo_keylen (algo);
889   if (!keylen)
890     {
891       fail ("algo %d, mode %d, gcry_cipher_get_algo_keylen failed\n",
892             algo, mode);
893       return;
894     }
895
896   if (keylen < 40 / 8 || keylen > 32)
897     {
898       fail ("algo %d, mode %d, keylength problem (%d)\n", algo, mode, keylen);
899       return;
900     }
901
902   err = gcry_cipher_open (&hd, algo, mode, flags);
903   if (err)
904     {
905       fail ("algo %d, mode %d, grcy_open_cipher failed: %s\n",
906             algo, mode, gpg_strerror (err));
907       return;
908     }
909
910   err = gcry_cipher_setkey (hd, key, keylen);
911   if (err)
912     {
913       fail ("algo %d, mode %d, gcry_cipher_setkey failed: %s\n",
914             algo, mode, gpg_strerror (err));
915       gcry_cipher_close (hd);
916       return;
917     }
918
919   err = gcry_cipher_encrypt (hd, out, 16, plain, 16);
920   if (err)
921     {
922       fail ("algo %d, mode %d, gcry_cipher_encrypt failed: %s\n",
923             algo, mode, gpg_strerror (err));
924       gcry_cipher_close (hd);
925       return;
926     }
927
928   gcry_cipher_reset (hd);
929
930   err = gcry_cipher_decrypt (hd, in, 16, out, 16);
931   if (err)
932     {
933       fail ("algo %d, mode %d, gcry_cipher_decrypt failed: %s\n",
934             algo, mode, gpg_strerror (err));
935       gcry_cipher_close (hd);
936       return;
937     }
938
939   gcry_cipher_close (hd);
940
941   if (memcmp (plain, in, 16))
942     fail ("algo %d, mode %d, encrypt-decrypt mismatch\n", algo, mode);
943 }
944
945
946 static void
947 check_ciphers (void)
948 {
949   static int algos[] = {
950     GCRY_CIPHER_3DES,
951     GCRY_CIPHER_CAST5,
952     GCRY_CIPHER_BLOWFISH,
953     GCRY_CIPHER_AES,
954     GCRY_CIPHER_AES192,
955     GCRY_CIPHER_AES256,
956     GCRY_CIPHER_TWOFISH,
957     GCRY_CIPHER_TWOFISH128,
958     GCRY_CIPHER_DES,
959     GCRY_CIPHER_SERPENT128,
960     GCRY_CIPHER_SERPENT192,
961     GCRY_CIPHER_SERPENT256,
962     0
963   };
964   static int algos2[] = {
965     GCRY_CIPHER_ARCFOUR,
966     0
967   };
968   int i;
969
970   if (verbose)
971     fprintf (stderr, "Starting Cipher checks.\n");
972   for (i = 0; algos[i]; i++)
973     {
974       if (verbose)
975         fprintf (stderr, "  checking %s [%i]\n",
976                  gcry_cipher_algo_name (algos[i]),
977                  gcry_cipher_map_name (gcry_cipher_algo_name (algos[i])));
978
979       check_one_cipher (algos[i], GCRY_CIPHER_MODE_ECB, 0);
980       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CFB, 0);
981       check_one_cipher (algos[i], GCRY_CIPHER_MODE_OFB, 0);
982       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, 0);
983       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_CTS);
984       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CTR, 0);
985     }
986
987   for (i = 0; algos2[i]; i++)
988     {
989       if (verbose)
990         fprintf (stderr, "  checking `%s'\n",
991                  gcry_cipher_algo_name (algos2[i]));
992
993       check_one_cipher (algos2[i], GCRY_CIPHER_MODE_STREAM, 0);
994     }
995   /* we have now run all cipher's selftests */
996
997   if (verbose)
998     fprintf (stderr, "Completed Cipher checks.\n");
999
1000   /* TODO: add some extra encryption to test the higher level functions */
1001 }
1002
1003
1004
1005 static void
1006 check_one_md (int algo, char *data, int len, char *expect)
1007 {
1008   gcry_md_hd_t hd, hd2;
1009   unsigned char *p;
1010   int mdlen;
1011   int i;
1012   gcry_error_t err = 0;
1013
1014   err = gcry_md_open (&hd, algo, 0);
1015   if (err)
1016     {
1017       fail ("algo %d, grcy_md_open failed: %s\n", algo, gpg_strerror (err));
1018       return;
1019     }
1020
1021   mdlen = gcry_md_get_algo_dlen (algo);
1022   if (mdlen < 1 || mdlen > 500)
1023     {
1024       fail ("algo %d, grcy_md_get_algo_dlen failed: %d\n", algo, mdlen);
1025       return;
1026     }
1027
1028   if (*data == '!' && !data[1])
1029     {                           /* hash one million times a "a" */
1030       char aaa[1000];
1031
1032       memset (aaa, 'a', 1000);
1033       for (i = 0; i < 1000; i++)
1034         gcry_md_write (hd, aaa, 1000);
1035     }
1036   else
1037     gcry_md_write (hd, data, len);
1038
1039   err = gcry_md_copy (&hd2, hd);
1040   if (err)
1041     {
1042       fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
1043     }
1044
1045   gcry_md_close (hd);
1046
1047   p = gcry_md_read (hd2, algo);
1048
1049   if (memcmp (p, expect, mdlen))
1050     {
1051       printf ("computed: ");
1052       for (i = 0; i < mdlen; i++)
1053         printf ("%02x ", p[i] & 0xFF);
1054       printf ("\nexpected: ");
1055       for (i = 0; i < mdlen; i++)
1056         printf ("%02x ", expect[i] & 0xFF);
1057       printf ("\n");
1058
1059       fail ("algo %d, digest mismatch\n", algo);
1060     }
1061
1062   gcry_md_close (hd2);
1063 }
1064
1065 static void
1066 check_digests (void)
1067 {
1068   static struct algos
1069   {
1070     int md;
1071     char *data;
1072     char *expect;
1073   } algos[] =
1074     {
1075       { GCRY_MD_MD4, "",
1076         "\x31\xD6\xCF\xE0\xD1\x6A\xE9\x31\xB7\x3C\x59\xD7\xE0\xC0\x89\xC0" },
1077       { GCRY_MD_MD4, "a",
1078         "\xbd\xe5\x2c\xb3\x1d\xe3\x3e\x46\x24\x5e\x05\xfb\xdb\xd6\xfb\x24" },
1079       { GCRY_MD_MD4, "message digest",
1080         "\xd9\x13\x0a\x81\x64\x54\x9f\xe8\x18\x87\x48\x06\xe1\xc7\x01\x4b" },
1081       { GCRY_MD_MD5, "",
1082         "\xD4\x1D\x8C\xD9\x8F\x00\xB2\x04\xE9\x80\x09\x98\xEC\xF8\x42\x7E" },
1083       { GCRY_MD_MD5, "a",
1084         "\x0C\xC1\x75\xB9\xC0\xF1\xB6\xA8\x31\xC3\x99\xE2\x69\x77\x26\x61" },
1085       { GCRY_MD_MD5, "abc",
1086         "\x90\x01\x50\x98\x3C\xD2\x4F\xB0\xD6\x96\x3F\x7D\x28\xE1\x7F\x72" },
1087       { GCRY_MD_MD5, "message digest",
1088         "\xF9\x6B\x69\x7D\x7C\xB7\x93\x8D\x52\x5A\x2F\x31\xAA\xF1\x61\xD0" },
1089       { GCRY_MD_SHA1, "abc",
1090         "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E"
1091         "\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" },
1092       { GCRY_MD_SHA1,
1093         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1094         "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE"
1095         "\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" },
1096       { GCRY_MD_SHA1, "!" /* kludge for "a"*1000000 */ ,
1097         "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E"
1098         "\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" },
1099       // From RFC3874
1100       { GCRY_MD_SHA224, "abc",
1101         "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
1102         "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7" },
1103       { GCRY_MD_SHA224,
1104         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1105         "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01\x50"
1106         "\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25" },
1107       { GCRY_MD_SHA224, "!",
1108         "\x20\x79\x46\x55\x98\x0c\x91\xd8\xbb\xb4\xc1\xea\x97\x61\x8a\x4b"
1109         "\xf0\x3f\x42\x58\x19\x48\xb2\xee\x4e\xe7\xad\x67" },
1110       { GCRY_MD_SHA256, "abc",
1111         "\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
1112         "\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad" },
1113       { GCRY_MD_SHA256,
1114         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1115         "\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
1116         "\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1" },
1117       { GCRY_MD_SHA256, "!",
1118         "\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67"
1119         "\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0" },
1120       { GCRY_MD_SHA384, "abc",
1121         "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b\xb5\xa0\x3d\x69\x9a\xc6\x50\x07"
1122         "\x27\x2c\x32\xab\x0e\xde\xd1\x63\x1a\x8b\x60\x5a\x43\xff\x5b\xed"
1123         "\x80\x86\x07\x2b\xa1\xe7\xcc\x23\x58\xba\xec\xa1\x34\xc8\x25\xa7" },
1124       { GCRY_MD_SHA512, "abc",
1125         "\xDD\xAF\x35\xA1\x93\x61\x7A\xBA\xCC\x41\x73\x49\xAE\x20\x41\x31"
1126         "\x12\xE6\xFA\x4E\x89\xA9\x7E\xA2\x0A\x9E\xEE\xE6\x4B\x55\xD3\x9A"
1127         "\x21\x92\x99\x2A\x27\x4F\xC1\xA8\x36\xBA\x3C\x23\xA3\xFE\xEB\xBD"
1128         "\x45\x4D\x44\x23\x64\x3C\xE8\x0E\x2A\x9A\xC9\x4F\xA5\x4C\xA4\x9F" },
1129       { GCRY_MD_RMD160, "",
1130         "\x9c\x11\x85\xa5\xc5\xe9\xfc\x54\x61\x28"
1131         "\x08\x97\x7e\xe8\xf5\x48\xb2\x25\x8d\x31" },
1132       { GCRY_MD_RMD160, "a",
1133         "\x0b\xdc\x9d\x2d\x25\x6b\x3e\xe9\xda\xae"
1134         "\x34\x7b\xe6\xf4\xdc\x83\x5a\x46\x7f\xfe" },
1135       { GCRY_MD_RMD160, "abc",
1136         "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04"
1137         "\x4a\x8e\x98\xc6\xb0\x87\xf1\x5a\x0b\xfc" },
1138       { GCRY_MD_RMD160, "message digest",
1139         "\x5d\x06\x89\xef\x49\xd2\xfa\xe5\x72\xb8"
1140         "\x81\xb1\x23\xa8\x5f\xfa\x21\x59\x5f\x36" },
1141       { GCRY_MD_CRC32, "", "\x00\x00\x00\x00" },
1142       { GCRY_MD_CRC32, "foo", "\x8c\x73\x65\x21" },
1143       { GCRY_MD_CRC32_RFC1510, "", "\x00\x00\x00\x00" },
1144       { GCRY_MD_CRC32_RFC1510, "foo", "\x73\x32\xbc\x33" },
1145       { GCRY_MD_CRC32_RFC1510, "test0123456789", "\xb8\x3e\x88\xd6" },
1146       { GCRY_MD_CRC32_RFC1510, "MASSACHVSETTS INSTITVTE OF TECHNOLOGY",
1147         "\xe3\x41\x80\xf7" },
1148 #if 0
1149       { GCRY_MD_CRC32_RFC1510, "\x80\x00", "\x3b\x83\x98\x4b" },
1150       { GCRY_MD_CRC32_RFC1510, "\x00\x08", "\x0e\xdb\x88\x32" },
1151       { GCRY_MD_CRC32_RFC1510, "\x00\x80", "\xed\xb8\x83\x20" },
1152 #endif
1153       { GCRY_MD_CRC32_RFC1510, "\x80", "\xed\xb8\x83\x20" },
1154 #if 0
1155       { GCRY_MD_CRC32_RFC1510, "\x80\x00\x00\x00", "\xed\x59\xb6\x3b" },
1156       { GCRY_MD_CRC32_RFC1510, "\x00\x00\x00\x01", "\x77\x07\x30\x96" },
1157 #endif
1158       { GCRY_MD_CRC24_RFC2440, "", "\xb7\x04\xce" },
1159       { GCRY_MD_CRC24_RFC2440, "foo", "\x4f\xc2\x55" },
1160       { GCRY_MD_TIGER, "",
1161         "\x24\xF0\x13\x0C\x63\xAC\x93\x32\x16\x16\x6E\x76"
1162         "\xB1\xBB\x92\x5F\xF3\x73\xDE\x2D\x49\x58\x4E\x7A" },
1163       { GCRY_MD_TIGER, "abc",
1164         "\xF2\x58\xC1\xE8\x84\x14\xAB\x2A\x52\x7A\xB5\x41"
1165         "\xFF\xC5\xB8\xBF\x93\x5F\x7B\x95\x1C\x13\x29\x51" },
1166       { GCRY_MD_TIGER, "Tiger",
1167         "\x9F\x00\xF5\x99\x07\x23\x00\xDD\x27\x6A\xBB\x38"
1168         "\xC8\xEB\x6D\xEC\x37\x79\x0C\x11\x6F\x9D\x2B\xDF" },
1169       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg"
1170         "hijklmnopqrstuvwxyz0123456789+-",
1171         "\x87\xFB\x2A\x90\x83\x85\x1C\xF7\x47\x0D\x2C\xF8"
1172         "\x10\xE6\xDF\x9E\xB5\x86\x44\x50\x34\xA5\xA3\x86" },
1173       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdef"
1174         "ghijklmnopqrstuvwxyz+0123456789",
1175         "\x46\x7D\xB8\x08\x63\xEB\xCE\x48\x8D\xF1\xCD\x12"
1176         "\x61\x65\x5D\xE9\x57\x89\x65\x65\x97\x5F\x91\x97" },
1177       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
1178         "by Ross Anderson and Eli Biham",
1179         "\x0C\x41\x0A\x04\x29\x68\x86\x8A\x16\x71\xDA\x5A"
1180         "\x3F\xD2\x9A\x72\x5E\xC1\xE4\x57\xD3\xCD\xB3\x03" },
1181       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
1182         "by Ross Anderson and Eli Biham, proceedings of Fa"
1183         "st Software Encryption 3, Cambridge.",
1184         "\xEB\xF5\x91\xD5\xAF\xA6\x55\xCE\x7F\x22\x89\x4F"
1185         "\xF8\x7F\x54\xAC\x89\xC8\x11\xB6\xB0\xDA\x31\x93" },
1186       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
1187         "by Ross Anderson and Eli Biham, proceedings of Fa"
1188         "st Software Encryption 3, Cambridge, 1996.",
1189         "\x3D\x9A\xEB\x03\xD1\xBD\x1A\x63\x57\xB2\x77\x4D"
1190         "\xFD\x6D\x5B\x24\xDD\x68\x15\x1D\x50\x39\x74\xFC" },
1191       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefgh"
1192         "ijklmnopqrstuvwxyz0123456789+-ABCDEFGHIJKLMNOPQRS"
1193         "TUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-",
1194         "\x00\xB8\x3E\xB4\xE5\x34\x40\xC5\x76\xAC\x6A\xAE"
1195         "\xE0\xA7\x48\x58\x25\xFD\x15\xE7\x0A\x59\xFF\xE4" },
1196       { GCRY_MD_WHIRLPOOL, "",
1197         "\x19\xFA\x61\xD7\x55\x22\xA4\x66\x9B\x44\xE3\x9C\x1D\x2E\x17\x26"
1198         "\xC5\x30\x23\x21\x30\xD4\x07\xF8\x9A\xFE\xE0\x96\x49\x97\xF7\xA7"
1199         "\x3E\x83\xBE\x69\x8B\x28\x8F\xEB\xCF\x88\xE3\xE0\x3C\x4F\x07\x57"
1200         "\xEA\x89\x64\xE5\x9B\x63\xD9\x37\x08\xB1\x38\xCC\x42\xA6\x6E\xB3" },
1201       { GCRY_MD_WHIRLPOOL, "a",
1202         "\x8A\xCA\x26\x02\x79\x2A\xEC\x6F\x11\xA6\x72\x06\x53\x1F\xB7\xD7"
1203         "\xF0\xDF\xF5\x94\x13\x14\x5E\x69\x73\xC4\x50\x01\xD0\x08\x7B\x42"
1204         "\xD1\x1B\xC6\x45\x41\x3A\xEF\xF6\x3A\x42\x39\x1A\x39\x14\x5A\x59"
1205         "\x1A\x92\x20\x0D\x56\x01\x95\xE5\x3B\x47\x85\x84\xFD\xAE\x23\x1A" },
1206       { GCRY_MD_WHIRLPOOL, "a",
1207         "\x8A\xCA\x26\x02\x79\x2A\xEC\x6F\x11\xA6\x72\x06\x53\x1F\xB7\xD7"
1208         "\xF0\xDF\xF5\x94\x13\x14\x5E\x69\x73\xC4\x50\x01\xD0\x08\x7B\x42"
1209         "\xD1\x1B\xC6\x45\x41\x3A\xEF\xF6\x3A\x42\x39\x1A\x39\x14\x5A\x59"
1210         "\x1A\x92\x20\x0D\x56\x01\x95\xE5\x3B\x47\x85\x84\xFD\xAE\x23\x1A" },
1211       { GCRY_MD_WHIRLPOOL,
1212         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
1213         "\xDC\x37\xE0\x08\xCF\x9E\xE6\x9B\xF1\x1F\x00\xED\x9A\xBA\x26\x90"
1214         "\x1D\xD7\xC2\x8C\xDE\xC0\x66\xCC\x6A\xF4\x2E\x40\xF8\x2F\x3A\x1E"
1215         "\x08\xEB\xA2\x66\x29\x12\x9D\x8F\xB7\xCB\x57\x21\x1B\x92\x81\xA6"
1216         "\x55\x17\xCC\x87\x9D\x7B\x96\x21\x42\xC6\x5F\x5A\x7A\xF0\x14\x67" },
1217       { GCRY_MD_WHIRLPOOL,
1218         "!",
1219         "\x0C\x99\x00\x5B\xEB\x57\xEF\xF5\x0A\x7C\xF0\x05\x56\x0D\xDF\x5D"
1220         "\x29\x05\x7F\xD8\x6B\x20\xBF\xD6\x2D\xEC\xA0\xF1\xCC\xEA\x4A\xF5"
1221         "\x1F\xC1\x54\x90\xED\xDC\x47\xAF\x32\xBB\x2B\x66\xC3\x4F\xF9\xAD"
1222         "\x8C\x60\x08\xAD\x67\x7F\x77\x12\x69\x53\xB2\x26\xE4\xED\x8B\x01" },
1223       { 0 },
1224     };
1225   int i;
1226
1227   if (verbose)
1228     fprintf (stderr, "Starting hash checks.\n");
1229
1230   for (i = 0; algos[i].md; i++)
1231     {
1232       if (verbose)
1233         fprintf (stderr, "  checking %s [%i] for length %zi\n", 
1234                  gcry_md_algo_name (algos[i].md),
1235                  algos[i].md,
1236                  strlen(algos[i].data));
1237
1238       check_one_md (algos[i].md, algos[i].data, strlen (algos[i].data),
1239                     algos[i].expect);
1240     }
1241
1242   if (verbose)
1243     fprintf (stderr, "Completed hash checks.\n");
1244 }
1245
1246 static void
1247 check_one_hmac (int algo, char *data, int datalen, 
1248                 char *key, int keylen, char *expect)
1249 {
1250   gcry_md_hd_t hd, hd2;
1251   unsigned char *p;
1252   int mdlen;
1253   int i;
1254   gcry_error_t err = 0;
1255
1256   err = gcry_md_open (&hd, algo, GCRY_MD_FLAG_HMAC);
1257   if (err)
1258     {
1259       fail ("algo %d, grcy_md_open failed: %s\n", algo, gpg_strerror (err));
1260       return;
1261     }
1262
1263   mdlen = gcry_md_get_algo_dlen (algo);
1264   if (mdlen < 1 || mdlen > 500)
1265     {
1266       fail ("algo %d, grcy_md_get_algo_dlen failed: %d\n", algo, mdlen);
1267       return;
1268     }
1269
1270   gcry_md_setkey( hd, key, keylen );
1271
1272   gcry_md_write (hd, data, datalen);
1273
1274   err = gcry_md_copy (&hd2, hd);
1275   if (err)
1276     {
1277       fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
1278     }
1279
1280   gcry_md_close (hd);
1281
1282   p = gcry_md_read (hd2, algo);
1283   if (0 == p)
1284     fail("algo %d, hmac gcry_md_read failed\n", algo);
1285
1286   if (memcmp (p, expect, mdlen))
1287     {
1288       printf ("computed: ");
1289       for (i = 0; i < mdlen; i++)
1290         printf ("%02x ", p[i] & 0xFF);
1291       printf ("\nexpected: ");
1292       for (i = 0; i < mdlen; i++)
1293         printf ("%02x ", expect[i] & 0xFF);
1294       printf ("\n");
1295
1296       fail ("algo %d, digest mismatch\n", algo);
1297     }
1298
1299   gcry_md_close (hd2);
1300 }
1301
1302 static void
1303 check_hmac (void)
1304 {
1305   static struct algos
1306   {
1307     int md;
1308     char *data;
1309     char *key;
1310     char *expect;
1311   } algos[] =
1312     {
1313       { GCRY_MD_MD5, "what do ya want for nothing?", "Jefe",
1314         "\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7\x38" },
1315       { GCRY_MD_MD5,
1316         "Hi There",
1317         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
1318         "\x92\x94\x72\x7a\x36\x38\xbb\x1c\x13\xf4\x8e\xf8\x15\x8b\xfc\x9d" },
1319       { GCRY_MD_MD5,
1320         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1321         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1322         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1323         "\xdd\xdd\xdd\xdd\xdd",
1324         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA",
1325         "\x56\xbe\x34\x52\x1d\x14\x4c\x88\xdb\xb8\xc7\x33\xf0\xe8\xb3\xf6" },
1326       { GCRY_MD_MD5,
1327         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1328         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1329         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1330         "\xcd\xcd\xcd\xcd\xcd",
1331         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
1332         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
1333         "\x69\x7e\xaf\x0a\xca\x3a\x3a\xea\x3a\x75\x16\x47\x46\xff\xaa\x79" },
1334       { GCRY_MD_MD5, "Test With Truncation",
1335         "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c",
1336         "\x56\x46\x1e\xf2\x34\x2e\xdc\x00\xf9\xba\xb9\x95\x69\x0e\xfd\x4c" },
1337       { GCRY_MD_MD5, "Test Using Larger Than Block-Size Key - Hash Key First",
1338         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1339         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1340         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1341         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1342         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1343         "\xaa\xaa\xaa\xaa\xaa",
1344         "\x6b\x1a\xb7\xfe\x4b\xd7\xbf\x8f\x0b\x62\xe6\xce\x61\xb9\xd0\xcd" },
1345       { GCRY_MD_MD5,
1346         "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
1347         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1348         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1349         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1350         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1351         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1352         "\xaa\xaa\xaa\xaa\xaa",
1353         "\x6f\x63\x0f\xad\x67\xcd\xa0\xee\x1f\xb1\xf5\x62\xdb\x3a\xa5\x3e", },
1354       { GCRY_MD_SHA256, "what do ya want for nothing?", "Jefe",
1355         "\x5b\xdc\xc1\x46\xbf\x60\x75\x4e\x6a\x04\x24\x26\x08\x95\x75\xc7\x5a"
1356         "\x00\x3f\x08\x9d\x27\x39\x83\x9d\xec\x58\xb9\x64\xec\x38\x43" },
1357       { GCRY_MD_SHA256,
1358         "Hi There",
1359         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
1360         "\x0b\x0b\x0b",
1361         "\xb0\x34\x4c\x61\xd8\xdb\x38\x53\x5c\xa8\xaf\xce\xaf\x0b\xf1\x2b\x88"
1362         "\x1d\xc2\x00\xc9\x83\x3d\xa7\x26\xe9\x37\x6c\x2e\x32\xcf\xf7" },
1363       { GCRY_MD_SHA256,
1364         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1365         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1366         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1367         "\xdd\xdd\xdd\xdd\xdd",
1368         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
1369         "\xAA\xAA\xAA\xAA",
1370         "\x77\x3e\xa9\x1e\x36\x80\x0e\x46\x85\x4d\xb8\xeb\xd0\x91\x81\xa7"
1371         "\x29\x59\x09\x8b\x3e\xf8\xc1\x22\xd9\x63\x55\x14\xce\xd5\x65\xfe" },
1372       { GCRY_MD_SHA256,
1373         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1374         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1375         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1376         "\xcd\xcd\xcd\xcd\xcd",
1377         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
1378         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
1379         "\x82\x55\x8a\x38\x9a\x44\x3c\x0e\xa4\xcc\x81\x98\x99\xf2\x08"
1380         "\x3a\x85\xf0\xfa\xa3\xe5\x78\xf8\x07\x7a\x2e\x3f\xf4\x67\x29\x66\x5b" },
1381       { GCRY_MD_SHA256, 
1382         "Test Using Larger Than Block-Size Key - Hash Key First",
1383         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1384         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1385         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1386         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1387         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1388         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1389         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1390         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1391         "\xaa\xaa\xaa",
1392         "\x60\xe4\x31\x59\x1e\xe0\xb6\x7f\x0d\x8a\x26\xaa\xcb\xf5\xb7\x7f"
1393         "\x8e\x0b\xc6\x21\x37\x28\xc5\x14\x05\x46\x04\x0f\x0e\xe3\x7f\x54" },
1394       { GCRY_MD_SHA256, 
1395         "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
1396         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1397         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1398         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1399         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1400         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1401         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1402         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1403         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1404         "\xaa\xaa\xaa",
1405         "\x9b\x09\xff\xa7\x1b\x94\x2f\xcb\x27\x63\x5f\xbc\xd5\xb0\xe9\x44"
1406         "\xbf\xdc\x63\x64\x4f\x07\x13\x93\x8a\x7f\x51\x53\x5c\x3a\x35\xe2" },
1407       { GCRY_MD_SHA224, "what do ya want for nothing?", "Jefe",
1408         "\xa3\x0e\x01\x09\x8b\xc6\xdb\xbf\x45\x69\x0f\x3a\x7e\x9e\x6d\x0f"
1409         "\x8b\xbe\xa2\xa3\x9e\x61\x48\x00\x8f\xd0\x5e\x44" },
1410       { GCRY_MD_SHA224,
1411         "Hi There",
1412         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
1413         "\x0b\x0b\x0b",
1414         "\x89\x6f\xb1\x12\x8a\xbb\xdf\x19\x68\x32\x10\x7c\xd4\x9d\xf3\x3f\x47"
1415         "\xb4\xb1\x16\x99\x12\xba\x4f\x53\x68\x4b\x22" },
1416       { GCRY_MD_SHA224,
1417         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1418         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1419         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1420         "\xdd\xdd\xdd\xdd\xdd",
1421         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
1422         "\xAA\xAA\xAA\xAA",
1423         "\x7f\xb3\xcb\x35\x88\xc6\xc1\xf6\xff\xa9\x69\x4d\x7d\x6a\xd2\x64"
1424         "\x93\x65\xb0\xc1\xf6\x5d\x69\xd1\xec\x83\x33\xea" },
1425       { GCRY_MD_SHA224,
1426         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1427         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1428         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1429         "\xcd\xcd\xcd\xcd\xcd",
1430         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
1431         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
1432         "\x6c\x11\x50\x68\x74\x01\x3c\xac\x6a\x2a\xbc\x1b\xb3\x82\x62"
1433         "\x7c\xec\x6a\x90\xd8\x6e\xfc\x01\x2d\xe7\xaf\xec\x5a" },
1434       { GCRY_MD_SHA224, 
1435         "Test Using Larger Than Block-Size Key - Hash Key First",
1436         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1437         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1438         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1439         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1440         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1441         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1442         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1443         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1444         "\xaa\xaa\xaa",
1445         "\x95\xe9\xa0\xdb\x96\x20\x95\xad\xae\xbe\x9b\x2d\x6f\x0d\xbc\xe2"
1446         "\xd4\x99\xf1\x12\xf2\xd2\xb7\x27\x3f\xa6\x87\x0e" },
1447       { GCRY_MD_SHA224, 
1448         "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
1449         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1450         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1451         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1452         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1453         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1454         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1455         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1456         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1457         "\xaa\xaa\xaa",
1458         "\x3a\x85\x41\x66\xac\x5d\x9f\x02\x3f\x54\xd5\x17\xd0\xb3\x9d\xbd"
1459         "\x94\x67\x70\xdb\x9c\x2b\x95\xc9\xf6\xf5\x65\xd1" },
1460       { GCRY_MD_SHA384, "what do ya want for nothing?", "Jefe",
1461         "\xaf\x45\xd2\xe3\x76\x48\x40\x31\x61\x7f\x78\xd2\xb5\x8a\x6b\x1b"
1462         "\x9c\x7e\xf4\x64\xf5\xa0\x1b\x47\xe4\x2e\xc3\x73\x63\x22\x44\x5e"
1463         "\x8e\x22\x40\xca\x5e\x69\xe2\xc7\x8b\x32\x39\xec\xfa\xb2\x16\x49" },
1464       { GCRY_MD_SHA384,
1465         "Hi There",
1466         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
1467         "\x0b\x0b\x0b",
1468         "\xaf\xd0\x39\x44\xd8\x48\x95\x62\x6b\x08\x25\xf4\xab\x46\x90\x7f\x15"
1469         "\xf9\xda\xdb\xe4\x10\x1e\xc6\x82\xaa\x03\x4c\x7c\xeb\xc5\x9c\xfa\xea"
1470         "\x9e\xa9\x07\x6e\xde\x7f\x4a\xf1\x52\xe8\xb2\xfa\x9c\xb6" },
1471       { GCRY_MD_SHA384,
1472         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1473         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1474         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1475         "\xdd\xdd\xdd\xdd\xdd",
1476         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
1477         "\xAA\xAA\xAA\xAA",
1478         "\x88\x06\x26\x08\xd3\xe6\xad\x8a\x0a\xa2\xac\xe0\x14\xc8\xa8\x6f"
1479         "\x0a\xa6\x35\xd9\x47\xac\x9f\xeb\xe8\x3e\xf4\xe5\x59\x66\x14\x4b"
1480         "\x2a\x5a\xb3\x9d\xc1\x38\x14\xb9\x4e\x3a\xb6\xe1\x01\xa3\x4f\x27" },
1481       { GCRY_MD_SHA384,
1482         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1483         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1484         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1485         "\xcd\xcd\xcd\xcd\xcd",
1486         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
1487         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
1488         "\x3e\x8a\x69\xb7\x78\x3c\x25\x85\x19\x33\xab\x62\x90\xaf\x6c\xa7"
1489         "\x7a\x99\x81\x48\x08\x50\x00\x9c\xc5\x57\x7c\x6e\x1f\x57\x3b\x4e"
1490         "\x68\x01\xdd\x23\xc4\xa7\xd6\x79\xcc\xf8\xa3\x86\xc6\x74\xcf\xfb" },
1491       { GCRY_MD_SHA384, 
1492         "Test Using Larger Than Block-Size Key - Hash Key First",
1493         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1494         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1495         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1496         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1497         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1498         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1499         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1500         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1501         "\xaa\xaa\xaa",
1502         "\x4e\xce\x08\x44\x85\x81\x3e\x90\x88\xd2\xc6\x3a\x04\x1b\xc5\xb4"
1503         "\x4f\x9e\xf1\x01\x2a\x2b\x58\x8f\x3c\xd1\x1f\x05\x03\x3a\xc4\xc6"
1504         "\x0c\x2e\xf6\xab\x40\x30\xfe\x82\x96\x24\x8d\xf1\x63\xf4\x49\x52" },
1505       { GCRY_MD_SHA384, 
1506         "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
1507         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1508         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1509         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1510         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1511         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1512         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1513         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1514         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1515         "\xaa\xaa\xaa",
1516         "\x66\x17\x17\x8e\x94\x1f\x02\x0d\x35\x1e\x2f\x25\x4e\x8f\xd3\x2c"
1517         "\x60\x24\x20\xfe\xb0\xb8\xfb\x9a\xdc\xce\xbb\x82\x46\x1e\x99\xc5"
1518         "\xa6\x78\xcc\x31\xe7\x99\x17\x6d\x38\x60\xe6\x11\x0c\x46\x52\x3e" },
1519       { GCRY_MD_SHA512, "what do ya want for nothing?", "Jefe",
1520         "\x16\x4b\x7a\x7b\xfc\xf8\x19\xe2\xe3\x95\xfb\xe7\x3b\x56\xe0\xa3"
1521         "\x87\xbd\x64\x22\x2e\x83\x1f\xd6\x10\x27\x0c\xd7\xea\x25\x05\x54"
1522         "\x97\x58\xbf\x75\xc0\x5a\x99\x4a\x6d\x03\x4f\x65\xf8\xf0\xe6\xfd"
1523         "\xca\xea\xb1\xa3\x4d\x4a\x6b\x4b\x63\x6e\x07\x0a\x38\xbc\xe7\x37" },
1524       { GCRY_MD_SHA512,
1525         "Hi There",
1526         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
1527         "\x0b\x0b\x0b",
1528         "\x87\xaa\x7c\xde\xa5\xef\x61\x9d\x4f\xf0\xb4\x24\x1a\x1d\x6c\xb0"
1529         "\x23\x79\xf4\xe2\xce\x4e\xc2\x78\x7a\xd0\xb3\x05\x45\xe1\x7c\xde"
1530         "\xda\xa8\x33\xb7\xd6\xb8\xa7\x02\x03\x8b\x27\x4e\xae\xa3\xf4\xe4"
1531         "\xbe\x9d\x91\x4e\xeb\x61\xf1\x70\x2e\x69\x6c\x20\x3a\x12\x68\x54" },
1532       { GCRY_MD_SHA512,
1533         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1534         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1535         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1536         "\xdd\xdd\xdd\xdd\xdd",
1537         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
1538         "\xAA\xAA\xAA\xAA",
1539         "\xfa\x73\xb0\x08\x9d\x56\xa2\x84\xef\xb0\xf0\x75\x6c\x89\x0b\xe9"
1540         "\xb1\xb5\xdb\xdd\x8e\xe8\x1a\x36\x55\xf8\x3e\x33\xb2\x27\x9d\x39"
1541         "\xbf\x3e\x84\x82\x79\xa7\x22\xc8\x06\xb4\x85\xa4\x7e\x67\xc8\x07"
1542         "\xb9\x46\xa3\x37\xbe\xe8\x94\x26\x74\x27\x88\x59\xe1\x32\x92\xfb"  },
1543       { GCRY_MD_SHA512,
1544         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1545         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1546         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1547         "\xcd\xcd\xcd\xcd\xcd",
1548         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
1549         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
1550         "\xb0\xba\x46\x56\x37\x45\x8c\x69\x90\xe5\xa8\xc5\xf6\x1d\x4a\xf7"
1551         "\xe5\x76\xd9\x7f\xf9\x4b\x87\x2d\xe7\x6f\x80\x50\x36\x1e\xe3\xdb"
1552         "\xa9\x1c\xa5\xc1\x1a\xa2\x5e\xb4\xd6\x79\x27\x5c\xc5\x78\x80\x63"
1553         "\xa5\xf1\x97\x41\x12\x0c\x4f\x2d\xe2\xad\xeb\xeb\x10\xa2\x98\xdd" },
1554       { GCRY_MD_SHA512, 
1555         "Test Using Larger Than Block-Size Key - Hash Key First",
1556         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1557         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1558         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1559         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1560         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1561         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1562         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1563         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1564         "\xaa\xaa\xaa",
1565         "\x80\xb2\x42\x63\xc7\xc1\xa3\xeb\xb7\x14\x93\xc1\xdd\x7b\xe8\xb4"
1566         "\x9b\x46\xd1\xf4\x1b\x4a\xee\xc1\x12\x1b\x01\x37\x83\xf8\xf3\x52"
1567         "\x6b\x56\xd0\x37\xe0\x5f\x25\x98\xbd\x0f\xd2\x21\x5d\x6a\x1e\x52"
1568         "\x95\xe6\x4f\x73\xf6\x3f\x0a\xec\x8b\x91\x5a\x98\x5d\x78\x65\x98" },
1569       { GCRY_MD_SHA512, 
1570         "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
1571         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1572         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1573         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1574         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1575         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1576         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1577         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1578         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1579         "\xaa\xaa\xaa",
1580         "\xe3\x7b\x6a\x77\x5d\xc8\x7d\xba\xa4\xdf\xa9\xf9\x6e\x5e\x3f\xfd"
1581         "\xde\xbd\x71\xf8\x86\x72\x89\x86\x5d\xf5\xa3\x2d\x20\xcd\xc9\x44"
1582         "\xb6\x02\x2c\xac\x3c\x49\x82\xb1\x0d\x5e\xeb\x55\xc3\xe4\xde\x15"
1583         "\x13\x46\x76\xfb\x6d\xe0\x44\x60\x65\xc9\x74\x40\xfa\x8c\x6a\x58" },
1584       { 0 },
1585     };
1586   int i;
1587
1588   if (verbose)
1589     fprintf (stderr, "Starting hashed MAC checks.\n");
1590
1591   for (i = 0; algos[i].md; i++)
1592     {
1593       if (verbose)
1594         fprintf (stderr, "  checking %s [%i] for length %zi\n", 
1595                  gcry_md_algo_name (algos[i].md),
1596                  algos[i].md,
1597                  strlen(algos[i].data));
1598
1599       check_one_hmac (algos[i].md, algos[i].data, strlen (algos[i].data),
1600                       algos[i].key, strlen(algos[i].key),
1601                       algos[i].expect);
1602     }
1603
1604   if (verbose)
1605     fprintf (stderr, "Completed hashed MAC checks.\n");
1606  }
1607
1608 /* Check that the signature SIG matches the hash HASH. PKEY is the
1609    public key used for the verification. BADHASH is a hasvalue which
1610    should; result in a bad signature status. */
1611 static void
1612 verify_one_signature (gcry_sexp_t pkey, gcry_sexp_t hash,
1613                       gcry_sexp_t badhash, gcry_sexp_t sig)
1614 {
1615   gcry_error_t rc;
1616
1617   rc = gcry_pk_verify (sig, hash, pkey);
1618   if (rc)
1619     fail ("gcry_pk_verify failed: %s\n", gpg_strerror (rc));
1620   rc = gcry_pk_verify (sig, badhash, pkey);
1621   if (gcry_err_code (rc) != GPG_ERR_BAD_SIGNATURE)
1622     fail ("gcry_pk_verify failed to detect a bad signature: %s\n",
1623           gpg_strerror (rc));
1624 }
1625
1626
1627 /* Test the public key sign function using the private ket SKEY. PKEY
1628    is used for verification. */
1629 static void
1630 check_pubkey_sign (int n, gcry_sexp_t skey, gcry_sexp_t pkey)
1631 {
1632   gcry_error_t rc;
1633   gcry_sexp_t sig, badhash, hash;
1634   int dataidx;
1635   static const char baddata[] =
1636     "(data\n (flags pkcs1)\n"
1637     " (hash sha1 #11223344556677889900AABBCCDDEEFF10203041#))\n";
1638   static struct
1639   {
1640     const char *data;
1641     int expected_rc;
1642   } datas[] =
1643     {
1644       { "(data\n (flags pkcs1)\n"
1645         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
1646         0 },
1647       { "(data\n (flags )\n"
1648         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
1649         GPG_ERR_CONFLICT },
1650       { "(data\n (flags pkcs1)\n"
1651         " (hash foo #11223344556677889900AABBCCDDEEFF10203040#))\n",
1652         GPG_ERR_DIGEST_ALGO },
1653       { "(data\n (flags )\n" " (value #11223344556677889900AA#))\n",
1654         0 },
1655       { "(data\n (flags )\n" " (value #0090223344556677889900AA#))\n",
1656         0 },
1657       { "(data\n (flags raw)\n" " (value #11223344556677889900AA#))\n",
1658         0 },
1659       { "(data\n (flags pkcs1)\n"
1660         " (value #11223344556677889900AA#))\n",
1661         GPG_ERR_CONFLICT },
1662       { "(data\n (flags raw foo)\n"
1663         " (value #11223344556677889900AA#))\n",
1664         GPG_ERR_INV_FLAG },
1665       { NULL }
1666     };
1667
1668   rc = gcry_sexp_sscan (&badhash, NULL, baddata, strlen (baddata));
1669   if (rc)
1670     die ("converting data failed: %s\n", gpg_strerror (rc));
1671
1672   for (dataidx = 0; datas[dataidx].data; dataidx++)
1673     {
1674       if (verbose)
1675         fprintf (stderr, "  signature test %d\n", dataidx);
1676
1677       rc = gcry_sexp_sscan (&hash, NULL, datas[dataidx].data,
1678                             strlen (datas[dataidx].data));
1679       if (rc)
1680         die ("converting data failed: %s\n", gpg_strerror (rc));
1681
1682       rc = gcry_pk_sign (&sig, hash, skey);
1683       if (gcry_err_code (rc) != datas[dataidx].expected_rc)
1684         fail ("gcry_pk_sign failed: %s\n", gpg_strerror (rc));
1685
1686       if (!rc)
1687         verify_one_signature (pkey, hash, badhash, sig);
1688
1689       gcry_sexp_release (sig);
1690       sig = NULL;
1691       gcry_sexp_release (hash);
1692       hash = NULL;
1693     }
1694
1695   gcry_sexp_release (badhash);
1696 }
1697
1698 static void
1699 check_pubkey_grip (int n, const unsigned char *grip,
1700                    gcry_sexp_t skey, gcry_sexp_t pkey)
1701 {
1702   unsigned char sgrip[20], pgrip[20];
1703
1704   if (!gcry_pk_get_keygrip (skey, sgrip))
1705     die ("get keygrip for private RSA key failed\n");
1706   if (!gcry_pk_get_keygrip (pkey, pgrip))
1707     die ("[%i] get keygrip for public RSA key failed\n", n);
1708   if (memcmp (sgrip, pgrip, 20))
1709     fail ("[%i] keygrips don't match\n", n);
1710   if (memcmp (sgrip, grip, 20))
1711     fail ("wrong keygrip for RSA key\n");
1712 }
1713
1714 static void
1715 do_check_one_pubkey (int n, gcry_sexp_t skey, gcry_sexp_t pkey,
1716                      const unsigned char *grip, int flags)
1717 {
1718  if (flags & FLAG_SIGN)
1719     check_pubkey_sign (n, skey, pkey);
1720  if (grip && (flags & FLAG_GRIP))
1721    check_pubkey_grip (n, grip, skey, pkey);
1722 }
1723
1724 static void
1725 check_one_pubkey (int n, test_spec_pubkey_t spec)
1726 {
1727   gcry_error_t err = GPG_ERR_NO_ERROR;
1728   gcry_sexp_t skey, pkey;
1729
1730   err = gcry_sexp_sscan (&skey, NULL, spec.key.secret,
1731                          strlen (spec.key.secret));
1732   if (!err)
1733     err = gcry_sexp_sscan (&pkey, NULL, spec.key.public,
1734                            strlen (spec.key.public));
1735   if (err)
1736     die ("converting sample key failed: %s\n", gpg_strerror (err));
1737
1738   do_check_one_pubkey (n, skey, pkey, spec.key.grip, spec.flags);
1739  
1740   gcry_sexp_release (skey);
1741   gcry_sexp_release (pkey);
1742 }
1743
1744 static void
1745 get_keys_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
1746 {
1747   gcry_sexp_t key_spec, key, pub_key, sec_key;
1748   int rc;
1749   if (verbose)
1750     fprintf (stderr, "  generating RSA key:");  
1751   rc = gcry_sexp_new (&key_spec,
1752                       "(genkey (rsa (nbits 4:1024)))", 0, 1);
1753   if (rc)
1754     die ("error creating S-expression: %s\n", gpg_strerror (rc));
1755   rc = gcry_pk_genkey (&key, key_spec);
1756   gcry_sexp_release (key_spec);
1757   if (rc)
1758     die ("error generating RSA key: %s\n", gpg_strerror (rc));
1759     
1760   pub_key = gcry_sexp_find_token (key, "public-key", 0);
1761   if (! pub_key)
1762     die ("public part missing in key\n");
1763
1764   sec_key = gcry_sexp_find_token (key, "private-key", 0);
1765   if (! sec_key)
1766     die ("private part missing in key\n");
1767
1768   gcry_sexp_release (key);
1769   *pkey = pub_key;
1770   *skey = sec_key;
1771 }
1772
1773 static void
1774 check_one_pubkey_new (int n)
1775 {
1776   gcry_sexp_t skey, pkey;
1777
1778   get_keys_new (&pkey, &skey);
1779   do_check_one_pubkey (n, skey, pkey, NULL, FLAG_SIGN | FLAG_CRYPT);
1780 }
1781
1782 /* Run all tests for the public key functions. */
1783 static void
1784 check_pubkey (void)
1785 {
1786   test_spec_pubkey_t pubkeys[] =
1787     {
1788       {
1789         GCRY_PK_RSA, FLAG_CRYPT | FLAG_SIGN,
1790
1791         { "(private-key\n"
1792           " (rsa\n"
1793           "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
1794           "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
1795           "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
1796           "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
1797           "  (e #010001#)\n"
1798           "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
1799           "      7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
1800           "      C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
1801           "      C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
1802           "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
1803           "      fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424f1#)\n"
1804           "  (q #00f7a7ca5367c661f8e62df34f0d05c10c88e5492348dd7bddc942c9a8f369f9"
1805           "      35a07785d2db805215ed786e4285df1658eed3ce84f469b81b50d358407b4ad361#)\n"
1806           "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
1807           "      ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b#)))\n",
1808
1809           "(public-key\n"
1810           " (rsa\n"
1811           "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
1812           "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
1813           "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
1814           "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
1815           "  (e #010001#)))\n",
1816
1817           "\x32\x10\x0c\x27\x17\x3e\xf6\xe9\xc4\xe9"
1818           "\xa2\x5d\x3d\x69\xf8\x6d\x37\xa4\xf9\x39"}
1819       },
1820       {
1821         GCRY_PK_DSA, FLAG_SIGN,
1822
1823         { "(private-key\n"
1824           " (DSA\n"
1825           "  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
1826           "      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
1827           "      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
1828           "      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D8777B#)\n"
1829           "  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)\n"
1830           "  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
1831           "      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
1832           "      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
1833           "      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15#)\n"
1834           "  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
1835           "      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
1836           "      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
1837           "      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB#)\n"
1838           "  (x #11D54E4ADBD3034160F2CED4B7CD292A4EBF3EC0#)))\n",
1839
1840           "(public-key\n"
1841           " (DSA\n"
1842           "  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
1843           "      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
1844           "      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
1845           "      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D8777B#)\n"
1846           "  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)\n"
1847           "  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
1848           "      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
1849           "      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
1850           "      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15#)\n"
1851           "  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
1852           "      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
1853           "      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
1854           "      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB#)))\n",
1855
1856           "\xc6\x39\x83\x1a\x43\xe5\x05\x5d\xc6\xd8"
1857           "\x4a\xa6\xf9\xeb\x23\xbf\xa9\x12\x2d\x5b" }
1858       },
1859       {
1860         GCRY_PK_ELG, FLAG_SIGN | FLAG_CRYPT,
1861
1862         { "(private-key\n"
1863           " (ELG\n"
1864           "  (p #00B93B93386375F06C2D38560F3B9C6D6D7B7506B20C1773F73F8DE56E6CD65D"
1865           "      F48DFAAA1E93F57A2789B168362A0F787320499F0B2461D3A4268757A7B27517"
1866           "      B7D203654A0CD484DEC6AF60C85FEB84AAC382EAF2047061FE5DAB81A20A0797"
1867           "      6E87359889BAE3B3600ED718BE61D4FC993CC8098A703DD0DC942E965E8F18D2A7#)\n"
1868           "  (g #05#)\n"
1869           "  (y #72DAB3E83C9F7DD9A931FDECDC6522C0D36A6F0A0FEC955C5AC3C09175BBFF2B"
1870           "      E588DB593DC2E420201BEB3AC17536918417C497AC0F8657855380C1FCF11C5B"
1871           "      D20DB4BEE9BDF916648DE6D6E419FA446C513AAB81C30CB7B34D6007637BE675"
1872           "      56CE6473E9F9EE9B9FADD275D001563336F2186F424DEC6199A0F758F6A00FF4#)\n"
1873           "  (x #03C28900087B38DABF4A0AB98ACEA39BB674D6557096C01D72E31C16BDD32214#)))\n",
1874
1875           "(public-key\n"
1876           " (ELG\n"
1877           "  (p #00B93B93386375F06C2D38560F3B9C6D6D7B7506B20C1773F73F8DE56E6CD65D"
1878           "      F48DFAAA1E93F57A2789B168362A0F787320499F0B2461D3A4268757A7B27517"
1879           "      B7D203654A0CD484DEC6AF60C85FEB84AAC382EAF2047061FE5DAB81A20A0797"
1880           "      6E87359889BAE3B3600ED718BE61D4FC993CC8098A703DD0DC942E965E8F18D2A7#)\n"
1881           "  (g #05#)\n"
1882           "  (y #72DAB3E83C9F7DD9A931FDECDC6522C0D36A6F0A0FEC955C5AC3C09175BBFF2B"
1883           "      E588DB593DC2E420201BEB3AC17536918417C497AC0F8657855380C1FCF11C5B"
1884           "      D20DB4BEE9BDF916648DE6D6E419FA446C513AAB81C30CB7B34D6007637BE675"
1885           "      56CE6473E9F9EE9B9FADD275D001563336F2186F424DEC6199A0F758F6A00FF4#)))\n",
1886
1887           "\xa7\x99\x61\xeb\x88\x83\xd2\xf4\x05\xc8"
1888           "\x4f\xba\x06\xf8\x78\x09\xbc\x1e\x20\xe5" }
1889       },
1890     };
1891   int i;
1892   if (verbose)
1893     fprintf (stderr, "Starting public key checks.\n");
1894   for (i = 0; i < sizeof (pubkeys) / sizeof (*pubkeys); i++)
1895     if (pubkeys[i].id)
1896       check_one_pubkey (i, pubkeys[i]);
1897   if (verbose)
1898     fprintf (stderr, "Completed public key checks.\n");
1899
1900   if (verbose)
1901     fprintf (stderr, "Starting additional public key checks.\n");
1902   for (i = 0; i < sizeof (pubkeys) / sizeof (*pubkeys); i++)
1903     if (pubkeys[i].id)
1904       check_one_pubkey_new (i);
1905   if (verbose)
1906     fprintf (stderr, "Completed additional public key checks.\n");
1907
1908 }
1909
1910 int
1911 main (int argc, char **argv)
1912 {
1913   int debug = 0;
1914
1915   if (argc > 1 && !strcmp (argv[1], "--verbose"))
1916     verbose = 1;
1917   else if (argc > 1 && !strcmp (argv[1], "--debug"))
1918     verbose = debug = 1;
1919
1920   if (!gcry_check_version (GCRYPT_VERSION))
1921     die ("version mismatch\n");
1922
1923   gcry_set_progress_handler (progress_handler, NULL);
1924   
1925   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
1926   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
1927   if (debug)
1928     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
1929   check_ciphers ();
1930   check_aes128_cbc_cts_cipher ();
1931   check_cbc_mac_cipher ();
1932   check_ctr_cipher ();
1933   check_cfb_cipher ();
1934   check_ofb_cipher ();
1935   check_digests ();
1936   check_hmac ();
1937   check_pubkey ();
1938
1939   if (verbose)
1940     fprintf (stderr, "\nAll tests completed. Errors: %i\n", error_count);
1941   return error_count ? 1 : 0;
1942 }