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