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