Add hack to allow using an "ecc" key for "ecdsa" or "ecdh".
[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 #include <assert.h>
29
30 #include "../src/gcrypt.h"
31
32 #ifndef DIM
33 # define DIM(v)              (sizeof(v)/sizeof((v)[0]))
34 #endif
35
36
37 typedef struct test_spec_pubkey_key
38 {
39   const char *secret;
40   const char *public;
41   const char *grip;
42 }
43 test_spec_pubkey_key_t;
44
45 typedef struct test_spec_pubkey
46 {
47   int id;
48   int flags;
49   test_spec_pubkey_key_t key;
50 }
51 test_spec_pubkey_t;
52
53 #define FLAG_CRYPT (1 << 0)
54 #define FLAG_SIGN  (1 << 1)
55 #define FLAG_GRIP  (1 << 2)
56
57 static int verbose;
58 static int error_count;
59 static int in_fips_mode;
60 static int die_on_error;
61
62 static void
63 fail (const char *format, ...)
64 {
65   va_list arg_ptr;
66
67   va_start (arg_ptr, format);
68   vfprintf (stderr, format, arg_ptr);
69   va_end (arg_ptr);
70   error_count++;
71   if (die_on_error)
72     exit (1);
73 }
74
75 static void
76 mismatch (const void *expected, size_t expectedlen,
77           const void *computed, size_t computedlen)
78 {
79   const unsigned char *p;
80
81   fprintf (stderr, "expected:");
82   for (p = expected; expectedlen; p++, expectedlen--)
83     fprintf (stderr, " %02x", *p);
84   fprintf (stderr, "\ncomputed:");
85   for (p = computed; computedlen; p++, computedlen--)
86     fprintf (stderr, " %02x", *p);
87   fprintf (stderr, "\n");
88 }
89
90
91 static void
92 die (const char *format, ...)
93 {
94   va_list arg_ptr;
95
96   va_start (arg_ptr, format);
97   vfprintf (stderr, format, arg_ptr);
98   va_end (arg_ptr);
99   exit (1);
100 }
101
102
103 static void
104 show_sexp (const char *prefix, gcry_sexp_t a)
105 {
106   char *buf;
107   size_t size;
108
109   if (prefix)
110     fputs (prefix, stderr);
111   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
112   buf = gcry_xmalloc (size);
113
114   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
115   fprintf (stderr, "%.*s", (int)size, buf);
116   gcry_free (buf);
117 }
118
119
120 #define MAX_DATA_LEN 100
121
122 void
123 progress_handler (void *cb_data, const char *what, int printchar,
124                   int current, int total)
125 {
126   (void)cb_data;
127   (void)what;
128   (void)current;
129   (void)total;
130
131   if (printchar == '\n')
132     fputs ( "<LF>", stdout);
133   else
134     putchar (printchar);
135   fflush (stdout);
136 }
137
138 static void
139 check_cbc_mac_cipher (void)
140 {
141   struct tv
142   {
143     int algo;
144     char key[MAX_DATA_LEN];
145     unsigned char plaintext[MAX_DATA_LEN];
146     size_t plaintextlen;
147     char mac[MAX_DATA_LEN];
148   }
149   tv[] =
150     {
151       { GCRY_CIPHER_AES,
152         "chicken teriyaki",
153         "This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
154         0, "\x23\x8f\x6d\xc7\x53\x6a\x62\x97\x11\xc4\xa5\x16\x43\xea\xb0\xb6" },
155       { GCRY_CIPHER_3DES,
156         "abcdefghABCDEFGH01234567",
157         "This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
158         0, "\x5c\x11\xf0\x01\x47\xbd\x3d\x3a" },
159       { GCRY_CIPHER_DES,
160         "abcdefgh",
161         "This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
162         0, "\xfa\x4b\xdf\x9d\xfa\xab\x01\x70" }
163     };
164   gcry_cipher_hd_t hd;
165   unsigned char out[MAX_DATA_LEN];
166   int i, blklen, keylen;
167   gcry_error_t err = 0;
168
169   if (verbose)
170     fprintf (stderr, "  Starting CBC MAC checks.\n");
171
172   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
173     {
174       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
175         {
176           if (verbose)
177             fprintf (stderr, "  algorithm %d not available in fips mode\n",
178                      tv[i].algo);
179           continue;
180         }
181
182       err = gcry_cipher_open (&hd,
183                               tv[i].algo,
184                               GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_MAC);
185       if (!hd)
186         {
187           fail ("cbc-mac algo %d, gcry_cipher_open failed: %s\n",
188                 tv[i].algo, gpg_strerror (err));
189           return;
190         }
191
192       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
193       if (!blklen)
194         {
195           fail ("cbc-mac algo %d, gcry_cipher_get_algo_blklen failed\n",
196                  tv[i].algo);
197           gcry_cipher_close (hd);
198           return;
199         }
200
201       keylen = gcry_cipher_get_algo_keylen (tv[i].algo);
202       if (!keylen)
203         {
204           fail ("cbc-mac algo %d, gcry_cipher_get_algo_keylen failed\n",
205                 tv[i].algo);
206           return;
207         }
208
209       err = gcry_cipher_setkey (hd, tv[i].key, keylen);
210       if (err)
211         {
212           fail ("cbc-mac algo %d, gcry_cipher_setkey failed: %s\n",
213                 tv[i].algo, gpg_strerror (err));
214           gcry_cipher_close (hd);
215           return;
216         }
217
218       err = gcry_cipher_setiv (hd, NULL, 0);
219       if (err)
220         {
221           fail ("cbc-mac algo %d, gcry_cipher_setiv failed: %s\n",
222                 tv[i].algo, gpg_strerror (err));
223           gcry_cipher_close (hd);
224           return;
225         }
226
227       if (verbose)
228         fprintf (stderr, "    checking CBC MAC for %s [%i]\n",
229                  gcry_cipher_algo_name (tv[i].algo),
230                  tv[i].algo);
231       err = gcry_cipher_encrypt (hd,
232                                  out, blklen,
233                                  tv[i].plaintext,
234                                  tv[i].plaintextlen ?
235                                  tv[i].plaintextlen :
236                                  strlen ((char*)tv[i].plaintext));
237       if (err)
238         {
239           fail ("cbc-mac algo %d, gcry_cipher_encrypt failed: %s\n",
240                 tv[i].algo, gpg_strerror (err));
241           gcry_cipher_close (hd);
242           return;
243         }
244
245 #if 0
246       {
247         int j;
248         for (j = 0; j < gcry_cipher_get_algo_blklen (tv[i].algo); j++)
249           printf ("\\x%02x", out[j] & 0xFF);
250         printf ("\n");
251       }
252 #endif
253
254       if (memcmp (tv[i].mac, out, blklen))
255         fail ("cbc-mac algo %d, encrypt mismatch entry %d\n", tv[i].algo, i);
256
257       gcry_cipher_close (hd);
258     }
259   if (verbose)
260     fprintf (stderr, "  Completed CBC MAC checks.\n");
261 }
262
263 static void
264 check_aes128_cbc_cts_cipher (void)
265 {
266   char key[128 / 8] = "chicken teriyaki";
267   unsigned char plaintext[] =
268     "I would like the General Gau's Chicken, please, and wonton soup.";
269   struct tv
270   {
271     unsigned char out[MAX_DATA_LEN];
272     int inlen;
273   } tv[] =
274     {
275       { "\xc6\x35\x35\x68\xf2\xbf\x8c\xb4\xd8\xa5\x80\x36\x2d\xa7\xff\x7f"
276         "\x97",
277         17 },
278       { "\xfc\x00\x78\x3e\x0e\xfd\xb2\xc1\xd4\x45\xd4\xc8\xef\xf7\xed\x22"
279         "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5",
280         31 },
281       { "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8"
282         "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84",
283         32 },
284       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
285         "\xb3\xff\xfd\x94\x0c\x16\xa1\x8c\x1b\x55\x49\xd2\xf8\x38\x02\x9e"
286         "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5",
287         47 },
288       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
289         "\x9d\xad\x8b\xbb\x96\xc4\xcd\xc0\x3b\xc1\x03\xe1\xa1\x94\xbb\xd8"
290         "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8",
291         48 },
292       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
293         "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8"
294         "\x48\x07\xef\xe8\x36\xee\x89\xa5\x26\x73\x0d\xbc\x2f\x7b\xc8\x40"
295         "\x9d\xad\x8b\xbb\x96\xc4\xcd\xc0\x3b\xc1\x03\xe1\xa1\x94\xbb\xd8",
296         64 },
297     };
298   gcry_cipher_hd_t hd;
299   unsigned char out[MAX_DATA_LEN];
300   int i;
301   gcry_error_t err = 0;
302
303   if (verbose)
304     fprintf (stderr, "  Starting AES128 CBC CTS checks.\n");
305   err = gcry_cipher_open (&hd,
306                           GCRY_CIPHER_AES,
307                           GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_CTS);
308   if (err)
309     {
310       fail ("aes-cbc-cts, gcry_cipher_open failed: %s\n", gpg_strerror (err));
311       return;
312     }
313
314   err = gcry_cipher_setkey (hd, key, 128 / 8);
315   if (err)
316     {
317       fail ("aes-cbc-cts, gcry_cipher_setkey failed: %s\n",
318             gpg_strerror (err));
319       gcry_cipher_close (hd);
320       return;
321     }
322
323   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
324     {
325       err = gcry_cipher_setiv (hd, NULL, 0);
326       if (err)
327         {
328           fail ("aes-cbc-cts, gcry_cipher_setiv failed: %s\n",
329                 gpg_strerror (err));
330           gcry_cipher_close (hd);
331           return;
332         }
333
334       if (verbose)
335         fprintf (stderr, "    checking encryption for length %i\n", tv[i].inlen);
336       err = gcry_cipher_encrypt (hd, out, MAX_DATA_LEN,
337                                  plaintext, tv[i].inlen);
338       if (err)
339         {
340           fail ("aes-cbc-cts, gcry_cipher_encrypt failed: %s\n",
341                 gpg_strerror (err));
342           gcry_cipher_close (hd);
343           return;
344         }
345
346       if (memcmp (tv[i].out, out, tv[i].inlen))
347         fail ("aes-cbc-cts, encrypt mismatch entry %d\n", i);
348
349       err = gcry_cipher_setiv (hd, NULL, 0);
350       if (err)
351         {
352           fail ("aes-cbc-cts, gcry_cipher_setiv failed: %s\n",
353                 gpg_strerror (err));
354           gcry_cipher_close (hd);
355           return;
356         }
357       if (verbose)
358         fprintf (stderr, "    checking decryption for length %i\n", tv[i].inlen);
359       err = gcry_cipher_decrypt (hd, out, tv[i].inlen, NULL, 0);
360       if (err)
361         {
362           fail ("aes-cbc-cts, gcry_cipher_decrypt failed: %s\n",
363                 gpg_strerror (err));
364           gcry_cipher_close (hd);
365           return;
366         }
367
368       if (memcmp (plaintext, out, tv[i].inlen))
369         fail ("aes-cbc-cts, decrypt mismatch entry %d\n", i);
370     }
371
372   gcry_cipher_close (hd);
373   if (verbose)
374     fprintf (stderr, "  Completed AES128 CBC CTS checks.\n");
375 }
376
377 static void
378 check_ctr_cipher (void)
379 {
380   struct tv
381   {
382     int algo;
383     char key[MAX_DATA_LEN];
384     char ctr[MAX_DATA_LEN];
385     struct data
386     {
387       unsigned char plaintext[MAX_DATA_LEN];
388       int inlen;
389       char out[MAX_DATA_LEN];
390     } data[8];
391   } tv[] =
392     {
393       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
394       { GCRY_CIPHER_AES,
395         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
396         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
397         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
398             16,
399             "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
400           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
401             16,
402             "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd\xff" },
403           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
404             16,
405             "\x5a\xe4\xdf\x3e\xdb\xd5\xd3\x5e\x5b\x4f\x09\x02\x0d\xb0\x3e\xab" },
406           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
407             16,
408             "\x1e\x03\x1d\xda\x2f\xbe\x03\xd1\x79\x21\x70\xa0\xf3\x00\x9c\xee" },
409
410           { "", 0, "" }
411         }
412       },
413       { GCRY_CIPHER_AES192,
414         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
415         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
416         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
417         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
418             16,
419             "\x1a\xbc\x93\x24\x17\x52\x1c\xa2\x4f\x2b\x04\x59\xfe\x7e\x6e\x0b" },
420           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
421             16,
422             "\x09\x03\x39\xec\x0a\xa6\xfa\xef\xd5\xcc\xc2\xc6\xf4\xce\x8e\x94" },
423           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
424             16,
425             "\x1e\x36\xb2\x6b\xd1\xeb\xc6\x70\xd1\xbd\x1d\x66\x56\x20\xab\xf7" },
426           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
427             16,
428             "\x4f\x78\xa7\xf6\xd2\x98\x09\x58\x5a\x97\xda\xec\x58\xc6\xb0\x50" },
429           { "", 0, "" }
430         }
431       },
432       { GCRY_CIPHER_AES256,
433         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
434         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
435         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
436         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
437             16,
438             "\x60\x1e\xc3\x13\x77\x57\x89\xa5\xb7\xa7\xf5\x04\xbb\xf3\xd2\x28" },
439           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
440             16,
441             "\xf4\x43\xe3\xca\x4d\x62\xb5\x9a\xca\x84\xe9\x90\xca\xca\xf5\xc5" },
442           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
443             16,
444             "\x2b\x09\x30\xda\xa2\x3d\xe9\x4c\xe8\x70\x17\xba\x2d\x84\x98\x8d" },
445           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
446             16,
447             "\xdf\xc9\xc5\x8d\xb6\x7a\xad\xa6\x13\xc2\xdd\x08\x45\x79\x41\xa6" },
448           { "", 0, "" }
449         }
450       },
451       /* Some truncation tests.  With a truncated second block and
452          also with a single truncated block.  */
453       { GCRY_CIPHER_AES,
454         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
455         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
456         {{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
457           16,
458           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
459          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e",
460           15,
461           "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd" },
462          {"", 0, "" }
463         }
464       },
465       { GCRY_CIPHER_AES,
466         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
467         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
468         {{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
469           16,
470           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
471          {"\xae",
472           1,
473           "\x98" },
474          {"", 0, "" }
475         }
476       },
477       { GCRY_CIPHER_AES,
478         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
479         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
480         {{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17",
481           15,
482           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6" },
483          {"", 0, "" }
484         }
485       },
486       { GCRY_CIPHER_AES,
487         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
488         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
489         {{"\x6b",
490           1,
491           "\x87" },
492          {"", 0, "" }
493         }
494       },
495       /* Tests to see whether it works correctly as a stream cipher.  */
496       { GCRY_CIPHER_AES,
497         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
498         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
499         {{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
500           16,
501           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
502          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e",
503           15,
504           "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd" },
505          {"\x51\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
506           17,
507           "\xff\x5a\xe4\xdf\x3e\xdb\xd5\xd3\x5e\x5b\x4f\x09\x02\x0d\xb0\x3e\xab" },
508          {"\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
509           16,
510           "\x1e\x03\x1d\xda\x2f\xbe\x03\xd1\x79\x21\x70\xa0\xf3\x00\x9c\xee" },
511
512           { "", 0, "" }
513         }
514       },
515       { GCRY_CIPHER_AES,
516         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
517         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
518         {{"\x6b",
519           1,
520           "\x87" },
521          {"\xc1\xbe",
522           2,
523           "\x4d\x61" },
524          {"\xe2\x2e\x40",
525           3,
526           "\x91\xb6\x20" },
527          {"\x9f",
528           1,
529           "\xe3" },
530          {"\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
531           9,
532           "\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
533          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e",
534           15,
535           "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd" },
536          {"\x51\x30\xc8\x1c\x46\xa3\x5c\xe4\x11",
537           9,
538           "\xff\x5a\xe4\xdf\x3e\xdb\xd5\xd3\x5e" },
539
540           { "", 0, "" }
541         }
542       },
543 #if USE_CAST5
544       /* A selfmade test vector using an 64 bit block cipher.  */
545       { GCRY_CIPHER_CAST5,
546         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
547         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8",
548         {{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
549           16,
550           "\xe8\xa7\xac\x68\xca\xca\xa0\x20\x10\xcb\x1b\xcc\x79\x2c\xc4\x48" },
551          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c",
552           8,
553           "\x16\xe8\x72\x77\xb0\x98\x29\x68" },
554          {"\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
555           8,
556           "\x9a\xb3\xa8\x03\x3b\xb4\x14\xba" },
557          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\xa1\x00",
558           10,
559           "\x31\x5e\xd3\xfb\x1b\x8d\xd1\xf9\xb0\x83" },
560          { "", 0, "" }
561         }
562       },
563 #endif /*USE_CAST5*/
564       { 0,
565         "",
566         "",
567         {
568          {"", 0, "" }
569         }
570       }
571     };
572   gcry_cipher_hd_t hde, hdd;
573   unsigned char out[MAX_DATA_LEN];
574   int i, j, keylen, blklen;
575   gcry_error_t err = 0;
576
577   if (verbose)
578     fprintf (stderr, "  Starting CTR cipher checks.\n");
579   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
580     {
581       if (!tv[i].algo)
582         continue;
583
584       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_CTR, 0);
585       if (!err)
586         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_CTR, 0);
587       if (err)
588         {
589           fail ("aes-ctr, gcry_cipher_open failed: %s\n", gpg_strerror (err));
590           return;
591         }
592
593       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
594       if (!keylen)
595         {
596           fail ("aes-ctr, gcry_cipher_get_algo_keylen failed\n");
597           return;
598         }
599
600       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
601       if (!err)
602         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
603       if (err)
604         {
605           fail ("aes-ctr, gcry_cipher_setkey failed: %s\n",
606                 gpg_strerror (err));
607           gcry_cipher_close (hde);
608           gcry_cipher_close (hdd);
609           return;
610         }
611
612       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
613       if (!blklen)
614         {
615           fail ("aes-ctr, gcry_cipher_get_algo_blklen failed\n");
616           return;
617         }
618
619       err = gcry_cipher_setctr (hde, tv[i].ctr, blklen);
620       if (!err)
621         err = gcry_cipher_setctr (hdd, tv[i].ctr, blklen);
622       if (err)
623         {
624           fail ("aes-ctr, gcry_cipher_setctr failed: %s\n",
625                 gpg_strerror (err));
626           gcry_cipher_close (hde);
627           gcry_cipher_close (hdd);
628           return;
629         }
630
631       if (verbose)
632         fprintf (stderr, "    checking CTR mode for %s [%i]\n",
633                  gcry_cipher_algo_name (tv[i].algo),
634                  tv[i].algo);
635       for (j = 0; tv[i].data[j].inlen; j++)
636         {
637           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
638                                      tv[i].data[j].plaintext,
639                                      tv[i].data[j].inlen == -1 ?
640                                      strlen ((char*)tv[i].data[j].plaintext) :
641                                      tv[i].data[j].inlen);
642           if (err)
643             {
644               fail ("aes-ctr, gcry_cipher_encrypt (%d, %d) failed: %s\n",
645                     i, j, gpg_strerror (err));
646               gcry_cipher_close (hde);
647               gcry_cipher_close (hdd);
648               return;
649             }
650
651           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
652             {
653               fail ("aes-ctr, encrypt mismatch entry %d:%d\n", i, j);
654               mismatch (tv[i].data[j].out, tv[i].data[j].inlen,
655                         out, tv[i].data[j].inlen);
656             }
657
658           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
659           if (err)
660             {
661               fail ("aes-ctr, gcry_cipher_decrypt (%d, %d) failed: %s\n",
662                     i, j, gpg_strerror (err));
663               gcry_cipher_close (hde);
664               gcry_cipher_close (hdd);
665               return;
666             }
667
668           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
669             {
670               fail ("aes-ctr, decrypt mismatch entry %d:%d\n", i, j);
671               mismatch (tv[i].data[j].plaintext, tv[i].data[j].inlen,
672                         out, tv[i].data[j].inlen);
673             }
674
675         }
676
677       /* Now check that we get valid return codes back for good and
678          bad inputs.  */
679       err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
680                                  "1234567890123456", 16);
681       if (err)
682         fail ("aes-ctr, encryption failed for valid input");
683
684       err = gcry_cipher_encrypt (hde, out, 15,
685                                  "1234567890123456", 16);
686       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
687         fail ("aes-ctr, too short output buffer returned wrong error: %s\n",
688               gpg_strerror (err));
689
690       err = gcry_cipher_encrypt (hde, out, 0,
691                                  "1234567890123456", 16);
692       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
693         fail ("aes-ctr, 0 length output buffer returned wrong error: %s\n",
694               gpg_strerror (err));
695
696       err = gcry_cipher_encrypt (hde, out, 16,
697                                  "1234567890123456", 16);
698       if (err)
699         fail ("aes-ctr, correct length output buffer returned error: %s\n",
700               gpg_strerror (err));
701
702       /* Again, now for decryption.  */
703       err = gcry_cipher_decrypt (hde, out, MAX_DATA_LEN,
704                                  "1234567890123456", 16);
705       if (err)
706         fail ("aes-ctr, decryption failed for valid input");
707
708       err = gcry_cipher_decrypt (hde, out, 15,
709                                  "1234567890123456", 16);
710       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
711         fail ("aes-ctr, too short output buffer returned wrong error: %s\n",
712               gpg_strerror (err));
713
714       err = gcry_cipher_decrypt (hde, out, 0,
715                                  "1234567890123456", 16);
716       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
717         fail ("aes-ctr, 0 length output buffer returned wrong error: %s\n",
718               gpg_strerror (err));
719
720       err = gcry_cipher_decrypt (hde, out, 16,
721                                  "1234567890123456", 16);
722       if (err)
723         fail ("aes-ctr, correct length output buffer returned error: %s\n",
724               gpg_strerror (err));
725
726       gcry_cipher_close (hde);
727       gcry_cipher_close (hdd);
728     }
729   if (verbose)
730     fprintf (stderr, "  Completed CTR cipher checks.\n");
731 }
732
733 static void
734 check_cfb_cipher (void)
735 {
736   struct tv
737   {
738     int algo;
739     char key[MAX_DATA_LEN];
740     char iv[MAX_DATA_LEN];
741     struct data
742     {
743       unsigned char plaintext[MAX_DATA_LEN];
744       int inlen;
745       char out[MAX_DATA_LEN];
746     }
747     data[MAX_DATA_LEN];
748   } tv[] =
749     {
750       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
751       { GCRY_CIPHER_AES,
752         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
753         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
754         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
755             16,
756             "\x3b\x3f\xd9\x2e\xb7\x2d\xad\x20\x33\x34\x49\xf8\xe8\x3c\xfb\x4a" },
757           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
758             16,
759             "\xc8\xa6\x45\x37\xa0\xb3\xa9\x3f\xcd\xe3\xcd\xad\x9f\x1c\xe5\x8b"},
760           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
761             16,
762             "\x26\x75\x1f\x67\xa3\xcb\xb1\x40\xb1\x80\x8c\xf1\x87\xa4\xf4\xdf" },
763           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
764             16,
765             "\xc0\x4b\x05\x35\x7c\x5d\x1c\x0e\xea\xc4\xc6\x6f\x9f\xf7\xf2\xe6" },
766         }
767       },
768       { GCRY_CIPHER_AES192,
769         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
770         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
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             "\xcd\xc8\x0d\x6f\xdd\xf1\x8c\xab\x34\xc2\x59\x09\xc9\x9a\x41\x74" },
775           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
776             16,
777             "\x67\xce\x7f\x7f\x81\x17\x36\x21\x96\x1a\x2b\x70\x17\x1d\x3d\x7a" },
778           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
779             16,
780             "\x2e\x1e\x8a\x1d\xd5\x9b\x88\xb1\xc8\xe6\x0f\xed\x1e\xfa\xc4\xc9" },
781           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
782             16,
783             "\xc0\x5f\x9f\x9c\xa9\x83\x4f\xa0\x42\xae\x8f\xba\x58\x4b\x09\xff" },
784         }
785       },
786       { GCRY_CIPHER_AES256,
787         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
788         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
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             "\xdc\x7e\x84\xbf\xda\x79\x16\x4b\x7e\xcd\x84\x86\x98\x5d\x38\x60" },
793           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
794             16,
795             "\x39\xff\xed\x14\x3b\x28\xb1\xc8\x32\x11\x3c\x63\x31\xe5\x40\x7b" },
796           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
797             16,
798             "\xdf\x10\x13\x24\x15\xe5\x4b\x92\xa1\x3e\xd0\xa8\x26\x7a\xe2\xf9" },
799           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
800             16,
801             "\x75\xa3\x85\x74\x1a\xb9\xce\xf8\x20\x31\x62\x3d\x55\xb1\xe4\x71" }
802         }
803       }
804     };
805   gcry_cipher_hd_t hde, hdd;
806   unsigned char out[MAX_DATA_LEN];
807   int i, j, keylen, blklen;
808   gcry_error_t err = 0;
809
810   if (verbose)
811     fprintf (stderr, "  Starting CFB checks.\n");
812
813   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
814     {
815       if (verbose)
816         fprintf (stderr, "    checking CFB mode for %s [%i]\n",
817                  gcry_cipher_algo_name (tv[i].algo),
818                  tv[i].algo);
819       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_CFB, 0);
820       if (!err)
821         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_CFB, 0);
822       if (err)
823         {
824           fail ("aes-cfb, gcry_cipher_open failed: %s\n", gpg_strerror (err));
825           return;
826         }
827
828       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
829       if (!keylen)
830         {
831           fail ("aes-cfb, gcry_cipher_get_algo_keylen failed\n");
832           return;
833         }
834
835       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
836       if (!err)
837         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
838       if (err)
839         {
840           fail ("aes-cfb, gcry_cipher_setkey failed: %s\n",
841                 gpg_strerror (err));
842           gcry_cipher_close (hde);
843           gcry_cipher_close (hdd);
844           return;
845         }
846
847       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
848       if (!blklen)
849         {
850           fail ("aes-cfb, gcry_cipher_get_algo_blklen failed\n");
851           return;
852         }
853
854       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
855       if (!err)
856         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
857       if (err)
858         {
859           fail ("aes-cfb, gcry_cipher_setiv failed: %s\n",
860                 gpg_strerror (err));
861           gcry_cipher_close (hde);
862           gcry_cipher_close (hdd);
863           return;
864         }
865
866       for (j = 0; tv[i].data[j].inlen; j++)
867         {
868           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
869                                      tv[i].data[j].plaintext,
870                                      tv[i].data[j].inlen);
871           if (err)
872             {
873               fail ("aes-cfb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
874                     i, j, gpg_strerror (err));
875               gcry_cipher_close (hde);
876               gcry_cipher_close (hdd);
877               return;
878             }
879
880           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen)) {
881             fail ("aes-cfb, encrypt mismatch entry %d:%d\n", i, j);
882           }
883           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
884           if (err)
885             {
886               fail ("aes-cfb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
887                     i, j, gpg_strerror (err));
888               gcry_cipher_close (hde);
889               gcry_cipher_close (hdd);
890               return;
891             }
892
893           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
894             fail ("aes-cfb, decrypt mismatch entry %d:%d\n", i, j);
895         }
896
897       gcry_cipher_close (hde);
898       gcry_cipher_close (hdd);
899     }
900   if (verbose)
901     fprintf (stderr, "  Completed CFB checks.\n");
902 }
903
904 static void
905 check_ofb_cipher (void)
906 {
907   struct tv
908   {
909     int algo;
910     char key[MAX_DATA_LEN];
911     char iv[MAX_DATA_LEN];
912     struct data
913     {
914       unsigned char plaintext[MAX_DATA_LEN];
915       int inlen;
916       char out[MAX_DATA_LEN];
917     }
918     data[MAX_DATA_LEN];
919   } tv[] =
920     {
921       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
922       { GCRY_CIPHER_AES,
923         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
924         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
925         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
926             16,
927             "\x3b\x3f\xd9\x2e\xb7\x2d\xad\x20\x33\x34\x49\xf8\xe8\x3c\xfb\x4a" },
928           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
929             16,
930             "\x77\x89\x50\x8d\x16\x91\x8f\x03\xf5\x3c\x52\xda\xc5\x4e\xd8\x25"},
931           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
932             16,
933             "\x97\x40\x05\x1e\x9c\x5f\xec\xf6\x43\x44\xf7\xa8\x22\x60\xed\xcc" },
934           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
935             16,
936             "\x30\x4c\x65\x28\xf6\x59\xc7\x78\x66\xa5\x10\xd9\xc1\xd6\xae\x5e" },
937         }
938       },
939       { GCRY_CIPHER_AES192,
940         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
941         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
942         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
943         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
944             16,
945             "\xcd\xc8\x0d\x6f\xdd\xf1\x8c\xab\x34\xc2\x59\x09\xc9\x9a\x41\x74" },
946           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
947             16,
948             "\xfc\xc2\x8b\x8d\x4c\x63\x83\x7c\x09\xe8\x17\x00\xc1\x10\x04\x01" },
949           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
950             16,
951             "\x8d\x9a\x9a\xea\xc0\xf6\x59\x6f\x55\x9c\x6d\x4d\xaf\x59\xa5\xf2" },
952           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
953             16,
954             "\x6d\x9f\x20\x08\x57\xca\x6c\x3e\x9c\xac\x52\x4b\xd9\xac\xc9\x2a" },
955         }
956       },
957       { GCRY_CIPHER_AES256,
958         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
959         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
960         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
961         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
962             16,
963             "\xdc\x7e\x84\xbf\xda\x79\x16\x4b\x7e\xcd\x84\x86\x98\x5d\x38\x60" },
964           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
965             16,
966             "\x4f\xeb\xdc\x67\x40\xd2\x0b\x3a\xc8\x8f\x6a\xd8\x2a\x4f\xb0\x8d" },
967           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
968             16,
969             "\x71\xab\x47\xa0\x86\xe8\x6e\xed\xf3\x9d\x1c\x5b\xba\x97\xc4\x08" },
970           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
971             16,
972             "\x01\x26\x14\x1d\x67\xf3\x7b\xe8\x53\x8f\x5a\x8b\xe7\x40\xe4\x84" }
973         }
974       }
975     };
976   gcry_cipher_hd_t hde, hdd;
977   unsigned char out[MAX_DATA_LEN];
978   int i, j, keylen, blklen;
979   gcry_error_t err = 0;
980
981   if (verbose)
982     fprintf (stderr, "  Starting OFB checks.\n");
983
984   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
985     {
986       if (verbose)
987         fprintf (stderr, "    checking OFB mode for %s [%i]\n",
988                  gcry_cipher_algo_name (tv[i].algo),
989                  tv[i].algo);
990       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_OFB, 0);
991       if (!err)
992         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_OFB, 0);
993       if (err)
994         {
995           fail ("aes-ofb, gcry_cipher_open failed: %s\n", gpg_strerror (err));
996           return;
997         }
998
999       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
1000       if (!keylen)
1001         {
1002           fail ("aes-ofb, gcry_cipher_get_algo_keylen failed\n");
1003           return;
1004         }
1005
1006       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
1007       if (!err)
1008         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
1009       if (err)
1010         {
1011           fail ("aes-ofb, gcry_cipher_setkey failed: %s\n",
1012                 gpg_strerror (err));
1013           gcry_cipher_close (hde);
1014           gcry_cipher_close (hdd);
1015           return;
1016         }
1017
1018       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
1019       if (!blklen)
1020         {
1021           fail ("aes-ofb, gcry_cipher_get_algo_blklen failed\n");
1022           return;
1023         }
1024
1025       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
1026       if (!err)
1027         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
1028       if (err)
1029         {
1030           fail ("aes-ofb, gcry_cipher_setiv failed: %s\n",
1031                 gpg_strerror (err));
1032           gcry_cipher_close (hde);
1033           gcry_cipher_close (hdd);
1034           return;
1035         }
1036
1037       for (j = 0; tv[i].data[j].inlen; j++)
1038         {
1039           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
1040                                      tv[i].data[j].plaintext,
1041                                      tv[i].data[j].inlen);
1042           if (err)
1043             {
1044               fail ("aes-ofb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
1045                     i, j, gpg_strerror (err));
1046               gcry_cipher_close (hde);
1047               gcry_cipher_close (hdd);
1048               return;
1049             }
1050
1051           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
1052             fail ("aes-ofb, encrypt mismatch entry %d:%d\n", i, j);
1053
1054           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
1055           if (err)
1056             {
1057               fail ("aes-ofb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
1058                     i, j, gpg_strerror (err));
1059               gcry_cipher_close (hde);
1060               gcry_cipher_close (hdd);
1061               return;
1062             }
1063
1064           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
1065             fail ("aes-ofb, decrypt mismatch entry %d:%d\n", i, j);
1066         }
1067
1068       err = gcry_cipher_reset(hde);
1069       if (!err)
1070         err = gcry_cipher_reset(hdd);
1071       if (err)
1072         {
1073           fail ("aes-ofb, gcry_cipher_reset (%d, %d) failed: %s\n",
1074                 i, j, gpg_strerror (err));
1075           gcry_cipher_close (hde);
1076           gcry_cipher_close (hdd);
1077           return;
1078         }
1079
1080       /* gcry_cipher_reset clears the IV */
1081       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
1082       if (!err)
1083         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
1084       if (err)
1085         {
1086           fail ("aes-ofb, gcry_cipher_setiv failed: %s\n",
1087                 gpg_strerror (err));
1088           gcry_cipher_close (hde);
1089           gcry_cipher_close (hdd);
1090           return;
1091         }
1092
1093       /* this time we encrypt and decrypt one byte at a time */
1094       for (j = 0; tv[i].data[j].inlen; j++)
1095         {
1096           int byteNum;
1097           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
1098             {
1099               err = gcry_cipher_encrypt (hde, out+byteNum, 1,
1100                                          (tv[i].data[j].plaintext) + byteNum,
1101                                          1);
1102               if (err)
1103                 {
1104                   fail ("aes-ofb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
1105                         i, j, gpg_strerror (err));
1106                   gcry_cipher_close (hde);
1107                   gcry_cipher_close (hdd);
1108                   return;
1109                 }
1110             }
1111
1112           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
1113             fail ("aes-ofb, encrypt mismatch entry %d:%d\n", i, j);
1114
1115           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
1116             {
1117               err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
1118               if (err)
1119                 {
1120                   fail ("aes-ofb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
1121                         i, j, gpg_strerror (err));
1122                   gcry_cipher_close (hde);
1123                   gcry_cipher_close (hdd);
1124                   return;
1125                 }
1126             }
1127
1128           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
1129             fail ("aes-ofb, decrypt mismatch entry %d:%d\n", i, j);
1130         }
1131
1132       gcry_cipher_close (hde);
1133       gcry_cipher_close (hdd);
1134     }
1135   if (verbose)
1136     fprintf (stderr, "  Completed OFB checks.\n");
1137 }
1138
1139
1140 /* Check that our bulk encryption fucntions work properly.  */
1141 static void
1142 check_bulk_cipher_modes (void)
1143 {
1144   struct
1145   {
1146     int algo;
1147     int mode;
1148     const char *key;
1149     int  keylen;
1150     const char *iv;
1151     int ivlen;
1152     char t1_hash[20];
1153   } tv[] = {
1154     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CFB,
1155       "abcdefghijklmnop", 16,
1156       "1234567890123456", 16,
1157 /*[0]*/
1158       { 0x53, 0xda, 0x27, 0x3c, 0x78, 0x3d, 0x54, 0x66, 0x19, 0x63,
1159         0xd7, 0xe6, 0x20, 0x10, 0xcd, 0xc0, 0x5a, 0x0b, 0x06, 0xcc }
1160     },
1161     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CFB,
1162       "abcdefghijklmnopABCDEFG", 24,
1163       "1234567890123456", 16,
1164 /*[1]*/
1165       { 0xc7, 0xb1, 0xd0, 0x09, 0x95, 0x04, 0x34, 0x61, 0x2b, 0xd9,
1166         0xcb, 0xb3, 0xc7, 0xcb, 0xef, 0xea, 0x16, 0x19, 0x9b, 0x3e }
1167     },
1168     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB,
1169       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1170       "1234567890123456", 16,
1171 /*[2]*/
1172       { 0x31, 0xe1, 0x1f, 0x63, 0x65, 0x47, 0x8c, 0x3f, 0x53, 0xdb,
1173         0xd9, 0x4d, 0x91, 0x1d, 0x02, 0x9c, 0x05, 0x25, 0x58, 0x29 }
1174     },
1175     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CBC,
1176       "abcdefghijklmnop", 16,
1177       "1234567890123456", 16,
1178 /*[3]*/
1179       { 0xdc, 0x0c, 0xc2, 0xd9, 0x6b, 0x47, 0xf9, 0xeb, 0x06, 0xb4,
1180         0x2f, 0x6e, 0xec, 0x72, 0xbf, 0x55, 0x26, 0x7f, 0xa9, 0x97 }
1181     },
1182     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC,
1183       "abcdefghijklmnopABCDEFG", 24,
1184       "1234567890123456", 16,
1185 /*[4]*/
1186       { 0x2b, 0x90, 0x9b, 0xe6, 0x40, 0xab, 0x6e, 0xc2, 0xc5, 0xb1,
1187         0x87, 0xf5, 0x43, 0x84, 0x7b, 0x04, 0x06, 0x47, 0xd1, 0x8f }
1188     },
1189     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC,
1190       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1191       "1234567890123456", 16,
1192 /*[5]*/
1193       { 0xaa, 0xa8, 0xdf, 0x03, 0xb0, 0xba, 0xc4, 0xe3, 0xc1, 0x02,
1194         0x38, 0x31, 0x8d, 0x86, 0xcb, 0x49, 0x6d, 0xad, 0xae, 0x01 }
1195     },
1196     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_OFB,
1197       "abcdefghijklmnop", 16,
1198       "1234567890123456", 16,
1199 /*[6]*/
1200       { 0x65, 0xfe, 0xde, 0x48, 0xd0, 0xa1, 0xa6, 0xf9, 0x24, 0x6b,
1201         0x52, 0x5f, 0x21, 0x8a, 0x6f, 0xc7, 0x70, 0x3b, 0xd8, 0x4a }
1202     },
1203     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_OFB,
1204       "abcdefghijklmnopABCDEFG", 24,
1205       "1234567890123456", 16,
1206 /*[7]*/
1207       { 0x59, 0x5b, 0x02, 0xa2, 0x88, 0xc0, 0xbe, 0x94, 0x43, 0xaa,
1208         0x39, 0xf6, 0xbd, 0xcc, 0x83, 0x99, 0xee, 0x00, 0xa1, 0x91 }
1209     },
1210     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB,
1211       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1212       "1234567890123456", 16,
1213 /*[8]*/
1214       { 0x38, 0x8c, 0xe1, 0xe2, 0xbe, 0x67, 0x60, 0xe8, 0xeb, 0xce,
1215         0xd0, 0xc6, 0xaa, 0xd6, 0xf6, 0x26, 0x15, 0x56, 0xd0, 0x2b }
1216     },
1217     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CTR,
1218       "abcdefghijklmnop", 16,
1219       "1234567890123456", 16,
1220 /*[9]*/
1221       { 0x9a, 0x48, 0x94, 0xd6, 0x50, 0x46, 0x81, 0xdb, 0x68, 0x34,
1222         0x3b, 0xc5, 0x9e, 0x66, 0x94, 0x81, 0x98, 0xa0, 0xf9, 0xff }
1223     },
1224     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CTR,
1225       "abcdefghijklmnopABCDEFG", 24,
1226       "1234567890123456", 16,
1227 /*[10]*/
1228       { 0x2c, 0x2c, 0xd3, 0x75, 0x81, 0x2a, 0x59, 0x07, 0xeb, 0x08,
1229         0xce, 0x28, 0x4c, 0x0c, 0x6a, 0xa8, 0x8f, 0xa3, 0x98, 0x7e }
1230     },
1231     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CTR,
1232       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1233       "1234567890123456", 16,
1234 /*[11]*/
1235       { 0x64, 0xce, 0x73, 0x03, 0xc7, 0x89, 0x99, 0x1f, 0xf1, 0xce,
1236         0xfe, 0xfb, 0xb9, 0x42, 0x30, 0xdf, 0xbb, 0x68, 0x6f, 0xd3 }
1237     },
1238     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB,
1239       "abcdefghijklmnop", 16,
1240       "1234567890123456", 16,
1241 /*[12]*/
1242       { 0x51, 0xae, 0xf5, 0xac, 0x22, 0xa0, 0xba, 0x11, 0xc5, 0xaa,
1243         0xb4, 0x70, 0x99, 0xce, 0x18, 0x08, 0x12, 0x9b, 0xb1, 0xc5 }
1244     },
1245     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_ECB,
1246       "abcdefghijklmnopABCDEFG", 24,
1247       "1234567890123456", 16,
1248 /*[13]*/
1249       { 0x57, 0x91, 0xea, 0x48, 0xd8, 0xbf, 0x9e, 0xc1, 0xae, 0x33,
1250         0xb3, 0xfd, 0xf7, 0x7a, 0xeb, 0x30, 0xb1, 0x62, 0x0d, 0x82 }
1251     },
1252     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_ECB,
1253       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1254       "1234567890123456", 16,
1255 /*[14]*/
1256       { 0x2d, 0x71, 0x54, 0xb9, 0xc5, 0x28, 0x76, 0xff, 0x76, 0xb5,
1257         0x99, 0x37, 0x99, 0x9d, 0xf7, 0x10, 0x6d, 0x86, 0x4f, 0x3f }
1258     }
1259   };
1260   gcry_cipher_hd_t hde = NULL;
1261   gcry_cipher_hd_t hdd = NULL;
1262   unsigned char *buffer_base, *outbuf_base; /* Allocated buffers.  */
1263   unsigned char *buffer, *outbuf;           /* Aligned buffers.  */
1264   size_t buflen;
1265   unsigned char hash[20];
1266   int i, j, keylen, blklen;
1267   gcry_error_t err = 0;
1268
1269   if (verbose)
1270     fprintf (stderr, "Starting bulk cipher checks.\n");
1271
1272   buflen = 16*100;  /* We check a 1600 byte buffer.  */
1273   buffer_base = gcry_xmalloc (buflen+16);
1274   buffer = buffer_base + (16 - ((size_t)buffer_base & 0x0f));
1275   outbuf_base = gcry_xmalloc (buflen+16);
1276   outbuf = outbuf_base + (16 - ((size_t)outbuf_base & 0x0f));
1277
1278
1279   for (i = 0; i < DIM (tv); i++)
1280     {
1281       if (verbose)
1282         fprintf (stderr, "    checking bulk encryption for %s [%i], mode %d\n",
1283                  gcry_cipher_algo_name (tv[i].algo),
1284                  tv[i].algo, tv[i].mode);
1285       err = gcry_cipher_open (&hde, tv[i].algo, tv[i].mode, 0);
1286       if (!err)
1287         err = gcry_cipher_open (&hdd, tv[i].algo, tv[i].mode, 0);
1288       if (err)
1289         {
1290           fail ("gcry_cipher_open failed: %s\n", gpg_strerror (err));
1291           goto leave;
1292         }
1293
1294       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
1295       if (!keylen)
1296         {
1297           fail ("gcry_cipher_get_algo_keylen failed\n");
1298           goto leave;
1299         }
1300
1301       err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
1302       if (!err)
1303         err = gcry_cipher_setkey (hdd, tv[i].key, tv[i].keylen);
1304       if (err)
1305         {
1306           fail ("gcry_cipher_setkey failed: %s\n", gpg_strerror (err));
1307           goto leave;
1308         }
1309
1310       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
1311       if (!blklen)
1312         {
1313           fail ("gcry_cipher_get_algo_blklen failed\n");
1314           goto leave;
1315         }
1316
1317       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
1318       if (!err)
1319         err = gcry_cipher_setiv (hdd, tv[i].iv,  tv[i].ivlen);
1320       if (err)
1321         {
1322           fail ("gcry_cipher_setiv failed: %s\n", gpg_strerror (err));
1323           goto leave;
1324         }
1325
1326       /* Fill the buffer with our test pattern.  */
1327       for (j=0; j < buflen; j++)
1328         buffer[j] = ((j & 0xff) ^ ((j >> 8) & 0xff));
1329
1330       err = gcry_cipher_encrypt (hde, outbuf, buflen, buffer, buflen);
1331       if (err)
1332         {
1333           fail ("gcry_cipher_encrypt (algo %d, mode %d) failed: %s\n",
1334                 tv[i].algo, tv[i].mode, gpg_strerror (err));
1335           goto leave;
1336         }
1337
1338       gcry_md_hash_buffer (GCRY_MD_SHA1, hash, outbuf, buflen);
1339 #if 0
1340       printf ("/*[%d]*/\n", i);
1341       fputs ("      {", stdout);
1342       for (j=0; j < 20; j++)
1343         printf (" 0x%02x%c%s", hash[j], j==19? ' ':',', j == 9? "\n       ":"");
1344       puts ("}");
1345 #endif
1346
1347       if (memcmp (hash, tv[i].t1_hash, 20))
1348         fail ("encrypt mismatch (algo %d, mode %d)\n",
1349               tv[i].algo, tv[i].mode);
1350
1351       err = gcry_cipher_decrypt (hdd, outbuf, buflen, NULL, 0);
1352       if (err)
1353         {
1354           fail ("gcry_cipher_decrypt (algo %d, mode %d) failed: %s\n",
1355                 tv[i].algo, tv[i].mode, gpg_strerror (err));
1356           goto leave;
1357         }
1358
1359       if (memcmp (buffer, outbuf, buflen))
1360         fail ("decrypt mismatch (algo %d, mode %d)\n",
1361               tv[i].algo, tv[i].mode);
1362
1363       gcry_cipher_close (hde); hde = NULL;
1364       gcry_cipher_close (hdd); hdd = NULL;
1365     }
1366
1367   if (verbose)
1368     fprintf (stderr, "Completed bulk cipher checks.\n");
1369  leave:
1370   gcry_cipher_close (hde);
1371   gcry_cipher_close (hdd);
1372   gcry_free (buffer_base);
1373   gcry_free (outbuf_base);
1374 }
1375
1376
1377 /* The core of the cipher check.  In addition to the parameters passed
1378    to check_one_cipher it also receives the KEY and the plain data.
1379    PASS is printed with error messages.  The function returns 0 on
1380    success.  */
1381 static int
1382 check_one_cipher_core (int algo, int mode, int flags,
1383                        const char *key, size_t nkey,
1384                        const unsigned char *plain, size_t nplain,
1385                        int bufshift, int pass)
1386 {
1387   gcry_cipher_hd_t hd;
1388   unsigned char in_buffer[1040+1], out_buffer[1040+1];
1389   unsigned char *in, *out;
1390   int keylen;
1391   gcry_error_t err = 0;
1392
1393   assert (nkey == 32);
1394   assert (nplain == 1040);
1395   assert (sizeof(in_buffer) == nplain + 1);
1396   assert (sizeof(out_buffer) == sizeof(in_buffer));
1397
1398   if (!bufshift)
1399     {
1400       in = in_buffer;
1401       out = out_buffer;
1402     }
1403   else if (bufshift == 1)
1404     {
1405       in = in_buffer+1;
1406       out = out_buffer;
1407     }
1408   else if (bufshift == 2)
1409     {
1410       in = in_buffer+1;
1411       out = out_buffer+1;
1412     }
1413   else
1414     {
1415       in = in_buffer;
1416       out = out_buffer+1;
1417     }
1418
1419   keylen = gcry_cipher_get_algo_keylen (algo);
1420   if (!keylen)
1421     {
1422       fail ("pass %d, algo %d, mode %d, gcry_cipher_get_algo_keylen failed\n",
1423             pass, algo, mode);
1424       return -1;
1425     }
1426
1427   if (keylen < 40 / 8 || keylen > 32)
1428     {
1429       fail ("pass %d, algo %d, mode %d, keylength problem (%d)\n", pass, algo, mode, keylen);
1430       return -1;
1431     }
1432
1433   err = gcry_cipher_open (&hd, algo, mode, flags);
1434   if (err)
1435     {
1436       fail ("pass %d, algo %d, mode %d, gcry_cipher_open failed: %s\n",
1437             pass, algo, mode, gpg_strerror (err));
1438       return -1;
1439     }
1440
1441   err = gcry_cipher_setkey (hd, key, keylen);
1442   if (err)
1443     {
1444       fail ("pass %d, algo %d, mode %d, gcry_cipher_setkey failed: %s\n",
1445             pass, algo, mode, gpg_strerror (err));
1446       gcry_cipher_close (hd);
1447       return -1;
1448     }
1449
1450   err = gcry_cipher_encrypt (hd, out, nplain, plain, nplain);
1451   if (err)
1452     {
1453       fail ("pass %d, algo %d, mode %d, gcry_cipher_encrypt failed: %s\n",
1454             pass, algo, mode, gpg_strerror (err));
1455       gcry_cipher_close (hd);
1456       return -1;
1457     }
1458
1459   gcry_cipher_reset (hd);
1460
1461   err = gcry_cipher_decrypt (hd, in, nplain, out, nplain);
1462   if (err)
1463     {
1464       fail ("pass %d, algo %d, mode %d, gcry_cipher_decrypt failed: %s\n",
1465             pass, algo, mode, gpg_strerror (err));
1466       gcry_cipher_close (hd);
1467       return -1;
1468     }
1469
1470   if (memcmp (plain, in, nplain))
1471     fail ("pass %d, algo %d, mode %d, encrypt-decrypt mismatch\n",
1472           pass, algo, mode);
1473
1474   /* Again, using in-place encryption.  */
1475   gcry_cipher_reset (hd);
1476
1477   memcpy (out, plain, nplain);
1478   err = gcry_cipher_encrypt (hd, out, nplain, NULL, 0);
1479   if (err)
1480     {
1481       fail ("pass %d, algo %d, mode %d, in-place, gcry_cipher_encrypt failed:"
1482             " %s\n",
1483             pass, algo, mode, gpg_strerror (err));
1484       gcry_cipher_close (hd);
1485       return -1;
1486     }
1487
1488   gcry_cipher_reset (hd);
1489
1490   err = gcry_cipher_decrypt (hd, out, nplain, NULL, 0);
1491   if (err)
1492     {
1493       fail ("pass %d, algo %d, mode %d, in-place, gcry_cipher_decrypt failed:"
1494             " %s\n",
1495             pass, algo, mode, gpg_strerror (err));
1496       gcry_cipher_close (hd);
1497       return -1;
1498     }
1499
1500   if (memcmp (plain, out, nplain))
1501     fail ("pass %d, algo %d, mode %d, in-place, encrypt-decrypt mismatch\n",
1502           pass, algo, mode);
1503
1504
1505   gcry_cipher_close (hd);
1506
1507   return 0;
1508 }
1509
1510
1511
1512 static void
1513 check_one_cipher (int algo, int mode, int flags)
1514 {
1515   char key[32+1];
1516   unsigned char plain[1040+1];
1517   int bufshift, i;
1518
1519   for (bufshift=0; bufshift < 4; bufshift++)
1520     {
1521       /* Pass 0: Standard test.  */
1522       memcpy (key, "0123456789abcdef.,;/[]{}-=ABCDEF", 32);
1523       memcpy (plain, "foobar42FOOBAR17", 16);
1524       for (i = 16; i < 1040; i += 16)
1525         {
1526           memcpy (&plain[i], &plain[i-16], 16);
1527           if (!++plain[i+7])
1528             plain[i+6]++;
1529           if (!++plain[i+15])
1530             plain[i+14]++;
1531         }
1532
1533       if (check_one_cipher_core (algo, mode, flags, key, 32, plain, 1040,
1534                                  bufshift, 0+10*bufshift))
1535         return;
1536
1537       /* Pass 1: Key not aligned.  */
1538       memmove (key+1, key, 32);
1539       if (check_one_cipher_core (algo, mode, flags, key+1, 32, plain, 1040,
1540                                  bufshift, 1+10*bufshift))
1541         return;
1542
1543       /* Pass 2: Key not aligned and data not aligned.  */
1544       memmove (plain+1, plain, 1024);
1545       if (check_one_cipher_core (algo, mode, flags, key+1, 32, plain+1, 1040,
1546                                  bufshift, 2+10*bufshift))
1547         return;
1548
1549       /* Pass 3: Key aligned and data not aligned.  */
1550       memmove (key, key+1, 32);
1551       if (check_one_cipher_core (algo, mode, flags, key, 32, plain+1, 1040,
1552                                  bufshift, 3+10*bufshift))
1553         return;
1554     }
1555
1556   return;
1557 }
1558
1559
1560
1561 static void
1562 check_ciphers (void)
1563 {
1564   static int algos[] = {
1565 #if USE_BLOWFISH
1566     GCRY_CIPHER_BLOWFISH,
1567 #endif
1568 #if USE_DES
1569     GCRY_CIPHER_DES,
1570     GCRY_CIPHER_3DES,
1571 #endif
1572 #if USE_CAST5
1573     GCRY_CIPHER_CAST5,
1574 #endif
1575 #if USE_AES
1576     GCRY_CIPHER_AES,
1577     GCRY_CIPHER_AES192,
1578     GCRY_CIPHER_AES256,
1579 #endif
1580 #if USE_TWOFISH
1581     GCRY_CIPHER_TWOFISH,
1582     GCRY_CIPHER_TWOFISH128,
1583 #endif
1584 #if USE_SERPENT
1585     GCRY_CIPHER_SERPENT128,
1586     GCRY_CIPHER_SERPENT192,
1587     GCRY_CIPHER_SERPENT256,
1588 #endif
1589 #if USE_RFC2268
1590     GCRY_CIPHER_RFC2268_40,
1591 #endif
1592 #if USE_SEED
1593     GCRY_CIPHER_SEED,
1594 #endif
1595 #if USE_CAMELLIA
1596     GCRY_CIPHER_CAMELLIA128,
1597     GCRY_CIPHER_CAMELLIA192,
1598     GCRY_CIPHER_CAMELLIA256,
1599 #endif
1600 #if USE_IDEA
1601     GCRY_CIPHER_IDEA,
1602 #endif
1603     0
1604   };
1605   static int algos2[] = {
1606 #if USE_ARCFOUR
1607     GCRY_CIPHER_ARCFOUR,
1608 #endif
1609     0
1610   };
1611   int i;
1612
1613   if (verbose)
1614     fprintf (stderr, "Starting Cipher checks.\n");
1615   for (i = 0; algos[i]; i++)
1616     {
1617       if (gcry_cipher_test_algo (algos[i]) && in_fips_mode)
1618         {
1619           if (verbose)
1620             fprintf (stderr, "  algorithm %d not available in fips mode\n",
1621                      algos[i]);
1622           continue;
1623         }
1624       if (verbose)
1625         fprintf (stderr, "  checking %s [%i]\n",
1626                  gcry_cipher_algo_name (algos[i]),
1627                  gcry_cipher_map_name (gcry_cipher_algo_name (algos[i])));
1628
1629       check_one_cipher (algos[i], GCRY_CIPHER_MODE_ECB, 0);
1630       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CFB, 0);
1631       check_one_cipher (algos[i], GCRY_CIPHER_MODE_OFB, 0);
1632       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, 0);
1633       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_CTS);
1634       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CTR, 0);
1635     }
1636
1637   for (i = 0; algos2[i]; i++)
1638     {
1639       if (gcry_cipher_test_algo (algos[i]) && in_fips_mode)
1640         {
1641           if (verbose)
1642             fprintf (stderr, "  algorithm %d not available in fips mode\n",
1643                      algos[i]);
1644           continue;
1645         }
1646       if (verbose)
1647         fprintf (stderr, "  checking `%s'\n",
1648                  gcry_cipher_algo_name (algos2[i]));
1649
1650       check_one_cipher (algos2[i], GCRY_CIPHER_MODE_STREAM, 0);
1651     }
1652   /* we have now run all cipher's selftests */
1653
1654   if (verbose)
1655     fprintf (stderr, "Completed Cipher checks.\n");
1656
1657   /* TODO: add some extra encryption to test the higher level functions */
1658 }
1659
1660
1661 static void
1662 check_cipher_modes(void)
1663 {
1664   if (verbose)
1665     fprintf (stderr, "Starting Cipher Mode checks.\n");
1666
1667   check_aes128_cbc_cts_cipher ();
1668   check_cbc_mac_cipher ();
1669   check_ctr_cipher ();
1670   check_cfb_cipher ();
1671   check_ofb_cipher ();
1672
1673   if (verbose)
1674     fprintf (stderr, "Completed Cipher Mode checks.\n");
1675 }
1676
1677 static void
1678 check_one_md (int algo, const char *data, int len, const char *expect)
1679 {
1680   gcry_md_hd_t hd, hd2;
1681   unsigned char *p;
1682   int mdlen;
1683   int i;
1684   gcry_error_t err = 0;
1685
1686   err = gcry_md_open (&hd, algo, 0);
1687   if (err)
1688     {
1689       fail ("algo %d, gcry_md_open failed: %s\n", algo, gpg_strerror (err));
1690       return;
1691     }
1692
1693   mdlen = gcry_md_get_algo_dlen (algo);
1694   if (mdlen < 1 || mdlen > 500)
1695     {
1696       fail ("algo %d, gcry_md_get_algo_dlen failed: %d\n", algo, mdlen);
1697       return;
1698     }
1699
1700   if (*data == '!' && !data[1])
1701     {                           /* hash one million times a "a" */
1702       char aaa[1000];
1703
1704       /* Write in odd size chunks so that we test the buffering.  */
1705       memset (aaa, 'a', 1000);
1706       for (i = 0; i < 1000; i++)
1707         gcry_md_write (hd, aaa, 1000);
1708     }
1709   else
1710     gcry_md_write (hd, data, len);
1711
1712   err = gcry_md_copy (&hd2, hd);
1713   if (err)
1714     {
1715       fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
1716     }
1717
1718   gcry_md_close (hd);
1719
1720   p = gcry_md_read (hd2, algo);
1721
1722   if (memcmp (p, expect, mdlen))
1723     {
1724       printf ("computed: ");
1725       for (i = 0; i < mdlen; i++)
1726         printf ("%02x ", p[i] & 0xFF);
1727       printf ("\nexpected: ");
1728       for (i = 0; i < mdlen; i++)
1729         printf ("%02x ", expect[i] & 0xFF);
1730       printf ("\n");
1731
1732       fail ("algo %d, digest mismatch\n", algo);
1733     }
1734
1735   gcry_md_close (hd2);
1736 }
1737
1738
1739 static void
1740 check_digests (void)
1741 {
1742   static struct algos
1743   {
1744     int md;
1745     const char *data;
1746     const char *expect;
1747   } algos[] =
1748     {
1749       { GCRY_MD_MD4, "",
1750         "\x31\xD6\xCF\xE0\xD1\x6A\xE9\x31\xB7\x3C\x59\xD7\xE0\xC0\x89\xC0" },
1751       { GCRY_MD_MD4, "a",
1752         "\xbd\xe5\x2c\xb3\x1d\xe3\x3e\x46\x24\x5e\x05\xfb\xdb\xd6\xfb\x24" },
1753       { GCRY_MD_MD4, "message digest",
1754         "\xd9\x13\x0a\x81\x64\x54\x9f\xe8\x18\x87\x48\x06\xe1\xc7\x01\x4b" },
1755       { GCRY_MD_MD5, "",
1756         "\xD4\x1D\x8C\xD9\x8F\x00\xB2\x04\xE9\x80\x09\x98\xEC\xF8\x42\x7E" },
1757       { GCRY_MD_MD5, "a",
1758         "\x0C\xC1\x75\xB9\xC0\xF1\xB6\xA8\x31\xC3\x99\xE2\x69\x77\x26\x61" },
1759       { GCRY_MD_MD5, "abc",
1760         "\x90\x01\x50\x98\x3C\xD2\x4F\xB0\xD6\x96\x3F\x7D\x28\xE1\x7F\x72" },
1761       { GCRY_MD_MD5, "message digest",
1762         "\xF9\x6B\x69\x7D\x7C\xB7\x93\x8D\x52\x5A\x2F\x31\xAA\xF1\x61\xD0" },
1763       { GCRY_MD_SHA1, "abc",
1764         "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E"
1765         "\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" },
1766       { GCRY_MD_SHA1,
1767         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1768         "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE"
1769         "\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" },
1770       { GCRY_MD_SHA1, "!" /* kludge for "a"*1000000 */ ,
1771         "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E"
1772         "\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" },
1773       /* From RFC3874 */
1774       { GCRY_MD_SHA224, "abc",
1775         "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
1776         "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7" },
1777       { GCRY_MD_SHA224,
1778         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1779         "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01\x50"
1780         "\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25" },
1781       { GCRY_MD_SHA224, "!",
1782         "\x20\x79\x46\x55\x98\x0c\x91\xd8\xbb\xb4\xc1\xea\x97\x61\x8a\x4b"
1783         "\xf0\x3f\x42\x58\x19\x48\xb2\xee\x4e\xe7\xad\x67" },
1784       { GCRY_MD_SHA256, "abc",
1785         "\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
1786         "\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad" },
1787       { GCRY_MD_SHA256,
1788         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1789         "\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
1790         "\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1" },
1791       { GCRY_MD_SHA256, "!",
1792         "\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67"
1793         "\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0" },
1794       { GCRY_MD_SHA384, "abc",
1795         "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b\xb5\xa0\x3d\x69\x9a\xc6\x50\x07"
1796         "\x27\x2c\x32\xab\x0e\xde\xd1\x63\x1a\x8b\x60\x5a\x43\xff\x5b\xed"
1797         "\x80\x86\x07\x2b\xa1\xe7\xcc\x23\x58\xba\xec\xa1\x34\xc8\x25\xa7" },
1798       { GCRY_MD_SHA512, "abc",
1799         "\xDD\xAF\x35\xA1\x93\x61\x7A\xBA\xCC\x41\x73\x49\xAE\x20\x41\x31"
1800         "\x12\xE6\xFA\x4E\x89\xA9\x7E\xA2\x0A\x9E\xEE\xE6\x4B\x55\xD3\x9A"
1801         "\x21\x92\x99\x2A\x27\x4F\xC1\xA8\x36\xBA\x3C\x23\xA3\xFE\xEB\xBD"
1802         "\x45\x4D\x44\x23\x64\x3C\xE8\x0E\x2A\x9A\xC9\x4F\xA5\x4C\xA4\x9F" },
1803       { GCRY_MD_RMD160, "",
1804         "\x9c\x11\x85\xa5\xc5\xe9\xfc\x54\x61\x28"
1805         "\x08\x97\x7e\xe8\xf5\x48\xb2\x25\x8d\x31" },
1806       { GCRY_MD_RMD160, "a",
1807         "\x0b\xdc\x9d\x2d\x25\x6b\x3e\xe9\xda\xae"
1808         "\x34\x7b\xe6\xf4\xdc\x83\x5a\x46\x7f\xfe" },
1809       { GCRY_MD_RMD160, "abc",
1810         "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04"
1811         "\x4a\x8e\x98\xc6\xb0\x87\xf1\x5a\x0b\xfc" },
1812       { GCRY_MD_RMD160, "message digest",
1813         "\x5d\x06\x89\xef\x49\xd2\xfa\xe5\x72\xb8"
1814         "\x81\xb1\x23\xa8\x5f\xfa\x21\x59\x5f\x36" },
1815       { GCRY_MD_CRC32, "", "\x00\x00\x00\x00" },
1816       { GCRY_MD_CRC32, "foo", "\x8c\x73\x65\x21" },
1817       { GCRY_MD_CRC32_RFC1510, "", "\x00\x00\x00\x00" },
1818       { GCRY_MD_CRC32_RFC1510, "foo", "\x73\x32\xbc\x33" },
1819       { GCRY_MD_CRC32_RFC1510, "test0123456789", "\xb8\x3e\x88\xd6" },
1820       { GCRY_MD_CRC32_RFC1510, "MASSACHVSETTS INSTITVTE OF TECHNOLOGY",
1821         "\xe3\x41\x80\xf7" },
1822 #if 0
1823       { GCRY_MD_CRC32_RFC1510, "\x80\x00", "\x3b\x83\x98\x4b" },
1824       { GCRY_MD_CRC32_RFC1510, "\x00\x08", "\x0e\xdb\x88\x32" },
1825       { GCRY_MD_CRC32_RFC1510, "\x00\x80", "\xed\xb8\x83\x20" },
1826 #endif
1827       { GCRY_MD_CRC32_RFC1510, "\x80", "\xed\xb8\x83\x20" },
1828 #if 0
1829       { GCRY_MD_CRC32_RFC1510, "\x80\x00\x00\x00", "\xed\x59\xb6\x3b" },
1830       { GCRY_MD_CRC32_RFC1510, "\x00\x00\x00\x01", "\x77\x07\x30\x96" },
1831 #endif
1832       { GCRY_MD_CRC24_RFC2440, "", "\xb7\x04\xce" },
1833       { GCRY_MD_CRC24_RFC2440, "foo", "\x4f\xc2\x55" },
1834
1835       { GCRY_MD_TIGER, "",
1836         "\x24\xF0\x13\x0C\x63\xAC\x93\x32\x16\x16\x6E\x76"
1837         "\xB1\xBB\x92\x5F\xF3\x73\xDE\x2D\x49\x58\x4E\x7A" },
1838       { GCRY_MD_TIGER, "abc",
1839         "\xF2\x58\xC1\xE8\x84\x14\xAB\x2A\x52\x7A\xB5\x41"
1840         "\xFF\xC5\xB8\xBF\x93\x5F\x7B\x95\x1C\x13\x29\x51" },
1841       { GCRY_MD_TIGER, "Tiger",
1842         "\x9F\x00\xF5\x99\x07\x23\x00\xDD\x27\x6A\xBB\x38"
1843         "\xC8\xEB\x6D\xEC\x37\x79\x0C\x11\x6F\x9D\x2B\xDF" },
1844       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg"
1845         "hijklmnopqrstuvwxyz0123456789+-",
1846         "\x87\xFB\x2A\x90\x83\x85\x1C\xF7\x47\x0D\x2C\xF8"
1847         "\x10\xE6\xDF\x9E\xB5\x86\x44\x50\x34\xA5\xA3\x86" },
1848       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdef"
1849         "ghijklmnopqrstuvwxyz+0123456789",
1850         "\x46\x7D\xB8\x08\x63\xEB\xCE\x48\x8D\xF1\xCD\x12"
1851         "\x61\x65\x5D\xE9\x57\x89\x65\x65\x97\x5F\x91\x97" },
1852       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
1853         "by Ross Anderson and Eli Biham",
1854         "\x0C\x41\x0A\x04\x29\x68\x86\x8A\x16\x71\xDA\x5A"
1855         "\x3F\xD2\x9A\x72\x5E\xC1\xE4\x57\xD3\xCD\xB3\x03" },
1856       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
1857         "by Ross Anderson and Eli Biham, proceedings of Fa"
1858         "st Software Encryption 3, Cambridge.",
1859         "\xEB\xF5\x91\xD5\xAF\xA6\x55\xCE\x7F\x22\x89\x4F"
1860         "\xF8\x7F\x54\xAC\x89\xC8\x11\xB6\xB0\xDA\x31\x93" },
1861       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
1862         "by Ross Anderson and Eli Biham, proceedings of Fa"
1863         "st Software Encryption 3, Cambridge, 1996.",
1864         "\x3D\x9A\xEB\x03\xD1\xBD\x1A\x63\x57\xB2\x77\x4D"
1865         "\xFD\x6D\x5B\x24\xDD\x68\x15\x1D\x50\x39\x74\xFC" },
1866       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefgh"
1867         "ijklmnopqrstuvwxyz0123456789+-ABCDEFGHIJKLMNOPQRS"
1868         "TUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-",
1869         "\x00\xB8\x3E\xB4\xE5\x34\x40\xC5\x76\xAC\x6A\xAE"
1870         "\xE0\xA7\x48\x58\x25\xFD\x15\xE7\x0A\x59\xFF\xE4" },
1871
1872       { GCRY_MD_TIGER1, "",
1873         "\x32\x93\xAC\x63\x0C\x13\xF0\x24\x5F\x92\xBB\xB1"
1874         "\x76\x6E\x16\x16\x7A\x4E\x58\x49\x2D\xDE\x73\xF3" },
1875       { GCRY_MD_TIGER1, "a",
1876         "\x77\xBE\xFB\xEF\x2E\x7E\xF8\xAB\x2E\xC8\xF9\x3B"
1877         "\xF5\x87\xA7\xFC\x61\x3E\x24\x7F\x5F\x24\x78\x09" },
1878       { GCRY_MD_TIGER1, "abc",
1879         "\x2A\xAB\x14\x84\xE8\xC1\x58\xF2\xBF\xB8\xC5\xFF"
1880         "\x41\xB5\x7A\x52\x51\x29\x13\x1C\x95\x7B\x5F\x93" },
1881       { GCRY_MD_TIGER1, "message digest",
1882         "\xD9\x81\xF8\xCB\x78\x20\x1A\x95\x0D\xCF\x30\x48"
1883         "\x75\x1E\x44\x1C\x51\x7F\xCA\x1A\xA5\x5A\x29\xF6" },
1884       { GCRY_MD_TIGER1, "abcdefghijklmnopqrstuvwxyz",
1885         "\x17\x14\xA4\x72\xEE\xE5\x7D\x30\x04\x04\x12\xBF"
1886         "\xCC\x55\x03\x2A\x0B\x11\x60\x2F\xF3\x7B\xEE\xE9" },
1887       { GCRY_MD_TIGER1,
1888         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1889         "\x0F\x7B\xF9\xA1\x9B\x9C\x58\xF2\xB7\x61\x0D\xF7"
1890         "\xE8\x4F\x0A\xC3\xA7\x1C\x63\x1E\x7B\x53\xF7\x8E" },
1891       { GCRY_MD_TIGER1,
1892         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1893         "abcdefghijklmnopqrstuvwxyz" "0123456789",
1894         "\x8D\xCE\xA6\x80\xA1\x75\x83\xEE\x50\x2B\xA3\x8A"
1895         "\x3C\x36\x86\x51\x89\x0F\xFB\xCC\xDC\x49\xA8\xCC" },
1896       { GCRY_MD_TIGER1,
1897         "1234567890" "1234567890" "1234567890" "1234567890"
1898         "1234567890" "1234567890" "1234567890" "1234567890",
1899         "\x1C\x14\x79\x55\x29\xFD\x9F\x20\x7A\x95\x8F\x84"
1900         "\xC5\x2F\x11\xE8\x87\xFA\x0C\xAB\xDF\xD9\x1B\xFD" },
1901       { GCRY_MD_TIGER1, "!",
1902         "\x6D\xB0\xE2\x72\x9C\xBE\xAD\x93\xD7\x15\xC6\xA7"
1903         "\xD3\x63\x02\xE9\xB3\xCE\xE0\xD2\xBC\x31\x4B\x41" },
1904
1905       { GCRY_MD_TIGER2, "",
1906         "\x44\x41\xBE\x75\xF6\x01\x87\x73\xC2\x06\xC2\x27"
1907         "\x45\x37\x4B\x92\x4A\xA8\x31\x3F\xEF\x91\x9F\x41" },
1908       { GCRY_MD_TIGER2, "a",
1909         "\x67\xE6\xAE\x8E\x9E\x96\x89\x99\xF7\x0A\x23\xE7"
1910         "\x2A\xEA\xA9\x25\x1C\xBC\x7C\x78\xA7\x91\x66\x36" },
1911       { GCRY_MD_TIGER2, "abc",
1912         "\xF6\x8D\x7B\xC5\xAF\x4B\x43\xA0\x6E\x04\x8D\x78"
1913         "\x29\x56\x0D\x4A\x94\x15\x65\x8B\xB0\xB1\xF3\xBF" },
1914       { GCRY_MD_TIGER2, "message digest",
1915         "\xE2\x94\x19\xA1\xB5\xFA\x25\x9D\xE8\x00\x5E\x7D"
1916         "\xE7\x50\x78\xEA\x81\xA5\x42\xEF\x25\x52\x46\x2D" },
1917       { GCRY_MD_TIGER2, "abcdefghijklmnopqrstuvwxyz",
1918         "\xF5\xB6\xB6\xA7\x8C\x40\x5C\x85\x47\xE9\x1C\xD8"
1919         "\x62\x4C\xB8\xBE\x83\xFC\x80\x4A\x47\x44\x88\xFD" },
1920       { GCRY_MD_TIGER2,
1921         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1922         "\xA6\x73\x7F\x39\x97\xE8\xFB\xB6\x3D\x20\xD2\xDF"
1923         "\x88\xF8\x63\x76\xB5\xFE\x2D\x5C\xE3\x66\x46\xA9" },
1924       { GCRY_MD_TIGER2,
1925         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1926         "abcdefghijklmnopqrstuvwxyz" "0123456789",
1927         "\xEA\x9A\xB6\x22\x8C\xEE\x7B\x51\xB7\x75\x44\xFC"
1928         "\xA6\x06\x6C\x8C\xBB\x5B\xBA\xE6\x31\x95\x05\xCD" },
1929       { GCRY_MD_TIGER2,
1930         "1234567890" "1234567890" "1234567890" "1234567890"
1931         "1234567890" "1234567890" "1234567890" "1234567890",
1932         "\xD8\x52\x78\x11\x53\x29\xEB\xAA\x0E\xEC\x85\xEC"
1933         "\xDC\x53\x96\xFD\xA8\xAA\x3A\x58\x20\x94\x2F\xFF" },
1934       { GCRY_MD_TIGER2, "!",
1935         "\xE0\x68\x28\x1F\x06\x0F\x55\x16\x28\xCC\x57\x15"
1936         "\xB9\xD0\x22\x67\x96\x91\x4D\x45\xF7\x71\x7C\xF4" },
1937
1938       { GCRY_MD_WHIRLPOOL, "",
1939         "\x19\xFA\x61\xD7\x55\x22\xA4\x66\x9B\x44\xE3\x9C\x1D\x2E\x17\x26"
1940         "\xC5\x30\x23\x21\x30\xD4\x07\xF8\x9A\xFE\xE0\x96\x49\x97\xF7\xA7"
1941         "\x3E\x83\xBE\x69\x8B\x28\x8F\xEB\xCF\x88\xE3\xE0\x3C\x4F\x07\x57"
1942         "\xEA\x89\x64\xE5\x9B\x63\xD9\x37\x08\xB1\x38\xCC\x42\xA6\x6E\xB3" },
1943       { GCRY_MD_WHIRLPOOL, "a",
1944         "\x8A\xCA\x26\x02\x79\x2A\xEC\x6F\x11\xA6\x72\x06\x53\x1F\xB7\xD7"
1945         "\xF0\xDF\xF5\x94\x13\x14\x5E\x69\x73\xC4\x50\x01\xD0\x08\x7B\x42"
1946         "\xD1\x1B\xC6\x45\x41\x3A\xEF\xF6\x3A\x42\x39\x1A\x39\x14\x5A\x59"
1947         "\x1A\x92\x20\x0D\x56\x01\x95\xE5\x3B\x47\x85\x84\xFD\xAE\x23\x1A" },
1948       { GCRY_MD_WHIRLPOOL, "a",
1949         "\x8A\xCA\x26\x02\x79\x2A\xEC\x6F\x11\xA6\x72\x06\x53\x1F\xB7\xD7"
1950         "\xF0\xDF\xF5\x94\x13\x14\x5E\x69\x73\xC4\x50\x01\xD0\x08\x7B\x42"
1951         "\xD1\x1B\xC6\x45\x41\x3A\xEF\xF6\x3A\x42\x39\x1A\x39\x14\x5A\x59"
1952         "\x1A\x92\x20\x0D\x56\x01\x95\xE5\x3B\x47\x85\x84\xFD\xAE\x23\x1A" },
1953       { GCRY_MD_WHIRLPOOL,
1954         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
1955         "\xDC\x37\xE0\x08\xCF\x9E\xE6\x9B\xF1\x1F\x00\xED\x9A\xBA\x26\x90"
1956         "\x1D\xD7\xC2\x8C\xDE\xC0\x66\xCC\x6A\xF4\x2E\x40\xF8\x2F\x3A\x1E"
1957         "\x08\xEB\xA2\x66\x29\x12\x9D\x8F\xB7\xCB\x57\x21\x1B\x92\x81\xA6"
1958         "\x55\x17\xCC\x87\x9D\x7B\x96\x21\x42\xC6\x5F\x5A\x7A\xF0\x14\x67" },
1959       { GCRY_MD_WHIRLPOOL,
1960         "!",
1961         "\x0C\x99\x00\x5B\xEB\x57\xEF\xF5\x0A\x7C\xF0\x05\x56\x0D\xDF\x5D"
1962         "\x29\x05\x7F\xD8\x6B\x20\xBF\xD6\x2D\xEC\xA0\xF1\xCC\xEA\x4A\xF5"
1963         "\x1F\xC1\x54\x90\xED\xDC\x47\xAF\x32\xBB\x2B\x66\xC3\x4F\xF9\xAD"
1964         "\x8C\x60\x08\xAD\x67\x7F\x77\x12\x69\x53\xB2\x26\xE4\xED\x8B\x01" },
1965       { 0 },
1966     };
1967   int i;
1968
1969   if (verbose)
1970     fprintf (stderr, "Starting hash checks.\n");
1971
1972   for (i = 0; algos[i].md; i++)
1973     {
1974       if ((gcry_md_test_algo (algos[i].md) || algos[i].md == GCRY_MD_MD5)
1975           && in_fips_mode)
1976         {
1977           if (verbose)
1978             fprintf (stderr, "  algorithm %d not available in fips mode\n",
1979                      algos[i].md);
1980           continue;
1981         }
1982       if (verbose)
1983         fprintf (stderr, "  checking %s [%i] for length %zi\n",
1984                  gcry_md_algo_name (algos[i].md),
1985                  algos[i].md,
1986                  !strcmp (algos[i].data, "!")?
1987                  1000000 : strlen(algos[i].data));
1988
1989       check_one_md (algos[i].md, algos[i].data, strlen (algos[i].data),
1990                     algos[i].expect);
1991     }
1992
1993   if (verbose)
1994     fprintf (stderr, "Completed hash checks.\n");
1995 }
1996
1997 static void
1998 check_one_hmac (int algo, const char *data, int datalen,
1999                 const char *key, int keylen, const char *expect)
2000 {
2001   gcry_md_hd_t hd, hd2;
2002   unsigned char *p;
2003   int mdlen;
2004   int i;
2005   gcry_error_t err = 0;
2006
2007   err = gcry_md_open (&hd, algo, GCRY_MD_FLAG_HMAC);
2008   if (err)
2009     {
2010       fail ("algo %d, gcry_md_open failed: %s\n", algo, gpg_strerror (err));
2011       return;
2012     }
2013
2014   mdlen = gcry_md_get_algo_dlen (algo);
2015   if (mdlen < 1 || mdlen > 500)
2016     {
2017       fail ("algo %d, gcry_md_get_algo_dlen failed: %d\n", algo, mdlen);
2018       return;
2019     }
2020
2021   gcry_md_setkey( hd, key, keylen );
2022
2023   gcry_md_write (hd, data, datalen);
2024
2025   err = gcry_md_copy (&hd2, hd);
2026   if (err)
2027     {
2028       fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
2029     }
2030
2031   gcry_md_close (hd);
2032
2033   p = gcry_md_read (hd2, algo);
2034   if (!p)
2035     fail("algo %d, hmac gcry_md_read failed\n", algo);
2036
2037   if (memcmp (p, expect, mdlen))
2038     {
2039       printf ("computed: ");
2040       for (i = 0; i < mdlen; i++)
2041         printf ("%02x ", p[i] & 0xFF);
2042       printf ("\nexpected: ");
2043       for (i = 0; i < mdlen; i++)
2044         printf ("%02x ", expect[i] & 0xFF);
2045       printf ("\n");
2046
2047       fail ("algo %d, digest mismatch\n", algo);
2048     }
2049
2050   gcry_md_close (hd2);
2051 }
2052
2053 static void
2054 check_hmac (void)
2055 {
2056   static struct algos
2057   {
2058     int md;
2059     const char *data;
2060     const char *key;
2061     const char *expect;
2062   } algos[] =
2063     {
2064       { GCRY_MD_MD5, "what do ya want for nothing?", "Jefe",
2065         "\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7\x38" },
2066       { GCRY_MD_MD5,
2067         "Hi There",
2068         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
2069         "\x92\x94\x72\x7a\x36\x38\xbb\x1c\x13\xf4\x8e\xf8\x15\x8b\xfc\x9d" },
2070       { GCRY_MD_MD5,
2071         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2072         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2073         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2074         "\xdd\xdd\xdd\xdd\xdd",
2075         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA",
2076         "\x56\xbe\x34\x52\x1d\x14\x4c\x88\xdb\xb8\xc7\x33\xf0\xe8\xb3\xf6" },
2077       { GCRY_MD_MD5,
2078         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2079         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2080         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2081         "\xcd\xcd\xcd\xcd\xcd",
2082         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2083         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2084         "\x69\x7e\xaf\x0a\xca\x3a\x3a\xea\x3a\x75\x16\x47\x46\xff\xaa\x79" },
2085       { GCRY_MD_MD5, "Test With Truncation",
2086         "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c",
2087         "\x56\x46\x1e\xf2\x34\x2e\xdc\x00\xf9\xba\xb9\x95\x69\x0e\xfd\x4c" },
2088       { GCRY_MD_MD5, "Test Using Larger Than Block-Size Key - Hash Key First",
2089         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2090         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2091         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2092         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2093         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2094         "\xaa\xaa\xaa\xaa\xaa",
2095         "\x6b\x1a\xb7\xfe\x4b\xd7\xbf\x8f\x0b\x62\xe6\xce\x61\xb9\xd0\xcd" },
2096       { GCRY_MD_MD5,
2097         "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
2098         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2099         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2100         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2101         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2102         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2103         "\xaa\xaa\xaa\xaa\xaa",
2104         "\x6f\x63\x0f\xad\x67\xcd\xa0\xee\x1f\xb1\xf5\x62\xdb\x3a\xa5\x3e", },
2105       { GCRY_MD_SHA256, "what do ya want for nothing?", "Jefe",
2106         "\x5b\xdc\xc1\x46\xbf\x60\x75\x4e\x6a\x04\x24\x26\x08\x95\x75\xc7\x5a"
2107         "\x00\x3f\x08\x9d\x27\x39\x83\x9d\xec\x58\xb9\x64\xec\x38\x43" },
2108       { GCRY_MD_SHA256,
2109         "Hi There",
2110         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2111         "\x0b\x0b\x0b",
2112         "\xb0\x34\x4c\x61\xd8\xdb\x38\x53\x5c\xa8\xaf\xce\xaf\x0b\xf1\x2b\x88"
2113         "\x1d\xc2\x00\xc9\x83\x3d\xa7\x26\xe9\x37\x6c\x2e\x32\xcf\xf7" },
2114       { GCRY_MD_SHA256,
2115         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2116         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2117         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2118         "\xdd\xdd\xdd\xdd\xdd",
2119         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2120         "\xAA\xAA\xAA\xAA",
2121         "\x77\x3e\xa9\x1e\x36\x80\x0e\x46\x85\x4d\xb8\xeb\xd0\x91\x81\xa7"
2122         "\x29\x59\x09\x8b\x3e\xf8\xc1\x22\xd9\x63\x55\x14\xce\xd5\x65\xfe" },
2123       { GCRY_MD_SHA256,
2124         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2125         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2126         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2127         "\xcd\xcd\xcd\xcd\xcd",
2128         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2129         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2130         "\x82\x55\x8a\x38\x9a\x44\x3c\x0e\xa4\xcc\x81\x98\x99\xf2\x08"
2131         "\x3a\x85\xf0\xfa\xa3\xe5\x78\xf8\x07\x7a\x2e\x3f\xf4\x67\x29\x66\x5b" },
2132       { GCRY_MD_SHA256,
2133         "Test Using Larger Than Block-Size Key - Hash Key First",
2134         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2135         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2136         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2137         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2138         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2139         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2140         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2141         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2142         "\xaa\xaa\xaa",
2143         "\x60\xe4\x31\x59\x1e\xe0\xb6\x7f\x0d\x8a\x26\xaa\xcb\xf5\xb7\x7f"
2144         "\x8e\x0b\xc6\x21\x37\x28\xc5\x14\x05\x46\x04\x0f\x0e\xe3\x7f\x54" },
2145       { GCRY_MD_SHA256,
2146         "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.",
2147         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2148         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2149         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2150         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2151         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2152         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2153         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2154         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2155         "\xaa\xaa\xaa",
2156         "\x9b\x09\xff\xa7\x1b\x94\x2f\xcb\x27\x63\x5f\xbc\xd5\xb0\xe9\x44"
2157         "\xbf\xdc\x63\x64\x4f\x07\x13\x93\x8a\x7f\x51\x53\x5c\x3a\x35\xe2" },
2158       { GCRY_MD_SHA224, "what do ya want for nothing?", "Jefe",
2159         "\xa3\x0e\x01\x09\x8b\xc6\xdb\xbf\x45\x69\x0f\x3a\x7e\x9e\x6d\x0f"
2160         "\x8b\xbe\xa2\xa3\x9e\x61\x48\x00\x8f\xd0\x5e\x44" },
2161       { GCRY_MD_SHA224,
2162         "Hi There",
2163         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2164         "\x0b\x0b\x0b",
2165         "\x89\x6f\xb1\x12\x8a\xbb\xdf\x19\x68\x32\x10\x7c\xd4\x9d\xf3\x3f\x47"
2166         "\xb4\xb1\x16\x99\x12\xba\x4f\x53\x68\x4b\x22" },
2167       { GCRY_MD_SHA224,
2168         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2169         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2170         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2171         "\xdd\xdd\xdd\xdd\xdd",
2172         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2173         "\xAA\xAA\xAA\xAA",
2174         "\x7f\xb3\xcb\x35\x88\xc6\xc1\xf6\xff\xa9\x69\x4d\x7d\x6a\xd2\x64"
2175         "\x93\x65\xb0\xc1\xf6\x5d\x69\xd1\xec\x83\x33\xea" },
2176       { GCRY_MD_SHA224,
2177         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2178         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2179         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2180         "\xcd\xcd\xcd\xcd\xcd",
2181         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2182         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2183         "\x6c\x11\x50\x68\x74\x01\x3c\xac\x6a\x2a\xbc\x1b\xb3\x82\x62"
2184         "\x7c\xec\x6a\x90\xd8\x6e\xfc\x01\x2d\xe7\xaf\xec\x5a" },
2185       { GCRY_MD_SHA224,
2186         "Test Using Larger Than Block-Size Key - Hash Key First",
2187         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2188         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2189         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2190         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2191         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2192         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2193         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2194         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2195         "\xaa\xaa\xaa",
2196         "\x95\xe9\xa0\xdb\x96\x20\x95\xad\xae\xbe\x9b\x2d\x6f\x0d\xbc\xe2"
2197         "\xd4\x99\xf1\x12\xf2\xd2\xb7\x27\x3f\xa6\x87\x0e" },
2198       { GCRY_MD_SHA224,
2199         "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.",
2200         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2201         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2202         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2203         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2204         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2205         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2206         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2207         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2208         "\xaa\xaa\xaa",
2209         "\x3a\x85\x41\x66\xac\x5d\x9f\x02\x3f\x54\xd5\x17\xd0\xb3\x9d\xbd"
2210         "\x94\x67\x70\xdb\x9c\x2b\x95\xc9\xf6\xf5\x65\xd1" },
2211       { GCRY_MD_SHA384, "what do ya want for nothing?", "Jefe",
2212         "\xaf\x45\xd2\xe3\x76\x48\x40\x31\x61\x7f\x78\xd2\xb5\x8a\x6b\x1b"
2213         "\x9c\x7e\xf4\x64\xf5\xa0\x1b\x47\xe4\x2e\xc3\x73\x63\x22\x44\x5e"
2214         "\x8e\x22\x40\xca\x5e\x69\xe2\xc7\x8b\x32\x39\xec\xfa\xb2\x16\x49" },
2215       { GCRY_MD_SHA384,
2216         "Hi There",
2217         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2218         "\x0b\x0b\x0b",
2219         "\xaf\xd0\x39\x44\xd8\x48\x95\x62\x6b\x08\x25\xf4\xab\x46\x90\x7f\x15"
2220         "\xf9\xda\xdb\xe4\x10\x1e\xc6\x82\xaa\x03\x4c\x7c\xeb\xc5\x9c\xfa\xea"
2221         "\x9e\xa9\x07\x6e\xde\x7f\x4a\xf1\x52\xe8\xb2\xfa\x9c\xb6" },
2222       { GCRY_MD_SHA384,
2223         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2224         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2225         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2226         "\xdd\xdd\xdd\xdd\xdd",
2227         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2228         "\xAA\xAA\xAA\xAA",
2229         "\x88\x06\x26\x08\xd3\xe6\xad\x8a\x0a\xa2\xac\xe0\x14\xc8\xa8\x6f"
2230         "\x0a\xa6\x35\xd9\x47\xac\x9f\xeb\xe8\x3e\xf4\xe5\x59\x66\x14\x4b"
2231         "\x2a\x5a\xb3\x9d\xc1\x38\x14\xb9\x4e\x3a\xb6\xe1\x01\xa3\x4f\x27" },
2232       { GCRY_MD_SHA384,
2233         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2234         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2235         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2236         "\xcd\xcd\xcd\xcd\xcd",
2237         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2238         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2239         "\x3e\x8a\x69\xb7\x78\x3c\x25\x85\x19\x33\xab\x62\x90\xaf\x6c\xa7"
2240         "\x7a\x99\x81\x48\x08\x50\x00\x9c\xc5\x57\x7c\x6e\x1f\x57\x3b\x4e"
2241         "\x68\x01\xdd\x23\xc4\xa7\xd6\x79\xcc\xf8\xa3\x86\xc6\x74\xcf\xfb" },
2242       { GCRY_MD_SHA384,
2243         "Test Using Larger Than Block-Size Key - Hash Key First",
2244         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2245         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2246         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2247         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2248         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2249         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2250         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2251         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2252         "\xaa\xaa\xaa",
2253         "\x4e\xce\x08\x44\x85\x81\x3e\x90\x88\xd2\xc6\x3a\x04\x1b\xc5\xb4"
2254         "\x4f\x9e\xf1\x01\x2a\x2b\x58\x8f\x3c\xd1\x1f\x05\x03\x3a\xc4\xc6"
2255         "\x0c\x2e\xf6\xab\x40\x30\xfe\x82\x96\x24\x8d\xf1\x63\xf4\x49\x52" },
2256       { GCRY_MD_SHA384,
2257         "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.",
2258         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2259         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2260         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2261         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2262         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2263         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2264         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2265         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2266         "\xaa\xaa\xaa",
2267         "\x66\x17\x17\x8e\x94\x1f\x02\x0d\x35\x1e\x2f\x25\x4e\x8f\xd3\x2c"
2268         "\x60\x24\x20\xfe\xb0\xb8\xfb\x9a\xdc\xce\xbb\x82\x46\x1e\x99\xc5"
2269         "\xa6\x78\xcc\x31\xe7\x99\x17\x6d\x38\x60\xe6\x11\x0c\x46\x52\x3e" },
2270       { GCRY_MD_SHA512, "what do ya want for nothing?", "Jefe",
2271         "\x16\x4b\x7a\x7b\xfc\xf8\x19\xe2\xe3\x95\xfb\xe7\x3b\x56\xe0\xa3"
2272         "\x87\xbd\x64\x22\x2e\x83\x1f\xd6\x10\x27\x0c\xd7\xea\x25\x05\x54"
2273         "\x97\x58\xbf\x75\xc0\x5a\x99\x4a\x6d\x03\x4f\x65\xf8\xf0\xe6\xfd"
2274         "\xca\xea\xb1\xa3\x4d\x4a\x6b\x4b\x63\x6e\x07\x0a\x38\xbc\xe7\x37" },
2275       { GCRY_MD_SHA512,
2276         "Hi There",
2277         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2278         "\x0b\x0b\x0b",
2279         "\x87\xaa\x7c\xde\xa5\xef\x61\x9d\x4f\xf0\xb4\x24\x1a\x1d\x6c\xb0"
2280         "\x23\x79\xf4\xe2\xce\x4e\xc2\x78\x7a\xd0\xb3\x05\x45\xe1\x7c\xde"
2281         "\xda\xa8\x33\xb7\xd6\xb8\xa7\x02\x03\x8b\x27\x4e\xae\xa3\xf4\xe4"
2282         "\xbe\x9d\x91\x4e\xeb\x61\xf1\x70\x2e\x69\x6c\x20\x3a\x12\x68\x54" },
2283       { GCRY_MD_SHA512,
2284         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2285         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2286         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2287         "\xdd\xdd\xdd\xdd\xdd",
2288         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2289         "\xAA\xAA\xAA\xAA",
2290         "\xfa\x73\xb0\x08\x9d\x56\xa2\x84\xef\xb0\xf0\x75\x6c\x89\x0b\xe9"
2291         "\xb1\xb5\xdb\xdd\x8e\xe8\x1a\x36\x55\xf8\x3e\x33\xb2\x27\x9d\x39"
2292         "\xbf\x3e\x84\x82\x79\xa7\x22\xc8\x06\xb4\x85\xa4\x7e\x67\xc8\x07"
2293         "\xb9\x46\xa3\x37\xbe\xe8\x94\x26\x74\x27\x88\x59\xe1\x32\x92\xfb"  },
2294       { GCRY_MD_SHA512,
2295         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2296         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2297         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2298         "\xcd\xcd\xcd\xcd\xcd",
2299         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2300         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2301         "\xb0\xba\x46\x56\x37\x45\x8c\x69\x90\xe5\xa8\xc5\xf6\x1d\x4a\xf7"
2302         "\xe5\x76\xd9\x7f\xf9\x4b\x87\x2d\xe7\x6f\x80\x50\x36\x1e\xe3\xdb"
2303         "\xa9\x1c\xa5\xc1\x1a\xa2\x5e\xb4\xd6\x79\x27\x5c\xc5\x78\x80\x63"
2304         "\xa5\xf1\x97\x41\x12\x0c\x4f\x2d\xe2\xad\xeb\xeb\x10\xa2\x98\xdd" },
2305       { GCRY_MD_SHA512,
2306         "Test Using Larger Than Block-Size Key - Hash Key First",
2307         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2308         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2309         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2310         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2311         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2312         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2313         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2314         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2315         "\xaa\xaa\xaa",
2316         "\x80\xb2\x42\x63\xc7\xc1\xa3\xeb\xb7\x14\x93\xc1\xdd\x7b\xe8\xb4"
2317         "\x9b\x46\xd1\xf4\x1b\x4a\xee\xc1\x12\x1b\x01\x37\x83\xf8\xf3\x52"
2318         "\x6b\x56\xd0\x37\xe0\x5f\x25\x98\xbd\x0f\xd2\x21\x5d\x6a\x1e\x52"
2319         "\x95\xe6\x4f\x73\xf6\x3f\x0a\xec\x8b\x91\x5a\x98\x5d\x78\x65\x98" },
2320       { GCRY_MD_SHA512,
2321         "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.",
2322         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2323         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2324         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2325         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2326         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2327         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2328         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2329         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2330         "\xaa\xaa\xaa",
2331         "\xe3\x7b\x6a\x77\x5d\xc8\x7d\xba\xa4\xdf\xa9\xf9\x6e\x5e\x3f\xfd"
2332         "\xde\xbd\x71\xf8\x86\x72\x89\x86\x5d\xf5\xa3\x2d\x20\xcd\xc9\x44"
2333         "\xb6\x02\x2c\xac\x3c\x49\x82\xb1\x0d\x5e\xeb\x55\xc3\xe4\xde\x15"
2334         "\x13\x46\x76\xfb\x6d\xe0\x44\x60\x65\xc9\x74\x40\xfa\x8c\x6a\x58" },
2335       { 0 },
2336     };
2337   int i;
2338
2339   if (verbose)
2340     fprintf (stderr, "Starting hashed MAC checks.\n");
2341
2342   for (i = 0; algos[i].md; i++)
2343     {
2344       if ((gcry_md_test_algo (algos[i].md) || algos[i].md == GCRY_MD_MD5)
2345           && in_fips_mode)
2346         {
2347           if (verbose)
2348             fprintf (stderr, "  algorithm %d not available in fips mode\n",
2349                      algos[i].md);
2350           continue;
2351         }
2352       if (verbose)
2353         fprintf (stderr,
2354                  "  checking %s [%i] for %zi byte key and %zi byte data\n",
2355                  gcry_md_algo_name (algos[i].md),
2356                  algos[i].md,
2357                  strlen(algos[i].key), strlen(algos[i].data));
2358
2359       check_one_hmac (algos[i].md, algos[i].data, strlen (algos[i].data),
2360                       algos[i].key, strlen(algos[i].key),
2361                       algos[i].expect);
2362     }
2363
2364   if (verbose)
2365     fprintf (stderr, "Completed hashed MAC checks.\n");
2366  }
2367
2368 /* Check that the signature SIG matches the hash HASH. PKEY is the
2369    public key used for the verification. BADHASH is a hash value which
2370    should result in a bad signature status. */
2371 static void
2372 verify_one_signature (gcry_sexp_t pkey, gcry_sexp_t hash,
2373                       gcry_sexp_t badhash, gcry_sexp_t sig)
2374 {
2375   gcry_error_t rc;
2376
2377   rc = gcry_pk_verify (sig, hash, pkey);
2378   if (rc)
2379     fail ("gcry_pk_verify failed: %s\n", gpg_strerror (rc));
2380   rc = gcry_pk_verify (sig, badhash, pkey);
2381   if (gcry_err_code (rc) != GPG_ERR_BAD_SIGNATURE)
2382     fail ("gcry_pk_verify failed to detect a bad signature: %s\n",
2383           gpg_strerror (rc));
2384 }
2385
2386
2387 /* Test the public key sign function using the private ket SKEY. PKEY
2388    is used for verification. */
2389 static void
2390 check_pubkey_sign (int n, gcry_sexp_t skey, gcry_sexp_t pkey, int algo)
2391 {
2392   gcry_error_t rc;
2393   gcry_sexp_t sig, badhash, hash;
2394   int dataidx;
2395   static const char baddata[] =
2396     "(data\n (flags pkcs1)\n"
2397     " (hash sha1 #11223344556677889900AABBCCDDEEFF10203041#))\n";
2398   static struct
2399   {
2400     const char *data;
2401     int algo;
2402     int expected_rc;
2403   } datas[] =
2404     {
2405       { "(data\n (flags pkcs1)\n"
2406         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
2407         GCRY_PK_RSA,
2408         0 },
2409       { "(data\n (flags oaep)\n"
2410         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
2411         0,
2412         GPG_ERR_CONFLICT },
2413       /* This test is to see whether hash algorithms not hard wired in
2414          pubkey.c are detected:  */
2415       { "(data\n (flags pkcs1)\n"
2416         " (hash oid.1.3.14.3.2.29 "
2417         "       #11223344556677889900AABBCCDDEEFF10203040#))\n",
2418         GCRY_PK_RSA,
2419         0 },
2420       { "(data\n (flags )\n"
2421         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
2422         0,
2423         GPG_ERR_CONFLICT },
2424       { "(data\n (flags pkcs1)\n"
2425         " (hash foo #11223344556677889900AABBCCDDEEFF10203040#))\n",
2426         GCRY_PK_RSA,
2427         GPG_ERR_DIGEST_ALGO },
2428       { "(data\n (flags )\n" " (value #11223344556677889900AA#))\n",
2429         0,
2430         0 },
2431       { "(data\n (flags )\n" " (value #0090223344556677889900AA#))\n",
2432         0,
2433         0 },
2434       { "(data\n (flags raw)\n" " (value #11223344556677889900AA#))\n",
2435         0,
2436         0 },
2437       { "(data\n (flags pkcs1)\n"
2438         " (value #11223344556677889900AA#))\n",
2439         GCRY_PK_RSA,
2440         GPG_ERR_CONFLICT },
2441       { "(data\n (flags raw foo)\n"
2442         " (value #11223344556677889900AA#))\n",
2443         0,
2444         GPG_ERR_INV_FLAG },
2445       { "(data\n (flags pss)\n"
2446         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
2447         GCRY_PK_RSA,
2448         0 },
2449       { "(data\n (flags pss)\n"
2450         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#)\n"
2451         " (random-override #4253647587980912233445566778899019283747#))\n",
2452         GCRY_PK_RSA,
2453         0 },
2454       { NULL }
2455     };
2456
2457   rc = gcry_sexp_sscan (&badhash, NULL, baddata, strlen (baddata));
2458   if (rc)
2459     die ("converting data failed: %s\n", gpg_strerror (rc));
2460
2461   for (dataidx = 0; datas[dataidx].data; dataidx++)
2462     {
2463       if (datas[dataidx].algo && datas[dataidx].algo != algo)
2464         continue;
2465
2466       if (verbose)
2467         fprintf (stderr, "  test %d, signature test %d\n", n, dataidx);
2468
2469       rc = gcry_sexp_sscan (&hash, NULL, datas[dataidx].data,
2470                             strlen (datas[dataidx].data));
2471       if (rc)
2472         die ("converting data failed: %s\n", gpg_strerror (rc));
2473
2474       rc = gcry_pk_sign (&sig, hash, skey);
2475       if (gcry_err_code (rc) != datas[dataidx].expected_rc)
2476         fail ("gcry_pk_sign failed: %s\n", gpg_strerror (rc));
2477
2478       if (!rc)
2479         verify_one_signature (pkey, hash, badhash, sig);
2480
2481       gcry_sexp_release (sig);
2482       sig = NULL;
2483       gcry_sexp_release (hash);
2484       hash = NULL;
2485     }
2486
2487   gcry_sexp_release (badhash);
2488 }
2489
2490
2491 /* Test the public key sign function using the private ket SKEY. PKEY
2492    is used for verification.  This variant is only used for ECDSA.  */
2493 static void
2494 check_pubkey_sign_ecdsa (int n, gcry_sexp_t skey, gcry_sexp_t pkey)
2495 {
2496   gcry_error_t rc;
2497   gcry_sexp_t sig, badhash, hash;
2498   unsigned int nbits;
2499   int dataidx;
2500   static struct
2501   {
2502     unsigned int nbits;
2503     const char *data;
2504     int expected_rc;
2505     const char *baddata;
2506     int dummy;
2507   } datas[] =
2508     {
2509       { 256,
2510         "(data (flags raw)\n"
2511         " (value #00112233445566778899AABBCCDDEEFF"
2512         /* */    "000102030405060708090A0B0C0D0E0F#))",
2513         0,
2514         "(data (flags raw)\n"
2515         " (value #80112233445566778899AABBCCDDEEFF"
2516         /* */    "000102030405060708090A0B0C0D0E0F#))",
2517         0
2518       },
2519       { 192,
2520         "(data (flags raw)\n"
2521         " (value #00112233445566778899AABBCCDDEEFF0001020304050607#))",
2522         0,
2523         "(data (flags raw)\n"
2524         " (value #80112233445566778899AABBCCDDEEFF0001020304050607#))",
2525         0
2526       },
2527       { 0, NULL }
2528     };
2529
2530   nbits = gcry_pk_get_nbits (skey);
2531
2532   for (dataidx = 0; datas[dataidx].data; dataidx++)
2533     {
2534       if (datas[dataidx].nbits != nbits)
2535         continue;
2536
2537       if (verbose)
2538         fprintf (stderr, "  test %d, signature test %d (%u bit ecdsa)\n",
2539                  n, dataidx, nbits);
2540
2541       rc = gcry_sexp_sscan (&hash, NULL, datas[dataidx].data,
2542                             strlen (datas[dataidx].data));
2543       if (rc)
2544         die ("converting data failed: %s\n", gpg_strerror (rc));
2545       rc = gcry_sexp_sscan (&badhash, NULL, datas[dataidx].baddata,
2546                             strlen (datas[dataidx].baddata));
2547       if (rc)
2548         die ("converting data failed: %s\n", gpg_strerror (rc));
2549
2550       rc = gcry_pk_sign (&sig, hash, skey);
2551       if (gcry_err_code (rc) != datas[dataidx].expected_rc)
2552         fail ("gcry_pk_sign failed: %s\n", gpg_strerror (rc));
2553
2554       if (!rc && verbose > 1)
2555         show_sexp ("ECDSA signature:\n", sig);
2556
2557       if (!rc)
2558         verify_one_signature (pkey, hash, badhash, sig);
2559
2560       gcry_sexp_release (sig);
2561       sig = NULL;
2562       gcry_sexp_release (badhash);
2563       badhash = NULL;
2564       gcry_sexp_release (hash);
2565       hash = NULL;
2566     }
2567 }
2568
2569
2570 static void
2571 check_pubkey_crypt (int n, gcry_sexp_t skey, gcry_sexp_t pkey, int algo)
2572 {
2573   gcry_error_t rc;
2574   gcry_sexp_t plain, ciph, data;
2575   int dataidx;
2576   static struct
2577   {
2578     int algo;    /* If not 0 run test only if ALGO matches.  */
2579     const char *data;
2580     const char *hint;
2581     int unpadded;
2582     int encrypt_expected_rc;
2583     int decrypt_expected_rc;
2584   } datas[] =
2585     {
2586       { GCRY_PK_RSA,
2587         "(data\n (flags pkcs1)\n"
2588         " (value #11223344556677889900AA#))\n",
2589         NULL,
2590         0,
2591         0,
2592         0 },
2593       { GCRY_PK_RSA,
2594         "(data\n (flags pkcs1)\n"
2595         " (value #11223344556677889900AA#))\n",
2596         "(flags pkcs1)",
2597         1,
2598         0,
2599         0 },
2600       { GCRY_PK_RSA,
2601         "(data\n (flags oaep)\n"
2602         " (value #11223344556677889900AA#))\n",
2603         "(flags oaep)",
2604         1,
2605         0,
2606         0 },
2607       { GCRY_PK_RSA,
2608         "(data\n (flags oaep)\n (hash-algo sha1)\n"
2609         " (value #11223344556677889900AA#))\n",
2610         "(flags oaep)(hash-algo sha1)",
2611         1,
2612         0,
2613         0 },
2614       { GCRY_PK_RSA,
2615         "(data\n (flags oaep)\n (hash-algo sha1)\n (label \"test\")\n"
2616         " (value #11223344556677889900AA#))\n",
2617         "(flags oaep)(hash-algo sha1)(label \"test\")",
2618         1,
2619         0,
2620         0 },
2621       { GCRY_PK_RSA,
2622         "(data\n (flags oaep)\n (hash-algo sha1)\n (label \"test\")\n"
2623         " (value #11223344556677889900AA#)\n"
2624         " (random-override #4253647587980912233445566778899019283747#))\n",
2625         "(flags oaep)(hash-algo sha1)(label \"test\")",
2626         1,
2627         0,
2628         0 },
2629       { 0,
2630         "(data\n (flags )\n" " (value #11223344556677889900AA#))\n",
2631         NULL,
2632         1,
2633         0,
2634         0 },
2635       { 0,
2636         "(data\n (flags )\n" " (value #0090223344556677889900AA#))\n",
2637         NULL,
2638         1,
2639         0,
2640         0 },
2641       { 0,
2642         "(data\n (flags raw)\n" " (value #11223344556677889900AA#))\n",
2643         NULL,
2644         1,
2645         0,
2646         0 },
2647       { GCRY_PK_RSA,
2648         "(data\n (flags pkcs1)\n"
2649         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
2650         NULL,
2651         0,
2652         GPG_ERR_CONFLICT,
2653         0},
2654       { 0,
2655         "(data\n (flags raw foo)\n"
2656         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
2657         NULL,
2658         0,
2659         GPG_ERR_INV_FLAG,
2660         0},
2661       { 0,
2662         "(data\n (flags raw)\n"
2663         " (value #11223344556677889900AA#))\n",
2664         "(flags oaep)",
2665         1,
2666         0,
2667         GPG_ERR_ENCODING_PROBLEM },
2668       { GCRY_PK_RSA,
2669         "(data\n (flags oaep)\n"
2670         " (value #11223344556677889900AA#))\n",
2671         "(flags pkcs1)",
2672         1,
2673         0,
2674         GPG_ERR_ENCODING_PROBLEM },
2675       { 0,
2676         "(data\n (flags pss)\n"
2677         " (value #11223344556677889900AA#))\n",
2678         NULL,
2679         0,
2680         GPG_ERR_CONFLICT },
2681       { 0, NULL }
2682     };
2683
2684   (void)n;
2685
2686   for (dataidx = 0; datas[dataidx].data; dataidx++)
2687     {
2688       if (datas[dataidx].algo && datas[dataidx].algo != algo)
2689         continue;
2690
2691       if (verbose)
2692         fprintf (stderr, "  encryption/decryption test %d (algo %d)\n",
2693                  dataidx, algo);
2694
2695       rc = gcry_sexp_sscan (&data, NULL, datas[dataidx].data,
2696                             strlen (datas[dataidx].data));
2697       if (rc)
2698         die ("converting data failed: %s\n", gpg_strerror (rc));
2699
2700       rc = gcry_pk_encrypt (&ciph, data, pkey);
2701       if (gcry_err_code (rc) != datas[dataidx].encrypt_expected_rc)
2702         fail ("gcry_pk_encrypt failed: %s\n", gpg_strerror (rc));
2703
2704       if (!rc)
2705         {
2706           /* Insert decoding hint to CIPH. */
2707           if (datas[dataidx].hint)
2708             {
2709               size_t hint_len, len;
2710               char *hint, *buf;
2711               gcry_sexp_t list;
2712
2713               /* Convert decoding hint into canonical sexp. */
2714               hint_len = gcry_sexp_new (&list, datas[dataidx].hint,
2715                                         strlen (datas[dataidx].hint), 1);
2716               hint_len = gcry_sexp_sprint (list, GCRYSEXP_FMT_CANON, NULL, 0);
2717               hint = gcry_malloc (hint_len);
2718               if (!hint)
2719                 die ("can't allocate memory\n");
2720               hint_len = gcry_sexp_sprint (list, GCRYSEXP_FMT_CANON, hint,
2721                                            hint_len);
2722               gcry_sexp_release (list);
2723
2724               /* Convert CIPH into canonical sexp. */
2725               len = gcry_sexp_sprint (ciph, GCRYSEXP_FMT_CANON, NULL, 0);
2726               buf = gcry_malloc (len + hint_len);
2727               if (!buf)
2728                 die ("can't allocate memory\n");
2729               len = gcry_sexp_sprint (ciph, GCRYSEXP_FMT_CANON, buf, len);
2730               /* assert (!strcmp (buf, "(7:enc-val", 10)); */
2731
2732               /* Copy decoding hint into CIPH. */
2733               memmove (buf + 10 + hint_len, buf + 10, len - 10);
2734               memcpy (buf + 10, hint, hint_len);
2735               gcry_free (hint);
2736               gcry_sexp_new (&list, buf, len + hint_len, 1);
2737               gcry_free (buf);
2738               gcry_sexp_release (ciph);
2739               ciph = list;
2740             }
2741           rc = gcry_pk_decrypt (&plain, ciph, skey);
2742           if (gcry_err_code (rc) != datas[dataidx].decrypt_expected_rc)
2743             fail ("gcry_pk_decrypt failed: %s\n", gpg_strerror (rc));
2744
2745           if (!rc && datas[dataidx].unpadded)
2746             {
2747               gcry_sexp_t p1, p2;
2748
2749               p1 = gcry_sexp_find_token (data, "value", 0);
2750               p2 = gcry_sexp_find_token (plain, "value", 0);
2751               if (p1 && p2)
2752                 {
2753                   const char *s1, *s2;
2754                   size_t n1, n2;
2755
2756                   s1 = gcry_sexp_nth_data (p1, 1, &n1);
2757                   s2 = gcry_sexp_nth_data (p2, 1, &n2);
2758                   if (n1 != n2 || memcmp (s1, s2, n1))
2759                     fail ("gcry_pk_encrypt/gcry_pk_decrypt do not roundtrip\n");
2760                 }
2761               gcry_sexp_release (p1);
2762               gcry_sexp_release (p2);
2763             }
2764         }
2765
2766       gcry_sexp_release (plain);
2767       plain = NULL;
2768       gcry_sexp_release (ciph);
2769       ciph = NULL;
2770       gcry_sexp_release (data);
2771       data = NULL;
2772     }
2773 }
2774
2775 static void
2776 check_pubkey_grip (int n, const unsigned char *grip,
2777                    gcry_sexp_t skey, gcry_sexp_t pkey, int algo)
2778 {
2779   unsigned char sgrip[20], pgrip[20];
2780
2781   (void)algo;
2782
2783   if (!gcry_pk_get_keygrip (skey, sgrip))
2784     die ("get keygrip for private RSA key failed\n");
2785   if (!gcry_pk_get_keygrip (pkey, pgrip))
2786     die ("[%i] get keygrip for public RSA key failed\n", n);
2787   if (memcmp (sgrip, pgrip, 20))
2788     fail ("[%i] keygrips don't match\n", n);
2789   if (memcmp (sgrip, grip, 20))
2790     fail ("wrong keygrip for RSA key\n");
2791 }
2792
2793 static void
2794 do_check_one_pubkey (int n, gcry_sexp_t skey, gcry_sexp_t pkey,
2795                      const unsigned char *grip, int algo, int flags)
2796 {
2797  if (flags & FLAG_SIGN)
2798    {
2799      if (algo == GCRY_PK_ECDSA)
2800        check_pubkey_sign_ecdsa (n, skey, pkey);
2801      else
2802        check_pubkey_sign (n, skey, pkey, algo);
2803    }
2804  if (flags & FLAG_CRYPT)
2805    check_pubkey_crypt (n, skey, pkey, algo);
2806  if (grip && (flags & FLAG_GRIP))
2807    check_pubkey_grip (n, grip, skey, pkey, algo);
2808 }
2809
2810 static void
2811 check_one_pubkey (int n, test_spec_pubkey_t spec)
2812 {
2813   gcry_error_t err = GPG_ERR_NO_ERROR;
2814   gcry_sexp_t skey, pkey;
2815
2816   err = gcry_sexp_sscan (&skey, NULL, spec.key.secret,
2817                          strlen (spec.key.secret));
2818   if (!err)
2819     err = gcry_sexp_sscan (&pkey, NULL, spec.key.public,
2820                            strlen (spec.key.public));
2821   if (err)
2822     die ("converting sample key failed: %s\n", gpg_strerror (err));
2823
2824   do_check_one_pubkey (n, skey, pkey,
2825                        (const unsigned char*)spec.key.grip,
2826                        spec.id, spec.flags);
2827
2828   gcry_sexp_release (skey);
2829   gcry_sexp_release (pkey);
2830 }
2831
2832 static void
2833 get_keys_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
2834 {
2835   gcry_sexp_t key_spec, key, pub_key, sec_key;
2836   int rc;
2837   if (verbose)
2838     fprintf (stderr, "  generating RSA key:");
2839   rc = gcry_sexp_new (&key_spec,
2840                       in_fips_mode ? "(genkey (rsa (nbits 4:1024)))"
2841                       : "(genkey (rsa (nbits 4:1024)(transient-key)))",
2842                       0, 1);
2843   if (rc)
2844     die ("error creating S-expression: %s\n", gpg_strerror (rc));
2845   rc = gcry_pk_genkey (&key, key_spec);
2846   gcry_sexp_release (key_spec);
2847   if (rc)
2848     die ("error generating RSA key: %s\n", gpg_strerror (rc));
2849
2850   pub_key = gcry_sexp_find_token (key, "public-key", 0);
2851   if (! pub_key)
2852     die ("public part missing in key\n");
2853
2854   sec_key = gcry_sexp_find_token (key, "private-key", 0);
2855   if (! sec_key)
2856     die ("private part missing in key\n");
2857
2858   gcry_sexp_release (key);
2859   *pkey = pub_key;
2860   *skey = sec_key;
2861 }
2862
2863 static void
2864 check_one_pubkey_new (int n)
2865 {
2866   gcry_sexp_t skey, pkey;
2867
2868   get_keys_new (&pkey, &skey);
2869   do_check_one_pubkey (n, skey, pkey, NULL,
2870                        GCRY_PK_RSA, FLAG_SIGN | FLAG_CRYPT);
2871   gcry_sexp_release (pkey);
2872   gcry_sexp_release (skey);
2873 }
2874
2875 /* Run all tests for the public key functions. */
2876 static void
2877 check_pubkey (void)
2878 {
2879   test_spec_pubkey_t pubkeys[] = {
2880   {
2881     GCRY_PK_RSA, FLAG_CRYPT | FLAG_SIGN,
2882     {
2883       "(private-key\n"
2884       " (rsa\n"
2885       "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
2886       "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
2887       "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
2888       "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea2"
2889       "      51#)\n"
2890       "  (e #010001#)\n"
2891       "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
2892       "      7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
2893       "      C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
2894       "      C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781"
2895       "      #)\n"
2896       "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
2897       "      fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424"
2898       "      f1#)\n"
2899       "  (q #00f7a7ca5367c661f8e62df34f0d05c10c88e5492348dd7bddc942c9a8f369f9"
2900       "      35a07785d2db805215ed786e4285df1658eed3ce84f469b81b50d358407b4ad3"
2901       "      61#)\n"
2902       "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
2903       "      ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b"
2904       "      #)))\n",
2905
2906       "(public-key\n"
2907       " (rsa\n"
2908       "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
2909       "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
2910       "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
2911       "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea2"
2912       "      51#)\n"
2913       "  (e #010001#)))\n",
2914
2915       "\x32\x10\x0c\x27\x17\x3e\xf6\xe9\xc4\xe9"
2916       "\xa2\x5d\x3d\x69\xf8\x6d\x37\xa4\xf9\x39"}
2917   },
2918   {
2919     GCRY_PK_DSA, FLAG_SIGN,
2920     {
2921       "(private-key\n"
2922       " (DSA\n"
2923       "  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
2924       "      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
2925       "      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
2926       "      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D877"
2927       "      7B#)\n"
2928       "  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)\n"
2929       "  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
2930       "      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
2931       "      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
2932       "      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15"
2933       "      #)\n"
2934       "  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
2935       "      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
2936       "      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
2937       "      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB"
2938       "      #)\n"
2939       "  (x #11D54E4ADBD3034160F2CED4B7CD292A4EBF3EC0#)))\n",
2940
2941       "(public-key\n"
2942       " (DSA\n"
2943       "  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
2944       "      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
2945       "      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
2946       "      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D877"
2947       "      7B#)\n"
2948       "  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)\n"
2949       "  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
2950       "      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
2951       "      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
2952       "      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15"
2953       "      #)\n"
2954       "  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
2955       "      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
2956       "      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
2957       "      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB"
2958       "      #)))\n",
2959
2960       "\xc6\x39\x83\x1a\x43\xe5\x05\x5d\xc6\xd8"
2961       "\x4a\xa6\xf9\xeb\x23\xbf\xa9\x12\x2d\x5b" }
2962   },
2963   {
2964     GCRY_PK_ELG, FLAG_SIGN | FLAG_CRYPT,
2965     {
2966       "(private-key\n"
2967       " (ELG\n"
2968       "  (p #00B93B93386375F06C2D38560F3B9C6D6D7B7506B20C1773F73F8DE56E6CD65D"
2969       "      F48DFAAA1E93F57A2789B168362A0F787320499F0B2461D3A4268757A7B27517"
2970       "      B7D203654A0CD484DEC6AF60C85FEB84AAC382EAF2047061FE5DAB81A20A0797"
2971       "      6E87359889BAE3B3600ED718BE61D4FC993CC8098A703DD0DC942E965E8F18D2"
2972       "      A7#)\n"
2973       "  (g #05#)\n"
2974       "  (y #72DAB3E83C9F7DD9A931FDECDC6522C0D36A6F0A0FEC955C5AC3C09175BBFF2B"
2975       "      E588DB593DC2E420201BEB3AC17536918417C497AC0F8657855380C1FCF11C5B"
2976       "      D20DB4BEE9BDF916648DE6D6E419FA446C513AAB81C30CB7B34D6007637BE675"
2977       "      56CE6473E9F9EE9B9FADD275D001563336F2186F424DEC6199A0F758F6A00FF4"
2978       "      #)\n"
2979       "  (x #03C28900087B38DABF4A0AB98ACEA39BB674D6557096C01D72E31C16BDD32214"
2980       "      #)))\n",
2981
2982       "(public-key\n"
2983       " (ELG\n"
2984       "  (p #00B93B93386375F06C2D38560F3B9C6D6D7B7506B20C1773F73F8DE56E6CD65D"
2985       "      F48DFAAA1E93F57A2789B168362A0F787320499F0B2461D3A4268757A7B27517"
2986       "      B7D203654A0CD484DEC6AF60C85FEB84AAC382EAF2047061FE5DAB81A20A0797"
2987       "      6E87359889BAE3B3600ED718BE61D4FC993CC8098A703DD0DC942E965E8F18D2"
2988       "      A7#)\n"
2989       "  (g #05#)\n"
2990       "  (y #72DAB3E83C9F7DD9A931FDECDC6522C0D36A6F0A0FEC955C5AC3C09175BBFF2B"
2991       "      E588DB593DC2E420201BEB3AC17536918417C497AC0F8657855380C1FCF11C5B"
2992       "      D20DB4BEE9BDF916648DE6D6E419FA446C513AAB81C30CB7B34D6007637BE675"
2993       "      56CE6473E9F9EE9B9FADD275D001563336F2186F424DEC6199A0F758F6A00FF4"
2994       "      #)))\n",
2995
2996       "\xa7\x99\x61\xeb\x88\x83\xd2\xf4\x05\xc8"
2997       "\x4f\xba\x06\xf8\x78\x09\xbc\x1e\x20\xe5" }
2998   },
2999   { /* ECDSA test.  */
3000     GCRY_PK_ECDSA, FLAG_SIGN,
3001     {
3002       "(private-key\n"
3003       " (ecdsa\n"
3004       "  (curve nistp192)\n"
3005       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3006       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
3007       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
3008
3009       "(public-key\n"
3010       " (ecdsa\n"
3011       "  (curve nistp192)\n"
3012       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3013       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
3014
3015       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3016       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
3017   },
3018   { /* ECDSA test with the public key algorithm given as "ecc".  */
3019     GCRY_PK_ECDSA, FLAG_SIGN,
3020     {
3021       "(private-key\n"
3022       " (ecdsa\n"
3023       "  (curve nistp192)\n"
3024       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3025       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
3026       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
3027
3028       "(public-key\n"
3029       " (ecc\n"
3030       "  (curve nistp192)\n"
3031       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3032       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
3033
3034       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3035       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
3036   },
3037   { /* ECDSA test with the private key algorithm given as "ecc".  */
3038     GCRY_PK_ECDSA, FLAG_SIGN,
3039     {
3040       "(private-key\n"
3041       " (ecc\n"
3042       "  (curve nistp192)\n"
3043       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3044       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
3045       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
3046
3047       "(public-key\n"
3048       " (ecdsa\n"
3049       "  (curve nistp192)\n"
3050       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3051       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
3052
3053       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3054       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
3055   },
3056   { /* ECDSA test with the key algorithms given as "ecc".  */
3057     GCRY_PK_ECDSA, FLAG_SIGN,
3058     {
3059       "(private-key\n"
3060       " (ecc\n"
3061       "  (curve nistp192)\n"
3062       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3063       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
3064       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
3065
3066       "(public-key\n"
3067       " (ecc\n"
3068       "  (curve nistp192)\n"
3069       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3070       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
3071
3072       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3073       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
3074   },
3075   { /* ECDSA test 256 bit.  */
3076     GCRY_PK_ECDSA, FLAG_SIGN,
3077     {
3078       "(private-key\n"
3079       " (ecc\n"
3080       "  (curve nistp256)\n"
3081       "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2B"
3082       "      EB6644D3609FC781B71F9A8072F58CB66AE2F89BB1245187"
3083       "      3ABF7D91F9E1FBF96BF2F70E73AAC9A283#)\n"
3084       "  (d #5A1EF0035118F19F3110FB81813D3547BCE1E5BCE77D1F74"
3085       "      4715E1D5BBE70378#)))\n",
3086
3087       "(public-key\n"
3088       " (ecc\n"
3089       "  (curve nistp256)\n"
3090       "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2B"
3091       "      EB6644D3609FC781B71F9A8072F58CB66AE2F89BB1245187"
3092       "      3ABF7D91F9E1FBF96BF2F70E73AAC9A283#)))\n"
3093
3094       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3095       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
3096     }
3097   };
3098   int i;
3099
3100   if (verbose)
3101     fprintf (stderr, "Starting public key checks.\n");
3102   for (i = 0; i < sizeof (pubkeys) / sizeof (*pubkeys); i++)
3103     if (pubkeys[i].id)
3104       {
3105         if (gcry_pk_test_algo (pubkeys[i].id) && in_fips_mode)
3106           {
3107             if (verbose)
3108               fprintf (stderr, "  algorithm %d not available in fips mode\n",
3109                        pubkeys[i].id);
3110             continue;
3111           }
3112         check_one_pubkey (i, pubkeys[i]);
3113       }
3114   if (verbose)
3115     fprintf (stderr, "Completed public key checks.\n");
3116
3117   if (verbose)
3118     fprintf (stderr, "Starting additional public key checks.\n");
3119   for (i = 0; i < sizeof (pubkeys) / sizeof (*pubkeys); i++)
3120     if (pubkeys[i].id)
3121       {
3122         if (gcry_pk_test_algo (pubkeys[i].id) && in_fips_mode)
3123           {
3124             if (verbose)
3125               fprintf (stderr, "  algorithm %d not available in fips mode\n",
3126                        pubkeys[i].id);
3127             continue;
3128           }
3129         check_one_pubkey_new (i);
3130       }
3131   if (verbose)
3132     fprintf (stderr, "Completed additional public key checks.\n");
3133
3134 }
3135
3136 int
3137 main (int argc, char **argv)
3138 {
3139   gpg_error_t err;
3140   int last_argc = -1;
3141   int debug = 0;
3142   int use_fips = 0;
3143   int selftest_only = 0;
3144
3145   if (argc)
3146     { argc--; argv++; }
3147
3148   while (argc && last_argc != argc )
3149     {
3150       last_argc = argc;
3151       if (!strcmp (*argv, "--"))
3152         {
3153           argc--; argv++;
3154           break;
3155         }
3156       else if (!strcmp (*argv, "--verbose"))
3157         {
3158           verbose++;
3159           argc--; argv++;
3160         }
3161       else if (!strcmp (*argv, "--debug"))
3162         {
3163           verbose = debug = 1;
3164           argc--; argv++;
3165         }
3166       else if (!strcmp (*argv, "--fips"))
3167         {
3168           use_fips = 1;
3169           argc--; argv++;
3170         }
3171       else if (!strcmp (*argv, "--selftest"))
3172         {
3173           selftest_only = 1;
3174           verbose += 2;
3175           argc--; argv++;
3176         }
3177       else if (!strcmp (*argv, "--die"))
3178         {
3179           die_on_error = 1;
3180           argc--; argv++;
3181         }
3182     }
3183
3184   gcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
3185
3186   if (use_fips)
3187     gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
3188
3189   /* Check that we test exactly our version - including the patchlevel.  */
3190   if (strcmp (GCRYPT_VERSION, gcry_check_version (NULL)))
3191     die ("version mismatch; pgm=%s, library=%s\n",
3192          GCRYPT_VERSION,gcry_check_version (NULL));
3193
3194   if ( gcry_fips_mode_active () )
3195     in_fips_mode = 1;
3196
3197   if (!in_fips_mode)
3198     gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
3199
3200   if (verbose)
3201     gcry_set_progress_handler (progress_handler, NULL);
3202
3203   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
3204   if (debug)
3205     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
3206   /* No valuable keys are create, so we can speed up our RNG. */
3207   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
3208
3209   if (!selftest_only)
3210     {
3211       check_ciphers ();
3212       check_cipher_modes ();
3213       check_bulk_cipher_modes ();
3214       check_digests ();
3215       check_hmac ();
3216       check_pubkey ();
3217     }
3218
3219
3220   if (in_fips_mode && !selftest_only)
3221     {
3222       /* If we are in fips mode do some more tests. */
3223       gcry_md_hd_t md;
3224
3225       /* First trigger a self-test.  */
3226       gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
3227       if (!gcry_control (GCRYCTL_OPERATIONAL_P, 0))
3228         fail ("not in operational state after self-test\n");
3229
3230       /* Get us into the error state.  */
3231       err = gcry_md_open (&md, GCRY_MD_SHA1, 0);
3232       if (err)
3233         fail ("failed to open SHA-1 hash context: %s\n", gpg_strerror (err));
3234       else
3235         {
3236           err = gcry_md_enable (md, GCRY_MD_SHA256);
3237           if (err)
3238             fail ("failed to add SHA-256 hash context: %s\n",
3239                   gpg_strerror (err));
3240           else
3241             {
3242               /* gcry_md_get_algo is only defined for a context with
3243                  just one digest algorithm.  With our setup it should
3244                  put the oibrary intoerror state.  */
3245               fputs ("Note: Two lines with error messages follow "
3246                      "- this is expected\n", stderr);
3247               gcry_md_get_algo (md);
3248               gcry_md_close (md);
3249               if (gcry_control (GCRYCTL_OPERATIONAL_P, 0))
3250                 fail ("expected error state but still in operational state\n");
3251               else
3252                 {
3253                   /* Now run a self-test and to get back into
3254                      operational state.  */
3255                   gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
3256                   if (!gcry_control (GCRYCTL_OPERATIONAL_P, 0))
3257                     fail ("did not reach operational after error "
3258                           "and self-test\n");
3259                 }
3260             }
3261         }
3262
3263     }
3264   else
3265     {
3266       /* If in standard mode, run selftests.  */
3267       if (gcry_control (GCRYCTL_SELFTEST, 0))
3268         fail ("running self-test failed\n");
3269     }
3270
3271   if (verbose)
3272     fprintf (stderr, "\nAll tests completed. Errors: %i\n", error_count);
3273
3274   if (in_fips_mode && !gcry_fips_mode_active ())
3275     fprintf (stderr, "FIPS mode is not anymore active\n");
3276
3277   return error_count ? 1 : 0;
3278 }