Add support for 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 #endif /*USE_SALSA20*/
1246   };
1247
1248   gcry_cipher_hd_t hde, hdd;
1249   unsigned char out[MAX_DATA_LEN];
1250   int i, j;
1251   gcry_error_t err = 0;
1252
1253
1254   if (verbose)
1255     fprintf (stderr, "  Starting stream cipher checks.\n");
1256
1257   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
1258     {
1259       if (verbose)
1260         fprintf (stderr, "    checking stream mode for %s [%i] (%s)\n",
1261                  gcry_cipher_algo_name (tv[i].algo), tv[i].algo, tv[i].name);
1262
1263       if (gcry_cipher_get_algo_blklen(tv[i].algo) != 1)
1264         {
1265           fail ("stream, gcry_cipher_get_algo_blklen: bad block length\n");
1266           continue;
1267         }
1268
1269       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_STREAM, 0);
1270       if (!err)
1271         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_STREAM, 0);
1272       if (err)
1273         {
1274           fail ("stream, gcry_cipher_open for stream mode failed: %s\n",
1275                 gpg_strerror (err));
1276           continue;
1277         }
1278
1279       /* Now loop over all the data samples.  */
1280       for (j = 0; tv[i].data[j].inlen; j++)
1281         {
1282           err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
1283           if (!err)
1284             err = gcry_cipher_setkey (hdd, tv[i].key, tv[i].keylen);
1285           if (err)
1286             {
1287               fail ("stream, gcry_cipher_setkey failed: %s\n",
1288                     gpg_strerror (err));
1289               goto next;
1290             }
1291
1292           err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
1293           if (!err)
1294             err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
1295           if (err)
1296             {
1297               fail ("stream, gcry_cipher_setiv failed: %s\n",
1298                     gpg_strerror (err));
1299               goto next;
1300             }
1301
1302           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
1303                                      tv[i].data[j].plaintext,
1304                                      tv[i].data[j].inlen);
1305           if (err)
1306             {
1307               fail ("stream, gcry_cipher_encrypt (%d, %d) failed: %s\n",
1308                     i, j, gpg_strerror (err));
1309               goto next;
1310             }
1311
1312           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
1313             {
1314               fail ("stream, encrypt mismatch entry %d:%d\n", i, j);
1315               mismatch (tv[i].data[j].out, tv[i].data[j].inlen,
1316                         out, tv[i].data[j].inlen);
1317             }
1318
1319           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
1320           if (err)
1321             {
1322               fail ("stream, gcry_cipher_decrypt (%d, %d) failed: %s\n",
1323                     i, j, gpg_strerror (err));
1324               goto next;
1325             }
1326
1327           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
1328             fail ("stream, decrypt mismatch entry %d:%d\n", i, j);
1329         }
1330
1331
1332       /* This time we encrypt and decrypt one byte at a time */
1333       for (j = 0; tv[i].data[j].inlen; j++)
1334         {
1335           int byteNum;
1336
1337           err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
1338           if (!err)
1339             err = gcry_cipher_setkey (hdd, tv[i].key, tv[i].keylen);
1340           if (err)
1341             {
1342               fail ("stream, gcry_cipher_setkey failed: %s\n",
1343                     gpg_strerror (err));
1344               goto next;
1345             }
1346
1347           err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
1348           if (!err)
1349             err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
1350           if (err)
1351             {
1352               fail ("stream, gcry_cipher_setiv failed: %s\n",
1353                     gpg_strerror (err));
1354               goto next;
1355             }
1356
1357           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
1358             {
1359               err = gcry_cipher_encrypt (hde, out+byteNum, 1,
1360                                          (tv[i].data[j].plaintext) + byteNum,
1361                                          1);
1362               if (err)
1363                 {
1364                   fail ("stream, gcry_cipher_encrypt (%d, %d) failed: %s\n",
1365                         i, j, gpg_strerror (err));
1366                   goto next;
1367                 }
1368             }
1369
1370           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
1371             fail ("stream, encrypt mismatch entry %d:%d (byte-wise)\n", i, j);
1372
1373           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
1374             {
1375               err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
1376               if (err)
1377                 {
1378                   fail ("stream, gcry_cipher_decrypt (%d, %d) failed: %s\n",
1379                         i, j, gpg_strerror (err));
1380                   goto next;
1381                 }
1382             }
1383
1384           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
1385             fail ("stream, decrypt mismatch entry %d:%d (byte-wise)\n", i, j);
1386         }
1387
1388     next:
1389       gcry_cipher_close (hde);
1390       gcry_cipher_close (hdd);
1391     }
1392   if (verbose)
1393     fprintf (stderr, "  Completed stream cipher checks.\n");
1394 }
1395
1396
1397 static void
1398 check_stream_cipher_large_block (void)
1399 {
1400   struct tv
1401   {
1402     const char *name;
1403     int algo;
1404     int keylen;
1405     int ivlen;
1406     const char *key;
1407     const char *iv;
1408     struct data
1409     {
1410       int offset, length;
1411       const char *result;
1412     } data[MAX_DATA_LEN];
1413   } tv[] = {
1414 #ifdef USE_SALSA20
1415     {
1416       "Salsa20 256 bit, ecrypt verified, set 6, vector 0",
1417       GCRY_CIPHER_SALSA20, 32, 8,
1418       "\x00\x53\xA6\xF9\x4C\x9F\xF2\x45\x98\xEB\x3E\x91\xE4\x37\x8A\xDD"
1419       "\x30\x83\xD6\x29\x7C\xCF\x22\x75\xC8\x1B\x6E\xC1\x14\x67\xBA\x0D",
1420       "\x0D\x74\xDB\x42\xA9\x10\x77\xDE",
1421       {
1422         { 0, 64,
1423           "\xF5\xFA\xD5\x3F\x79\xF9\xDF\x58\xC4\xAE\xA0\xD0\xED\x9A\x96\x01"
1424           "\xF2\x78\x11\x2C\xA7\x18\x0D\x56\x5B\x42\x0A\x48\x01\x96\x70\xEA"
1425           "\xF2\x4C\xE4\x93\xA8\x62\x63\xF6\x77\xB4\x6A\xCE\x19\x24\x77\x3D"
1426           "\x2B\xB2\x55\x71\xE1\xAA\x85\x93\x75\x8F\xC3\x82\xB1\x28\x0B\x71"
1427         },
1428         { 65472, 64,
1429          "\xB7\x0C\x50\x13\x9C\x63\x33\x2E\xF6\xE7\x7A\xC5\x43\x38\xA4\x07"
1430          "\x9B\x82\xBE\xC9\xF9\xA4\x03\xDF\xEA\x82\x1B\x83\xF7\x86\x07\x91"
1431          "\x65\x0E\xF1\xB2\x48\x9D\x05\x90\xB1\xDE\x77\x2E\xED\xA4\xE3\xBC"
1432          "\xD6\x0F\xA7\xCE\x9C\xD6\x23\xD9\xD2\xFD\x57\x58\xB8\x65\x3E\x70"
1433         },
1434         { 65536, 64,
1435          "\x81\x58\x2C\x65\xD7\x56\x2B\x80\xAE\xC2\xF1\xA6\x73\xA9\xD0\x1C"
1436          "\x9F\x89\x2A\x23\xD4\x91\x9F\x6A\xB4\x7B\x91\x54\xE0\x8E\x69\x9B"
1437          "\x41\x17\xD7\xC6\x66\x47\x7B\x60\xF8\x39\x14\x81\x68\x2F\x5D\x95"
1438          "\xD9\x66\x23\xDB\xC4\x89\xD8\x8D\xAA\x69\x56\xB9\xF0\x64\x6B\x6E"
1439         },
1440         { 131008, 64,
1441          "\xA1\x3F\xFA\x12\x08\xF8\xBF\x50\x90\x08\x86\xFA\xAB\x40\xFD\x10"
1442          "\xE8\xCA\xA3\x06\xE6\x3D\xF3\x95\x36\xA1\x56\x4F\xB7\x60\xB2\x42"
1443          "\xA9\xD6\xA4\x62\x8C\xDC\x87\x87\x62\x83\x4E\x27\xA5\x41\xDA\x2A"
1444          "\x5E\x3B\x34\x45\x98\x9C\x76\xF6\x11\xE0\xFE\xC6\xD9\x1A\xCA\xCC"
1445         }
1446       }
1447     },
1448     {
1449       "Salsa20 256 bit, ecrypt verified, set 6, vector 1",
1450       GCRY_CIPHER_SALSA20, 32, 8,
1451       "\x05\x58\xAB\xFE\x51\xA4\xF7\x4A\x9D\xF0\x43\x96\xE9\x3C\x8F\xE2"
1452       "\x35\x88\xDB\x2E\x81\xD4\x27\x7A\xCD\x20\x73\xC6\x19\x6C\xBF\x12",
1453       "\x16\x7D\xE4\x4B\xB2\x19\x80\xE7",
1454       {
1455         { 0, 64,
1456           "\x39\x44\xF6\xDC\x9F\x85\xB1\x28\x08\x38\x79\xFD\xF1\x90\xF7\xDE"
1457           "\xE4\x05\x3A\x07\xBC\x09\x89\x6D\x51\xD0\x69\x0B\xD4\xDA\x4A\xC1"
1458           "\x06\x2F\x1E\x47\xD3\xD0\x71\x6F\x80\xA9\xB4\xD8\x5E\x6D\x60\x85"
1459           "\xEE\x06\x94\x76\x01\xC8\x5F\x1A\x27\xA2\xF7\x6E\x45\xA6\xAA\x87"
1460         },
1461         { 65472, 64,
1462           "\x36\xE0\x3B\x4B\x54\xB0\xB2\xE0\x4D\x06\x9E\x69\x00\x82\xC8\xC5"
1463           "\x92\xDF\x56\xE6\x33\xF5\xD8\xC7\x68\x2A\x02\xA6\x5E\xCD\x13\x71"
1464           "\x8C\xA4\x35\x2A\xAC\xCB\x0D\xA2\x0E\xD6\xBB\xBA\x62\xE1\x77\xF2"
1465           "\x10\xE3\x56\x0E\x63\xBB\x82\x2C\x41\x58\xCA\xA8\x06\xA8\x8C\x82"
1466         },
1467         { 65536, 64,
1468           "\x1B\x77\x9E\x7A\x91\x7C\x8C\x26\x03\x9F\xFB\x23\xCF\x0E\xF8\xE0"
1469           "\x8A\x1A\x13\xB4\x3A\xCD\xD9\x40\x2C\xF5\xDF\x38\x50\x10\x98\xDF"
1470           "\xC9\x45\xA6\xCC\x69\xA6\xA1\x73\x67\xBC\x03\x43\x1A\x86\xB3\xED"
1471           "\x04\xB0\x24\x5B\x56\x37\x9B\xF9\x97\xE2\x58\x00\xAD\x83\x7D\x7D"
1472         },
1473         { 131008, 64,
1474           "\x7E\xC6\xDA\xE8\x1A\x10\x5E\x67\x17\x2A\x0B\x8C\x4B\xBE\x7D\x06"
1475           "\xA7\xA8\x75\x9F\x91\x4F\xBE\xB1\xAF\x62\xC8\xA5\x52\xEF\x4A\x4F"
1476           "\x56\x96\x7E\xA2\x9C\x74\x71\xF4\x6F\x3B\x07\xF7\xA3\x74\x6E\x95"
1477           "\x3D\x31\x58\x21\xB8\x5B\x6E\x8C\xB4\x01\x22\xB9\x66\x35\x31\x3C"
1478         }
1479       }
1480     },
1481     {
1482       "Salsa20 256 bit, ecrypt verified, set 6, vector 2",
1483       GCRY_CIPHER_SALSA20, 32, 8,
1484       "\x0A\x5D\xB0\x03\x56\xA9\xFC\x4F\xA2\xF5\x48\x9B\xEE\x41\x94\xE7"
1485       "\x3A\x8D\xE0\x33\x86\xD9\x2C\x7F\xD2\x25\x78\xCB\x1E\x71\xC4\x17",
1486       "\x1F\x86\xED\x54\xBB\x22\x89\xF0",
1487       {
1488         { 0, 64,
1489           "\x3F\xE8\x5D\x5B\xB1\x96\x0A\x82\x48\x0B\x5E\x6F\x4E\x96\x5A\x44"
1490           "\x60\xD7\xA5\x45\x01\x66\x4F\x7D\x60\xB5\x4B\x06\x10\x0A\x37\xFF"
1491           "\xDC\xF6\xBD\xE5\xCE\x3F\x48\x86\xBA\x77\xDD\x5B\x44\xE9\x56\x44"
1492           "\xE4\x0A\x8A\xC6\x58\x01\x15\x5D\xB9\x0F\x02\x52\x2B\x64\x40\x23"
1493         },
1494         { 65472, 64,
1495           "\xC8\xD6\xE5\x4C\x29\xCA\x20\x40\x18\xA8\x30\xE2\x66\xCE\xEE\x0D"
1496           "\x03\x7D\xC4\x7E\x92\x19\x47\x30\x2A\xCE\x40\xD1\xB9\x96\xA6\xD8"
1497           "\x0B\x59\x86\x77\xF3\x35\x2F\x1D\xAA\x6D\x98\x88\xF8\x91\xAD\x95"
1498           "\xA1\xC3\x2F\xFE\xB7\x1B\xB8\x61\xE8\xB0\x70\x58\x51\x51\x71\xC9"
1499         },
1500         { 65536, 64,
1501           "\xB7\x9F\xD7\x76\x54\x2B\x46\x20\xEF\xCB\x88\x44\x95\x99\xF2\x34"
1502           "\x03\xE7\x4A\x6E\x91\xCA\xCC\x50\xA0\x5A\x8F\x8F\x3C\x0D\xEA\x8B"
1503           "\x00\xE1\xA5\xE6\x08\x1F\x55\x26\xAE\x97\x5B\x3B\xC0\x45\x0F\x1A"
1504           "\x0C\x8B\x66\xF8\x08\xF1\x90\x4B\x97\x13\x61\x13\x7C\x93\x15\x6F"
1505         },
1506         { 131008, 64,
1507           "\x79\x98\x20\x4F\xED\x70\xCE\x8E\x0D\x02\x7B\x20\x66\x35\xC0\x8C"
1508           "\x8B\xC4\x43\x62\x26\x08\x97\x0E\x40\xE3\xAE\xDF\x3C\xE7\x90\xAE"
1509           "\xED\xF8\x9F\x92\x26\x71\xB4\x53\x78\xE2\xCD\x03\xF6\xF6\x23\x56"
1510           "\x52\x9C\x41\x58\xB7\xFF\x41\xEE\x85\x4B\x12\x35\x37\x39\x88\xC8"
1511         }
1512       }
1513     },
1514     {
1515       "Salsa20 256 bit, ecrypt verified, set 6, vector 3",
1516       GCRY_CIPHER_SALSA20, 32, 8,
1517       "\x0F\x62\xB5\x08\x5B\xAE\x01\x54\xA7\xFA\x4D\xA0\xF3\x46\x99\xEC"
1518       "\x3F\x92\xE5\x38\x8B\xDE\x31\x84\xD7\x2A\x7D\xD0\x23\x76\xC9\x1C",
1519       "\x28\x8F\xF6\x5D\xC4\x2B\x92\xF9",
1520       {
1521         { 0, 64,
1522           "\x5E\x5E\x71\xF9\x01\x99\x34\x03\x04\xAB\xB2\x2A\x37\xB6\x62\x5B"
1523           "\xF8\x83\xFB\x89\xCE\x3B\x21\xF5\x4A\x10\xB8\x10\x66\xEF\x87\xDA"
1524           "\x30\xB7\x76\x99\xAA\x73\x79\xDA\x59\x5C\x77\xDD\x59\x54\x2D\xA2"
1525           "\x08\xE5\x95\x4F\x89\xE4\x0E\xB7\xAA\x80\xA8\x4A\x61\x76\x66\x3F"
1526         },
1527         { 65472, 64,
1528           "\x2D\xA2\x17\x4B\xD1\x50\xA1\xDF\xEC\x17\x96\xE9\x21\xE9\xD6\xE2"
1529           "\x4E\xCF\x02\x09\xBC\xBE\xA4\xF9\x83\x70\xFC\xE6\x29\x05\x6F\x64"
1530           "\x91\x72\x83\x43\x6E\x2D\x3F\x45\x55\x62\x25\x30\x7D\x5C\xC5\xA5"
1531           "\x65\x32\x5D\x89\x93\xB3\x7F\x16\x54\x19\x5C\x24\x0B\xF7\x5B\x16"
1532         },
1533         { 65536, 64,
1534           "\xAB\xF3\x9A\x21\x0E\xEE\x89\x59\x8B\x71\x33\x37\x70\x56\xC2\xFE"
1535           "\xF4\x2D\xA7\x31\x32\x75\x63\xFB\x67\xC7\xBE\xDB\x27\xF3\x8C\x7C"
1536           "\x5A\x3F\xC2\x18\x3A\x4C\x6B\x27\x7F\x90\x11\x52\x47\x2C\x6B\x2A"
1537           "\xBC\xF5\xE3\x4C\xBE\x31\x5E\x81\xFD\x3D\x18\x0B\x5D\x66\xCB\x6C"
1538         },
1539         { 131008, 64,
1540           "\x1B\xA8\x9D\xBD\x3F\x98\x83\x97\x28\xF5\x67\x91\xD5\xB7\xCE\x23"
1541           "\x50\x36\xDE\x84\x3C\xCC\xAB\x03\x90\xB8\xB5\x86\x2F\x1E\x45\x96"
1542           "\xAE\x8A\x16\xFB\x23\xDA\x99\x7F\x37\x1F\x4E\x0A\xAC\xC2\x6D\xB8"
1543           "\xEB\x31\x4E\xD4\x70\xB1\xAF\x6B\x9F\x8D\x69\xDD\x79\xA9\xD7\x50"
1544         }
1545       }
1546     }
1547 #endif /*USE_SALSA20*/
1548   };
1549
1550
1551   char zeroes[512];
1552   gcry_cipher_hd_t hde;
1553   unsigned char *buffer;
1554   unsigned char *p;
1555   size_t buffersize;
1556   unsigned int n;
1557   int i, j;
1558   gcry_error_t err = 0;
1559
1560   if (verbose)
1561     fprintf (stderr, "  Starting large block stream cipher checks.\n");
1562
1563   memset (zeroes, 0, 512);
1564
1565   buffersize = 128 * 1024;
1566   buffer = gcry_xmalloc (buffersize+1024);
1567   memset (buffer+buffersize, 0x5a, 1024);
1568
1569   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
1570     {
1571       if (verbose)
1572         fprintf (stderr, "    checking large block stream for %s [%i] (%s)\n",
1573                  gcry_cipher_algo_name (tv[i].algo), tv[i].algo, tv[i].name);
1574
1575       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_STREAM, 0);
1576       if (err)
1577         {
1578           fail ("large stream, gcry_cipher_open for stream mode failed: %s\n",
1579                 gpg_strerror (err));
1580           continue;
1581         }
1582
1583       err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
1584       if (err)
1585         {
1586           fail ("large stream, gcry_cipher_setkey failed: %s\n",
1587                 gpg_strerror (err));
1588           goto next;
1589         }
1590
1591       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
1592       if (err)
1593         {
1594           fail ("large stream, gcry_cipher_setiv failed: %s\n",
1595                 gpg_strerror (err));
1596           goto next;
1597         }
1598
1599       for (j=0, p=buffer; j < buffersize/512; j++, p += 512)
1600         {
1601           err = gcry_cipher_encrypt (hde, p, 512, zeroes, 512);
1602           if (err)
1603             {
1604               fail ("large stream, "
1605                     "gcry_cipher_encrypt (%d) block %d failed: %s\n",
1606                     i, j, gpg_strerror (err));
1607               goto next;
1608             }
1609         }
1610       for (j=0, p=buffer+buffersize; j < 1024; j++, p++)
1611         if (*p != 0x5a)
1612           die ("large stream, buffer corrupted at j=%d\n", j);
1613
1614       /* Now loop over all the data samples.  */
1615       for (j = 0; tv[i].data[j].length; j++)
1616         {
1617           assert (tv[i].data[j].offset + tv[i].data[j].length <= buffersize);
1618
1619           if (memcmp (tv[i].data[j].result,
1620                       buffer + tv[i].data[j].offset, tv[i].data[j].length))
1621             {
1622               fail ("large stream, encrypt mismatch entry %d:%d\n", i, j);
1623               mismatch (tv[i].data[j].result, tv[i].data[j].length,
1624                         buffer + tv[i].data[j].offset, tv[i].data[j].length);
1625             }
1626         }
1627
1628       /*
1629        *  Let's do the same thing again but using changing block sizes.
1630        */
1631       err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
1632       if (err)
1633         {
1634           fail ("large stream, gcry_cipher_setkey failed: %s\n",
1635                 gpg_strerror (err));
1636           goto next;
1637         }
1638
1639       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
1640       if (err)
1641         {
1642           fail ("large stream, gcry_cipher_setiv failed: %s\n",
1643                 gpg_strerror (err));
1644           goto next;
1645         }
1646
1647       for (n=0, p=buffer, j = 0; n < buffersize; n += j, p += j)
1648         {
1649           switch (j)
1650             {
1651             case   0: j =   1;  break;
1652             case   1: j =  64; break;
1653             case  64: j=  384; break;
1654             case 384: j =  63; break;
1655             case  63: j = 512; break;
1656             case 512: j =  32; break;
1657             case  32: j = 503; break;
1658             default:  j = 509; break;
1659             }
1660           if ( n + j >= buffersize )
1661             j = buffersize - n;
1662           assert (j <= 512);
1663           err = gcry_cipher_encrypt (hde, p, j, zeroes, j);
1664           if (err)
1665             {
1666               fail ("large stream, "
1667                     "gcry_cipher_encrypt (%d) offset %u failed: %s\n",
1668                     i, n, gpg_strerror (err));
1669               goto next;
1670             }
1671         }
1672       for (j=0, p=buffer+buffersize; j < 1024; j++, p++)
1673         if (*p != 0x5a)
1674           die ("large stream, buffer corrupted at j=%d (line %d)\n",
1675                j, __LINE__);
1676
1677       /* Now loop over all the data samples.  */
1678       for (j = 0; tv[i].data[j].length; j++)
1679         {
1680           assert (tv[i].data[j].offset + tv[i].data[j].length <= buffersize);
1681
1682           if (memcmp (tv[i].data[j].result,
1683                       buffer + tv[i].data[j].offset, tv[i].data[j].length))
1684             {
1685               fail ("large stream var, encrypt mismatch entry %d:%d\n", i, j);
1686               mismatch (tv[i].data[j].result, tv[i].data[j].length,
1687                         buffer + tv[i].data[j].offset, tv[i].data[j].length);
1688             }
1689         }
1690
1691     next:
1692       gcry_cipher_close (hde);
1693     }
1694
1695   gcry_free (buffer);
1696   if (verbose)
1697     fprintf (stderr, "  Completed large block stream cipher checks.\n");
1698 }
1699
1700
1701
1702 /* Check that our bulk encryption fucntions work properly.  */
1703 static void
1704 check_bulk_cipher_modes (void)
1705 {
1706   struct
1707   {
1708     int algo;
1709     int mode;
1710     const char *key;
1711     int  keylen;
1712     const char *iv;
1713     int ivlen;
1714     char t1_hash[20];
1715   } tv[] = {
1716     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CFB,
1717       "abcdefghijklmnop", 16,
1718       "1234567890123456", 16,
1719 /*[0]*/
1720       { 0x53, 0xda, 0x27, 0x3c, 0x78, 0x3d, 0x54, 0x66, 0x19, 0x63,
1721         0xd7, 0xe6, 0x20, 0x10, 0xcd, 0xc0, 0x5a, 0x0b, 0x06, 0xcc }
1722     },
1723     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CFB,
1724       "abcdefghijklmnopABCDEFG", 24,
1725       "1234567890123456", 16,
1726 /*[1]*/
1727       { 0xc7, 0xb1, 0xd0, 0x09, 0x95, 0x04, 0x34, 0x61, 0x2b, 0xd9,
1728         0xcb, 0xb3, 0xc7, 0xcb, 0xef, 0xea, 0x16, 0x19, 0x9b, 0x3e }
1729     },
1730     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB,
1731       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1732       "1234567890123456", 16,
1733 /*[2]*/
1734       { 0x31, 0xe1, 0x1f, 0x63, 0x65, 0x47, 0x8c, 0x3f, 0x53, 0xdb,
1735         0xd9, 0x4d, 0x91, 0x1d, 0x02, 0x9c, 0x05, 0x25, 0x58, 0x29 }
1736     },
1737     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CBC,
1738       "abcdefghijklmnop", 16,
1739       "1234567890123456", 16,
1740 /*[3]*/
1741       { 0xdc, 0x0c, 0xc2, 0xd9, 0x6b, 0x47, 0xf9, 0xeb, 0x06, 0xb4,
1742         0x2f, 0x6e, 0xec, 0x72, 0xbf, 0x55, 0x26, 0x7f, 0xa9, 0x97 }
1743     },
1744     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC,
1745       "abcdefghijklmnopABCDEFG", 24,
1746       "1234567890123456", 16,
1747 /*[4]*/
1748       { 0x2b, 0x90, 0x9b, 0xe6, 0x40, 0xab, 0x6e, 0xc2, 0xc5, 0xb1,
1749         0x87, 0xf5, 0x43, 0x84, 0x7b, 0x04, 0x06, 0x47, 0xd1, 0x8f }
1750     },
1751     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC,
1752       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1753       "1234567890123456", 16,
1754 /*[5]*/
1755       { 0xaa, 0xa8, 0xdf, 0x03, 0xb0, 0xba, 0xc4, 0xe3, 0xc1, 0x02,
1756         0x38, 0x31, 0x8d, 0x86, 0xcb, 0x49, 0x6d, 0xad, 0xae, 0x01 }
1757     },
1758     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_OFB,
1759       "abcdefghijklmnop", 16,
1760       "1234567890123456", 16,
1761 /*[6]*/
1762       { 0x65, 0xfe, 0xde, 0x48, 0xd0, 0xa1, 0xa6, 0xf9, 0x24, 0x6b,
1763         0x52, 0x5f, 0x21, 0x8a, 0x6f, 0xc7, 0x70, 0x3b, 0xd8, 0x4a }
1764     },
1765     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_OFB,
1766       "abcdefghijklmnopABCDEFG", 24,
1767       "1234567890123456", 16,
1768 /*[7]*/
1769       { 0x59, 0x5b, 0x02, 0xa2, 0x88, 0xc0, 0xbe, 0x94, 0x43, 0xaa,
1770         0x39, 0xf6, 0xbd, 0xcc, 0x83, 0x99, 0xee, 0x00, 0xa1, 0x91 }
1771     },
1772     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB,
1773       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1774       "1234567890123456", 16,
1775 /*[8]*/
1776       { 0x38, 0x8c, 0xe1, 0xe2, 0xbe, 0x67, 0x60, 0xe8, 0xeb, 0xce,
1777         0xd0, 0xc6, 0xaa, 0xd6, 0xf6, 0x26, 0x15, 0x56, 0xd0, 0x2b }
1778     },
1779     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CTR,
1780       "abcdefghijklmnop", 16,
1781       "1234567890123456", 16,
1782 /*[9]*/
1783       { 0x9a, 0x48, 0x94, 0xd6, 0x50, 0x46, 0x81, 0xdb, 0x68, 0x34,
1784         0x3b, 0xc5, 0x9e, 0x66, 0x94, 0x81, 0x98, 0xa0, 0xf9, 0xff }
1785     },
1786     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CTR,
1787       "abcdefghijklmnopABCDEFG", 24,
1788       "1234567890123456", 16,
1789 /*[10]*/
1790       { 0x2c, 0x2c, 0xd3, 0x75, 0x81, 0x2a, 0x59, 0x07, 0xeb, 0x08,
1791         0xce, 0x28, 0x4c, 0x0c, 0x6a, 0xa8, 0x8f, 0xa3, 0x98, 0x7e }
1792     },
1793     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CTR,
1794       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1795       "1234567890123456", 16,
1796 /*[11]*/
1797       { 0x64, 0xce, 0x73, 0x03, 0xc7, 0x89, 0x99, 0x1f, 0xf1, 0xce,
1798         0xfe, 0xfb, 0xb9, 0x42, 0x30, 0xdf, 0xbb, 0x68, 0x6f, 0xd3 }
1799     },
1800     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB,
1801       "abcdefghijklmnop", 16,
1802       "1234567890123456", 16,
1803 /*[12]*/
1804       { 0x51, 0xae, 0xf5, 0xac, 0x22, 0xa0, 0xba, 0x11, 0xc5, 0xaa,
1805         0xb4, 0x70, 0x99, 0xce, 0x18, 0x08, 0x12, 0x9b, 0xb1, 0xc5 }
1806     },
1807     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_ECB,
1808       "abcdefghijklmnopABCDEFG", 24,
1809       "1234567890123456", 16,
1810 /*[13]*/
1811       { 0x57, 0x91, 0xea, 0x48, 0xd8, 0xbf, 0x9e, 0xc1, 0xae, 0x33,
1812         0xb3, 0xfd, 0xf7, 0x7a, 0xeb, 0x30, 0xb1, 0x62, 0x0d, 0x82 }
1813     },
1814     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_ECB,
1815       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1816       "1234567890123456", 16,
1817 /*[14]*/
1818       { 0x2d, 0x71, 0x54, 0xb9, 0xc5, 0x28, 0x76, 0xff, 0x76, 0xb5,
1819         0x99, 0x37, 0x99, 0x9d, 0xf7, 0x10, 0x6d, 0x86, 0x4f, 0x3f }
1820     }
1821   };
1822   gcry_cipher_hd_t hde = NULL;
1823   gcry_cipher_hd_t hdd = NULL;
1824   unsigned char *buffer_base, *outbuf_base; /* Allocated buffers.  */
1825   unsigned char *buffer, *outbuf;           /* Aligned buffers.  */
1826   size_t buflen;
1827   unsigned char hash[20];
1828   int i, j, keylen, blklen;
1829   gcry_error_t err = 0;
1830
1831   if (verbose)
1832     fprintf (stderr, "Starting bulk cipher checks.\n");
1833
1834   buflen = 16*100;  /* We check a 1600 byte buffer.  */
1835   buffer_base = gcry_xmalloc (buflen+16);
1836   buffer = buffer_base + (16 - ((size_t)buffer_base & 0x0f));
1837   outbuf_base = gcry_xmalloc (buflen+16);
1838   outbuf = outbuf_base + (16 - ((size_t)outbuf_base & 0x0f));
1839
1840
1841   for (i = 0; i < DIM (tv); i++)
1842     {
1843       if (verbose)
1844         fprintf (stderr, "    checking bulk encryption for %s [%i], mode %d\n",
1845                  gcry_cipher_algo_name (tv[i].algo),
1846                  tv[i].algo, tv[i].mode);
1847       err = gcry_cipher_open (&hde, tv[i].algo, tv[i].mode, 0);
1848       if (!err)
1849         err = gcry_cipher_open (&hdd, tv[i].algo, tv[i].mode, 0);
1850       if (err)
1851         {
1852           fail ("gcry_cipher_open failed: %s\n", gpg_strerror (err));
1853           goto leave;
1854         }
1855
1856       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
1857       if (!keylen)
1858         {
1859           fail ("gcry_cipher_get_algo_keylen failed\n");
1860           goto leave;
1861         }
1862
1863       err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
1864       if (!err)
1865         err = gcry_cipher_setkey (hdd, tv[i].key, tv[i].keylen);
1866       if (err)
1867         {
1868           fail ("gcry_cipher_setkey failed: %s\n", gpg_strerror (err));
1869           goto leave;
1870         }
1871
1872       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
1873       if (!blklen)
1874         {
1875           fail ("gcry_cipher_get_algo_blklen failed\n");
1876           goto leave;
1877         }
1878
1879       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
1880       if (!err)
1881         err = gcry_cipher_setiv (hdd, tv[i].iv,  tv[i].ivlen);
1882       if (err)
1883         {
1884           fail ("gcry_cipher_setiv failed: %s\n", gpg_strerror (err));
1885           goto leave;
1886         }
1887
1888       /* Fill the buffer with our test pattern.  */
1889       for (j=0; j < buflen; j++)
1890         buffer[j] = ((j & 0xff) ^ ((j >> 8) & 0xff));
1891
1892       err = gcry_cipher_encrypt (hde, outbuf, buflen, buffer, buflen);
1893       if (err)
1894         {
1895           fail ("gcry_cipher_encrypt (algo %d, mode %d) failed: %s\n",
1896                 tv[i].algo, tv[i].mode, gpg_strerror (err));
1897           goto leave;
1898         }
1899
1900       gcry_md_hash_buffer (GCRY_MD_SHA1, hash, outbuf, buflen);
1901 #if 0
1902       printf ("/*[%d]*/\n", i);
1903       fputs ("      {", stdout);
1904       for (j=0; j < 20; j++)
1905         printf (" 0x%02x%c%s", hash[j], j==19? ' ':',', j == 9? "\n       ":"");
1906       puts ("}");
1907 #endif
1908
1909       if (memcmp (hash, tv[i].t1_hash, 20))
1910         fail ("encrypt mismatch (algo %d, mode %d)\n",
1911               tv[i].algo, tv[i].mode);
1912
1913       err = gcry_cipher_decrypt (hdd, outbuf, buflen, NULL, 0);
1914       if (err)
1915         {
1916           fail ("gcry_cipher_decrypt (algo %d, mode %d) failed: %s\n",
1917                 tv[i].algo, tv[i].mode, gpg_strerror (err));
1918           goto leave;
1919         }
1920
1921       if (memcmp (buffer, outbuf, buflen))
1922         fail ("decrypt mismatch (algo %d, mode %d)\n",
1923               tv[i].algo, tv[i].mode);
1924
1925       gcry_cipher_close (hde); hde = NULL;
1926       gcry_cipher_close (hdd); hdd = NULL;
1927     }
1928
1929   if (verbose)
1930     fprintf (stderr, "Completed bulk cipher checks.\n");
1931  leave:
1932   gcry_cipher_close (hde);
1933   gcry_cipher_close (hdd);
1934   gcry_free (buffer_base);
1935   gcry_free (outbuf_base);
1936 }
1937
1938
1939 /* The core of the cipher check.  In addition to the parameters passed
1940    to check_one_cipher it also receives the KEY and the plain data.
1941    PASS is printed with error messages.  The function returns 0 on
1942    success.  */
1943 static int
1944 check_one_cipher_core (int algo, int mode, int flags,
1945                        const char *key, size_t nkey,
1946                        const unsigned char *plain, size_t nplain,
1947                        int bufshift, int pass)
1948 {
1949   gcry_cipher_hd_t hd;
1950   unsigned char in_buffer[1040+1], out_buffer[1040+1];
1951   unsigned char *in, *out;
1952   int keylen;
1953   gcry_error_t err = 0;
1954
1955   assert (nkey == 32);
1956   assert (nplain == 1040);
1957   assert (sizeof(in_buffer) == nplain + 1);
1958   assert (sizeof(out_buffer) == sizeof(in_buffer));
1959
1960   if (!bufshift)
1961     {
1962       in = in_buffer;
1963       out = out_buffer;
1964     }
1965   else if (bufshift == 1)
1966     {
1967       in = in_buffer+1;
1968       out = out_buffer;
1969     }
1970   else if (bufshift == 2)
1971     {
1972       in = in_buffer+1;
1973       out = out_buffer+1;
1974     }
1975   else
1976     {
1977       in = in_buffer;
1978       out = out_buffer+1;
1979     }
1980
1981   keylen = gcry_cipher_get_algo_keylen (algo);
1982   if (!keylen)
1983     {
1984       fail ("pass %d, algo %d, mode %d, gcry_cipher_get_algo_keylen failed\n",
1985             pass, algo, mode);
1986       return -1;
1987     }
1988
1989   if (keylen < 40 / 8 || keylen > 32)
1990     {
1991       fail ("pass %d, algo %d, mode %d, keylength problem (%d)\n", pass, algo, mode, keylen);
1992       return -1;
1993     }
1994
1995   err = gcry_cipher_open (&hd, algo, mode, flags);
1996   if (err)
1997     {
1998       fail ("pass %d, algo %d, mode %d, gcry_cipher_open failed: %s\n",
1999             pass, algo, mode, gpg_strerror (err));
2000       return -1;
2001     }
2002
2003   err = gcry_cipher_setkey (hd, key, keylen);
2004   if (err)
2005     {
2006       fail ("pass %d, algo %d, mode %d, gcry_cipher_setkey failed: %s\n",
2007             pass, algo, mode, gpg_strerror (err));
2008       gcry_cipher_close (hd);
2009       return -1;
2010     }
2011
2012   err = gcry_cipher_encrypt (hd, out, nplain, plain, nplain);
2013   if (err)
2014     {
2015       fail ("pass %d, algo %d, mode %d, gcry_cipher_encrypt failed: %s\n",
2016             pass, algo, mode, gpg_strerror (err));
2017       gcry_cipher_close (hd);
2018       return -1;
2019     }
2020
2021   gcry_cipher_reset (hd);
2022
2023   err = gcry_cipher_decrypt (hd, in, nplain, out, nplain);
2024   if (err)
2025     {
2026       fail ("pass %d, algo %d, mode %d, gcry_cipher_decrypt failed: %s\n",
2027             pass, algo, mode, gpg_strerror (err));
2028       gcry_cipher_close (hd);
2029       return -1;
2030     }
2031
2032   if (memcmp (plain, in, nplain))
2033     fail ("pass %d, algo %d, mode %d, encrypt-decrypt mismatch\n",
2034           pass, algo, mode);
2035
2036   /* Again, using in-place encryption.  */
2037   gcry_cipher_reset (hd);
2038
2039   memcpy (out, plain, nplain);
2040   err = gcry_cipher_encrypt (hd, out, nplain, NULL, 0);
2041   if (err)
2042     {
2043       fail ("pass %d, algo %d, mode %d, in-place, gcry_cipher_encrypt failed:"
2044             " %s\n",
2045             pass, algo, mode, gpg_strerror (err));
2046       gcry_cipher_close (hd);
2047       return -1;
2048     }
2049
2050   gcry_cipher_reset (hd);
2051
2052   err = gcry_cipher_decrypt (hd, out, nplain, NULL, 0);
2053   if (err)
2054     {
2055       fail ("pass %d, algo %d, mode %d, in-place, gcry_cipher_decrypt failed:"
2056             " %s\n",
2057             pass, algo, mode, gpg_strerror (err));
2058       gcry_cipher_close (hd);
2059       return -1;
2060     }
2061
2062   if (memcmp (plain, out, nplain))
2063     fail ("pass %d, algo %d, mode %d, in-place, encrypt-decrypt mismatch\n",
2064           pass, algo, mode);
2065
2066
2067   gcry_cipher_close (hd);
2068
2069   return 0;
2070 }
2071
2072
2073
2074 static void
2075 check_one_cipher (int algo, int mode, int flags)
2076 {
2077   char key[32+1];
2078   unsigned char plain[1040+1];
2079   int bufshift, i;
2080
2081   for (bufshift=0; bufshift < 4; bufshift++)
2082     {
2083       /* Pass 0: Standard test.  */
2084       memcpy (key, "0123456789abcdef.,;/[]{}-=ABCDEF", 32);
2085       memcpy (plain, "foobar42FOOBAR17", 16);
2086       for (i = 16; i < 1040; i += 16)
2087         {
2088           memcpy (&plain[i], &plain[i-16], 16);
2089           if (!++plain[i+7])
2090             plain[i+6]++;
2091           if (!++plain[i+15])
2092             plain[i+14]++;
2093         }
2094
2095       if (check_one_cipher_core (algo, mode, flags, key, 32, plain, 1040,
2096                                  bufshift, 0+10*bufshift))
2097         return;
2098
2099       /* Pass 1: Key not aligned.  */
2100       memmove (key+1, key, 32);
2101       if (check_one_cipher_core (algo, mode, flags, key+1, 32, plain, 1040,
2102                                  bufshift, 1+10*bufshift))
2103         return;
2104
2105       /* Pass 2: Key not aligned and data not aligned.  */
2106       memmove (plain+1, plain, 1024);
2107       if (check_one_cipher_core (algo, mode, flags, key+1, 32, plain+1, 1040,
2108                                  bufshift, 2+10*bufshift))
2109         return;
2110
2111       /* Pass 3: Key aligned and data not aligned.  */
2112       memmove (key, key+1, 32);
2113       if (check_one_cipher_core (algo, mode, flags, key, 32, plain+1, 1040,
2114                                  bufshift, 3+10*bufshift))
2115         return;
2116     }
2117
2118   return;
2119 }
2120
2121
2122
2123 static void
2124 check_ciphers (void)
2125 {
2126   static int algos[] = {
2127 #if USE_BLOWFISH
2128     GCRY_CIPHER_BLOWFISH,
2129 #endif
2130 #if USE_DES
2131     GCRY_CIPHER_DES,
2132     GCRY_CIPHER_3DES,
2133 #endif
2134 #if USE_CAST5
2135     GCRY_CIPHER_CAST5,
2136 #endif
2137 #if USE_AES
2138     GCRY_CIPHER_AES,
2139     GCRY_CIPHER_AES192,
2140     GCRY_CIPHER_AES256,
2141 #endif
2142 #if USE_TWOFISH
2143     GCRY_CIPHER_TWOFISH,
2144     GCRY_CIPHER_TWOFISH128,
2145 #endif
2146 #if USE_SERPENT
2147     GCRY_CIPHER_SERPENT128,
2148     GCRY_CIPHER_SERPENT192,
2149     GCRY_CIPHER_SERPENT256,
2150 #endif
2151 #if USE_RFC2268
2152     GCRY_CIPHER_RFC2268_40,
2153 #endif
2154 #if USE_SEED
2155     GCRY_CIPHER_SEED,
2156 #endif
2157 #if USE_CAMELLIA
2158     GCRY_CIPHER_CAMELLIA128,
2159     GCRY_CIPHER_CAMELLIA192,
2160     GCRY_CIPHER_CAMELLIA256,
2161 #endif
2162 #if USE_IDEA
2163     GCRY_CIPHER_IDEA,
2164 #endif
2165     0
2166   };
2167   static int algos2[] = {
2168 #if USE_ARCFOUR
2169     GCRY_CIPHER_ARCFOUR,
2170 #endif
2171 #if USE_SALSA20
2172     GCRY_CIPHER_SALSA20,
2173 #endif
2174     0
2175   };
2176   int i;
2177
2178   if (verbose)
2179     fprintf (stderr, "Starting Cipher checks.\n");
2180   for (i = 0; algos[i]; i++)
2181     {
2182       if (gcry_cipher_test_algo (algos[i]) && in_fips_mode)
2183         {
2184           if (verbose)
2185             fprintf (stderr, "  algorithm %d not available in fips mode\n",
2186                      algos[i]);
2187           continue;
2188         }
2189       if (verbose)
2190         fprintf (stderr, "  checking %s [%i]\n",
2191                  gcry_cipher_algo_name (algos[i]),
2192                  gcry_cipher_map_name (gcry_cipher_algo_name (algos[i])));
2193
2194       check_one_cipher (algos[i], GCRY_CIPHER_MODE_ECB, 0);
2195       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CFB, 0);
2196       check_one_cipher (algos[i], GCRY_CIPHER_MODE_OFB, 0);
2197       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, 0);
2198       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_CTS);
2199       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CTR, 0);
2200     }
2201
2202   for (i = 0; algos2[i]; i++)
2203     {
2204       if (gcry_cipher_test_algo (algos[i]) && in_fips_mode)
2205         {
2206           if (verbose)
2207             fprintf (stderr, "  algorithm %d not available in fips mode\n",
2208                      algos[i]);
2209           continue;
2210         }
2211       if (verbose)
2212         fprintf (stderr, "  checking %s\n",
2213                  gcry_cipher_algo_name (algos2[i]));
2214
2215       check_one_cipher (algos2[i], GCRY_CIPHER_MODE_STREAM, 0);
2216     }
2217   /* we have now run all cipher's selftests */
2218
2219   if (verbose)
2220     fprintf (stderr, "Completed Cipher checks.\n");
2221
2222   /* TODO: add some extra encryption to test the higher level functions */
2223 }
2224
2225
2226 static void
2227 check_cipher_modes(void)
2228 {
2229   if (verbose)
2230     fprintf (stderr, "Starting Cipher Mode checks.\n");
2231
2232   check_aes128_cbc_cts_cipher ();
2233   check_cbc_mac_cipher ();
2234   check_ctr_cipher ();
2235   check_cfb_cipher ();
2236   check_ofb_cipher ();
2237   check_stream_cipher ();
2238   check_stream_cipher_large_block ();
2239
2240   if (verbose)
2241     fprintf (stderr, "Completed Cipher Mode checks.\n");
2242 }
2243
2244 static void
2245 check_one_md (int algo, const char *data, int len, const char *expect)
2246 {
2247   gcry_md_hd_t hd, hd2;
2248   unsigned char *p;
2249   int mdlen;
2250   int i;
2251   gcry_error_t err = 0;
2252
2253   err = gcry_md_open (&hd, algo, 0);
2254   if (err)
2255     {
2256       fail ("algo %d, gcry_md_open failed: %s\n", algo, gpg_strerror (err));
2257       return;
2258     }
2259
2260   mdlen = gcry_md_get_algo_dlen (algo);
2261   if (mdlen < 1 || mdlen > 500)
2262     {
2263       fail ("algo %d, gcry_md_get_algo_dlen failed: %d\n", algo, mdlen);
2264       return;
2265     }
2266
2267   if (*data == '!' && !data[1])
2268     {                           /* hash one million times a "a" */
2269       char aaa[1000];
2270
2271       /* Write in odd size chunks so that we test the buffering.  */
2272       memset (aaa, 'a', 1000);
2273       for (i = 0; i < 1000; i++)
2274         gcry_md_write (hd, aaa, 1000);
2275     }
2276   else
2277     gcry_md_write (hd, data, len);
2278
2279   err = gcry_md_copy (&hd2, hd);
2280   if (err)
2281     {
2282       fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
2283     }
2284
2285   gcry_md_close (hd);
2286
2287   p = gcry_md_read (hd2, algo);
2288
2289   if (memcmp (p, expect, mdlen))
2290     {
2291       printf ("computed: ");
2292       for (i = 0; i < mdlen; i++)
2293         printf ("%02x ", p[i] & 0xFF);
2294       printf ("\nexpected: ");
2295       for (i = 0; i < mdlen; i++)
2296         printf ("%02x ", expect[i] & 0xFF);
2297       printf ("\n");
2298
2299       fail ("algo %d, digest mismatch\n", algo);
2300     }
2301
2302   gcry_md_close (hd2);
2303 }
2304
2305
2306 static void
2307 check_digests (void)
2308 {
2309   static struct algos
2310   {
2311     int md;
2312     const char *data;
2313     const char *expect;
2314   } algos[] =
2315     {
2316       { GCRY_MD_MD4, "",
2317         "\x31\xD6\xCF\xE0\xD1\x6A\xE9\x31\xB7\x3C\x59\xD7\xE0\xC0\x89\xC0" },
2318       { GCRY_MD_MD4, "a",
2319         "\xbd\xe5\x2c\xb3\x1d\xe3\x3e\x46\x24\x5e\x05\xfb\xdb\xd6\xfb\x24" },
2320       { GCRY_MD_MD4, "message digest",
2321         "\xd9\x13\x0a\x81\x64\x54\x9f\xe8\x18\x87\x48\x06\xe1\xc7\x01\x4b" },
2322       { GCRY_MD_MD5, "",
2323         "\xD4\x1D\x8C\xD9\x8F\x00\xB2\x04\xE9\x80\x09\x98\xEC\xF8\x42\x7E" },
2324       { GCRY_MD_MD5, "a",
2325         "\x0C\xC1\x75\xB9\xC0\xF1\xB6\xA8\x31\xC3\x99\xE2\x69\x77\x26\x61" },
2326       { GCRY_MD_MD5, "abc",
2327         "\x90\x01\x50\x98\x3C\xD2\x4F\xB0\xD6\x96\x3F\x7D\x28\xE1\x7F\x72" },
2328       { GCRY_MD_MD5, "message digest",
2329         "\xF9\x6B\x69\x7D\x7C\xB7\x93\x8D\x52\x5A\x2F\x31\xAA\xF1\x61\xD0" },
2330       { GCRY_MD_SHA1, "abc",
2331         "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E"
2332         "\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" },
2333       { GCRY_MD_SHA1,
2334         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
2335         "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE"
2336         "\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" },
2337       { GCRY_MD_SHA1, "!" /* kludge for "a"*1000000 */ ,
2338         "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E"
2339         "\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" },
2340       /* From RFC3874 */
2341       { GCRY_MD_SHA224, "abc",
2342         "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
2343         "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7" },
2344       { GCRY_MD_SHA224,
2345         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
2346         "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01\x50"
2347         "\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25" },
2348       { GCRY_MD_SHA224, "!",
2349         "\x20\x79\x46\x55\x98\x0c\x91\xd8\xbb\xb4\xc1\xea\x97\x61\x8a\x4b"
2350         "\xf0\x3f\x42\x58\x19\x48\xb2\xee\x4e\xe7\xad\x67" },
2351       { GCRY_MD_SHA256, "abc",
2352         "\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
2353         "\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad" },
2354       { GCRY_MD_SHA256,
2355         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
2356         "\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
2357         "\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1" },
2358       { GCRY_MD_SHA256, "!",
2359         "\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67"
2360         "\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0" },
2361       { GCRY_MD_SHA384, "abc",
2362         "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b\xb5\xa0\x3d\x69\x9a\xc6\x50\x07"
2363         "\x27\x2c\x32\xab\x0e\xde\xd1\x63\x1a\x8b\x60\x5a\x43\xff\x5b\xed"
2364         "\x80\x86\x07\x2b\xa1\xe7\xcc\x23\x58\xba\xec\xa1\x34\xc8\x25\xa7" },
2365       { GCRY_MD_SHA512, "abc",
2366         "\xDD\xAF\x35\xA1\x93\x61\x7A\xBA\xCC\x41\x73\x49\xAE\x20\x41\x31"
2367         "\x12\xE6\xFA\x4E\x89\xA9\x7E\xA2\x0A\x9E\xEE\xE6\x4B\x55\xD3\x9A"
2368         "\x21\x92\x99\x2A\x27\x4F\xC1\xA8\x36\xBA\x3C\x23\xA3\xFE\xEB\xBD"
2369         "\x45\x4D\x44\x23\x64\x3C\xE8\x0E\x2A\x9A\xC9\x4F\xA5\x4C\xA4\x9F" },
2370       { GCRY_MD_RMD160, "",
2371         "\x9c\x11\x85\xa5\xc5\xe9\xfc\x54\x61\x28"
2372         "\x08\x97\x7e\xe8\xf5\x48\xb2\x25\x8d\x31" },
2373       { GCRY_MD_RMD160, "a",
2374         "\x0b\xdc\x9d\x2d\x25\x6b\x3e\xe9\xda\xae"
2375         "\x34\x7b\xe6\xf4\xdc\x83\x5a\x46\x7f\xfe" },
2376       { GCRY_MD_RMD160, "abc",
2377         "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04"
2378         "\x4a\x8e\x98\xc6\xb0\x87\xf1\x5a\x0b\xfc" },
2379       { GCRY_MD_RMD160, "message digest",
2380         "\x5d\x06\x89\xef\x49\xd2\xfa\xe5\x72\xb8"
2381         "\x81\xb1\x23\xa8\x5f\xfa\x21\x59\x5f\x36" },
2382       { GCRY_MD_CRC32, "", "\x00\x00\x00\x00" },
2383       { GCRY_MD_CRC32, "foo", "\x8c\x73\x65\x21" },
2384       { GCRY_MD_CRC32_RFC1510, "", "\x00\x00\x00\x00" },
2385       { GCRY_MD_CRC32_RFC1510, "foo", "\x73\x32\xbc\x33" },
2386       { GCRY_MD_CRC32_RFC1510, "test0123456789", "\xb8\x3e\x88\xd6" },
2387       { GCRY_MD_CRC32_RFC1510, "MASSACHVSETTS INSTITVTE OF TECHNOLOGY",
2388         "\xe3\x41\x80\xf7" },
2389 #if 0
2390       { GCRY_MD_CRC32_RFC1510, "\x80\x00", "\x3b\x83\x98\x4b" },
2391       { GCRY_MD_CRC32_RFC1510, "\x00\x08", "\x0e\xdb\x88\x32" },
2392       { GCRY_MD_CRC32_RFC1510, "\x00\x80", "\xed\xb8\x83\x20" },
2393 #endif
2394       { GCRY_MD_CRC32_RFC1510, "\x80", "\xed\xb8\x83\x20" },
2395 #if 0
2396       { GCRY_MD_CRC32_RFC1510, "\x80\x00\x00\x00", "\xed\x59\xb6\x3b" },
2397       { GCRY_MD_CRC32_RFC1510, "\x00\x00\x00\x01", "\x77\x07\x30\x96" },
2398 #endif
2399       { GCRY_MD_CRC24_RFC2440, "", "\xb7\x04\xce" },
2400       { GCRY_MD_CRC24_RFC2440, "foo", "\x4f\xc2\x55" },
2401
2402       { GCRY_MD_TIGER, "",
2403         "\x24\xF0\x13\x0C\x63\xAC\x93\x32\x16\x16\x6E\x76"
2404         "\xB1\xBB\x92\x5F\xF3\x73\xDE\x2D\x49\x58\x4E\x7A" },
2405       { GCRY_MD_TIGER, "abc",
2406         "\xF2\x58\xC1\xE8\x84\x14\xAB\x2A\x52\x7A\xB5\x41"
2407         "\xFF\xC5\xB8\xBF\x93\x5F\x7B\x95\x1C\x13\x29\x51" },
2408       { GCRY_MD_TIGER, "Tiger",
2409         "\x9F\x00\xF5\x99\x07\x23\x00\xDD\x27\x6A\xBB\x38"
2410         "\xC8\xEB\x6D\xEC\x37\x79\x0C\x11\x6F\x9D\x2B\xDF" },
2411       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg"
2412         "hijklmnopqrstuvwxyz0123456789+-",
2413         "\x87\xFB\x2A\x90\x83\x85\x1C\xF7\x47\x0D\x2C\xF8"
2414         "\x10\xE6\xDF\x9E\xB5\x86\x44\x50\x34\xA5\xA3\x86" },
2415       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdef"
2416         "ghijklmnopqrstuvwxyz+0123456789",
2417         "\x46\x7D\xB8\x08\x63\xEB\xCE\x48\x8D\xF1\xCD\x12"
2418         "\x61\x65\x5D\xE9\x57\x89\x65\x65\x97\x5F\x91\x97" },
2419       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
2420         "by Ross Anderson and Eli Biham",
2421         "\x0C\x41\x0A\x04\x29\x68\x86\x8A\x16\x71\xDA\x5A"
2422         "\x3F\xD2\x9A\x72\x5E\xC1\xE4\x57\xD3\xCD\xB3\x03" },
2423       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
2424         "by Ross Anderson and Eli Biham, proceedings of Fa"
2425         "st Software Encryption 3, Cambridge.",
2426         "\xEB\xF5\x91\xD5\xAF\xA6\x55\xCE\x7F\x22\x89\x4F"
2427         "\xF8\x7F\x54\xAC\x89\xC8\x11\xB6\xB0\xDA\x31\x93" },
2428       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
2429         "by Ross Anderson and Eli Biham, proceedings of Fa"
2430         "st Software Encryption 3, Cambridge, 1996.",
2431         "\x3D\x9A\xEB\x03\xD1\xBD\x1A\x63\x57\xB2\x77\x4D"
2432         "\xFD\x6D\x5B\x24\xDD\x68\x15\x1D\x50\x39\x74\xFC" },
2433       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefgh"
2434         "ijklmnopqrstuvwxyz0123456789+-ABCDEFGHIJKLMNOPQRS"
2435         "TUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-",
2436         "\x00\xB8\x3E\xB4\xE5\x34\x40\xC5\x76\xAC\x6A\xAE"
2437         "\xE0\xA7\x48\x58\x25\xFD\x15\xE7\x0A\x59\xFF\xE4" },
2438
2439       { GCRY_MD_TIGER1, "",
2440         "\x32\x93\xAC\x63\x0C\x13\xF0\x24\x5F\x92\xBB\xB1"
2441         "\x76\x6E\x16\x16\x7A\x4E\x58\x49\x2D\xDE\x73\xF3" },
2442       { GCRY_MD_TIGER1, "a",
2443         "\x77\xBE\xFB\xEF\x2E\x7E\xF8\xAB\x2E\xC8\xF9\x3B"
2444         "\xF5\x87\xA7\xFC\x61\x3E\x24\x7F\x5F\x24\x78\x09" },
2445       { GCRY_MD_TIGER1, "abc",
2446         "\x2A\xAB\x14\x84\xE8\xC1\x58\xF2\xBF\xB8\xC5\xFF"
2447         "\x41\xB5\x7A\x52\x51\x29\x13\x1C\x95\x7B\x5F\x93" },
2448       { GCRY_MD_TIGER1, "message digest",
2449         "\xD9\x81\xF8\xCB\x78\x20\x1A\x95\x0D\xCF\x30\x48"
2450         "\x75\x1E\x44\x1C\x51\x7F\xCA\x1A\xA5\x5A\x29\xF6" },
2451       { GCRY_MD_TIGER1, "abcdefghijklmnopqrstuvwxyz",
2452         "\x17\x14\xA4\x72\xEE\xE5\x7D\x30\x04\x04\x12\xBF"
2453         "\xCC\x55\x03\x2A\x0B\x11\x60\x2F\xF3\x7B\xEE\xE9" },
2454       { GCRY_MD_TIGER1,
2455         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
2456         "\x0F\x7B\xF9\xA1\x9B\x9C\x58\xF2\xB7\x61\x0D\xF7"
2457         "\xE8\x4F\x0A\xC3\xA7\x1C\x63\x1E\x7B\x53\xF7\x8E" },
2458       { GCRY_MD_TIGER1,
2459         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
2460         "abcdefghijklmnopqrstuvwxyz" "0123456789",
2461         "\x8D\xCE\xA6\x80\xA1\x75\x83\xEE\x50\x2B\xA3\x8A"
2462         "\x3C\x36\x86\x51\x89\x0F\xFB\xCC\xDC\x49\xA8\xCC" },
2463       { GCRY_MD_TIGER1,
2464         "1234567890" "1234567890" "1234567890" "1234567890"
2465         "1234567890" "1234567890" "1234567890" "1234567890",
2466         "\x1C\x14\x79\x55\x29\xFD\x9F\x20\x7A\x95\x8F\x84"
2467         "\xC5\x2F\x11\xE8\x87\xFA\x0C\xAB\xDF\xD9\x1B\xFD" },
2468       { GCRY_MD_TIGER1, "!",
2469         "\x6D\xB0\xE2\x72\x9C\xBE\xAD\x93\xD7\x15\xC6\xA7"
2470         "\xD3\x63\x02\xE9\xB3\xCE\xE0\xD2\xBC\x31\x4B\x41" },
2471
2472       { GCRY_MD_TIGER2, "",
2473         "\x44\x41\xBE\x75\xF6\x01\x87\x73\xC2\x06\xC2\x27"
2474         "\x45\x37\x4B\x92\x4A\xA8\x31\x3F\xEF\x91\x9F\x41" },
2475       { GCRY_MD_TIGER2, "a",
2476         "\x67\xE6\xAE\x8E\x9E\x96\x89\x99\xF7\x0A\x23\xE7"
2477         "\x2A\xEA\xA9\x25\x1C\xBC\x7C\x78\xA7\x91\x66\x36" },
2478       { GCRY_MD_TIGER2, "abc",
2479         "\xF6\x8D\x7B\xC5\xAF\x4B\x43\xA0\x6E\x04\x8D\x78"
2480         "\x29\x56\x0D\x4A\x94\x15\x65\x8B\xB0\xB1\xF3\xBF" },
2481       { GCRY_MD_TIGER2, "message digest",
2482         "\xE2\x94\x19\xA1\xB5\xFA\x25\x9D\xE8\x00\x5E\x7D"
2483         "\xE7\x50\x78\xEA\x81\xA5\x42\xEF\x25\x52\x46\x2D" },
2484       { GCRY_MD_TIGER2, "abcdefghijklmnopqrstuvwxyz",
2485         "\xF5\xB6\xB6\xA7\x8C\x40\x5C\x85\x47\xE9\x1C\xD8"
2486         "\x62\x4C\xB8\xBE\x83\xFC\x80\x4A\x47\x44\x88\xFD" },
2487       { GCRY_MD_TIGER2,
2488         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
2489         "\xA6\x73\x7F\x39\x97\xE8\xFB\xB6\x3D\x20\xD2\xDF"
2490         "\x88\xF8\x63\x76\xB5\xFE\x2D\x5C\xE3\x66\x46\xA9" },
2491       { GCRY_MD_TIGER2,
2492         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
2493         "abcdefghijklmnopqrstuvwxyz" "0123456789",
2494         "\xEA\x9A\xB6\x22\x8C\xEE\x7B\x51\xB7\x75\x44\xFC"
2495         "\xA6\x06\x6C\x8C\xBB\x5B\xBA\xE6\x31\x95\x05\xCD" },
2496       { GCRY_MD_TIGER2,
2497         "1234567890" "1234567890" "1234567890" "1234567890"
2498         "1234567890" "1234567890" "1234567890" "1234567890",
2499         "\xD8\x52\x78\x11\x53\x29\xEB\xAA\x0E\xEC\x85\xEC"
2500         "\xDC\x53\x96\xFD\xA8\xAA\x3A\x58\x20\x94\x2F\xFF" },
2501       { GCRY_MD_TIGER2, "!",
2502         "\xE0\x68\x28\x1F\x06\x0F\x55\x16\x28\xCC\x57\x15"
2503         "\xB9\xD0\x22\x67\x96\x91\x4D\x45\xF7\x71\x7C\xF4" },
2504
2505       { GCRY_MD_WHIRLPOOL, "",
2506         "\x19\xFA\x61\xD7\x55\x22\xA4\x66\x9B\x44\xE3\x9C\x1D\x2E\x17\x26"
2507         "\xC5\x30\x23\x21\x30\xD4\x07\xF8\x9A\xFE\xE0\x96\x49\x97\xF7\xA7"
2508         "\x3E\x83\xBE\x69\x8B\x28\x8F\xEB\xCF\x88\xE3\xE0\x3C\x4F\x07\x57"
2509         "\xEA\x89\x64\xE5\x9B\x63\xD9\x37\x08\xB1\x38\xCC\x42\xA6\x6E\xB3" },
2510       { GCRY_MD_WHIRLPOOL, "a",
2511         "\x8A\xCA\x26\x02\x79\x2A\xEC\x6F\x11\xA6\x72\x06\x53\x1F\xB7\xD7"
2512         "\xF0\xDF\xF5\x94\x13\x14\x5E\x69\x73\xC4\x50\x01\xD0\x08\x7B\x42"
2513         "\xD1\x1B\xC6\x45\x41\x3A\xEF\xF6\x3A\x42\x39\x1A\x39\x14\x5A\x59"
2514         "\x1A\x92\x20\x0D\x56\x01\x95\xE5\x3B\x47\x85\x84\xFD\xAE\x23\x1A" },
2515       { GCRY_MD_WHIRLPOOL, "a",
2516         "\x8A\xCA\x26\x02\x79\x2A\xEC\x6F\x11\xA6\x72\x06\x53\x1F\xB7\xD7"
2517         "\xF0\xDF\xF5\x94\x13\x14\x5E\x69\x73\xC4\x50\x01\xD0\x08\x7B\x42"
2518         "\xD1\x1B\xC6\x45\x41\x3A\xEF\xF6\x3A\x42\x39\x1A\x39\x14\x5A\x59"
2519         "\x1A\x92\x20\x0D\x56\x01\x95\xE5\x3B\x47\x85\x84\xFD\xAE\x23\x1A" },
2520       { GCRY_MD_WHIRLPOOL,
2521         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
2522         "\xDC\x37\xE0\x08\xCF\x9E\xE6\x9B\xF1\x1F\x00\xED\x9A\xBA\x26\x90"
2523         "\x1D\xD7\xC2\x8C\xDE\xC0\x66\xCC\x6A\xF4\x2E\x40\xF8\x2F\x3A\x1E"
2524         "\x08\xEB\xA2\x66\x29\x12\x9D\x8F\xB7\xCB\x57\x21\x1B\x92\x81\xA6"
2525         "\x55\x17\xCC\x87\x9D\x7B\x96\x21\x42\xC6\x5F\x5A\x7A\xF0\x14\x67" },
2526       { GCRY_MD_WHIRLPOOL,
2527         "!",
2528         "\x0C\x99\x00\x5B\xEB\x57\xEF\xF5\x0A\x7C\xF0\x05\x56\x0D\xDF\x5D"
2529         "\x29\x05\x7F\xD8\x6B\x20\xBF\xD6\x2D\xEC\xA0\xF1\xCC\xEA\x4A\xF5"
2530         "\x1F\xC1\x54\x90\xED\xDC\x47\xAF\x32\xBB\x2B\x66\xC3\x4F\xF9\xAD"
2531         "\x8C\x60\x08\xAD\x67\x7F\x77\x12\x69\x53\xB2\x26\xE4\xED\x8B\x01" },
2532       { 0 },
2533     };
2534   int i;
2535
2536   if (verbose)
2537     fprintf (stderr, "Starting hash checks.\n");
2538
2539   for (i = 0; algos[i].md; i++)
2540     {
2541       if ((gcry_md_test_algo (algos[i].md) || algos[i].md == GCRY_MD_MD5)
2542           && in_fips_mode)
2543         {
2544           if (verbose)
2545             fprintf (stderr, "  algorithm %d not available in fips mode\n",
2546                      algos[i].md);
2547           continue;
2548         }
2549       if (verbose)
2550         fprintf (stderr, "  checking %s [%i] for length %zi\n",
2551                  gcry_md_algo_name (algos[i].md),
2552                  algos[i].md,
2553                  !strcmp (algos[i].data, "!")?
2554                  1000000 : strlen(algos[i].data));
2555
2556       check_one_md (algos[i].md, algos[i].data, strlen (algos[i].data),
2557                     algos[i].expect);
2558     }
2559
2560   if (verbose)
2561     fprintf (stderr, "Completed hash checks.\n");
2562 }
2563
2564 static void
2565 check_one_hmac (int algo, const char *data, int datalen,
2566                 const char *key, int keylen, const char *expect)
2567 {
2568   gcry_md_hd_t hd, hd2;
2569   unsigned char *p;
2570   int mdlen;
2571   int i;
2572   gcry_error_t err = 0;
2573
2574   err = gcry_md_open (&hd, algo, GCRY_MD_FLAG_HMAC);
2575   if (err)
2576     {
2577       fail ("algo %d, gcry_md_open failed: %s\n", algo, gpg_strerror (err));
2578       return;
2579     }
2580
2581   mdlen = gcry_md_get_algo_dlen (algo);
2582   if (mdlen < 1 || mdlen > 500)
2583     {
2584       fail ("algo %d, gcry_md_get_algo_dlen failed: %d\n", algo, mdlen);
2585       return;
2586     }
2587
2588   gcry_md_setkey( hd, key, keylen );
2589
2590   gcry_md_write (hd, data, datalen);
2591
2592   err = gcry_md_copy (&hd2, hd);
2593   if (err)
2594     {
2595       fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
2596     }
2597
2598   gcry_md_close (hd);
2599
2600   p = gcry_md_read (hd2, algo);
2601   if (!p)
2602     fail("algo %d, hmac gcry_md_read failed\n", algo);
2603
2604   if (memcmp (p, expect, mdlen))
2605     {
2606       printf ("computed: ");
2607       for (i = 0; i < mdlen; i++)
2608         printf ("%02x ", p[i] & 0xFF);
2609       printf ("\nexpected: ");
2610       for (i = 0; i < mdlen; i++)
2611         printf ("%02x ", expect[i] & 0xFF);
2612       printf ("\n");
2613
2614       fail ("algo %d, digest mismatch\n", algo);
2615     }
2616
2617   gcry_md_close (hd2);
2618 }
2619
2620 static void
2621 check_hmac (void)
2622 {
2623   static struct algos
2624   {
2625     int md;
2626     const char *data;
2627     const char *key;
2628     const char *expect;
2629   } algos[] =
2630     {
2631       { GCRY_MD_MD5, "what do ya want for nothing?", "Jefe",
2632         "\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7\x38" },
2633       { GCRY_MD_MD5,
2634         "Hi There",
2635         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
2636         "\x92\x94\x72\x7a\x36\x38\xbb\x1c\x13\xf4\x8e\xf8\x15\x8b\xfc\x9d" },
2637       { GCRY_MD_MD5,
2638         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2639         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2640         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2641         "\xdd\xdd\xdd\xdd\xdd",
2642         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA",
2643         "\x56\xbe\x34\x52\x1d\x14\x4c\x88\xdb\xb8\xc7\x33\xf0\xe8\xb3\xf6" },
2644       { GCRY_MD_MD5,
2645         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2646         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2647         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2648         "\xcd\xcd\xcd\xcd\xcd",
2649         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2650         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2651         "\x69\x7e\xaf\x0a\xca\x3a\x3a\xea\x3a\x75\x16\x47\x46\xff\xaa\x79" },
2652       { GCRY_MD_MD5, "Test With Truncation",
2653         "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c",
2654         "\x56\x46\x1e\xf2\x34\x2e\xdc\x00\xf9\xba\xb9\x95\x69\x0e\xfd\x4c" },
2655       { GCRY_MD_MD5, "Test Using Larger Than Block-Size Key - Hash Key First",
2656         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2657         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2658         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2659         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2660         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2661         "\xaa\xaa\xaa\xaa\xaa",
2662         "\x6b\x1a\xb7\xfe\x4b\xd7\xbf\x8f\x0b\x62\xe6\xce\x61\xb9\xd0\xcd" },
2663       { GCRY_MD_MD5,
2664         "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
2665         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2666         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2667         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2668         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2669         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2670         "\xaa\xaa\xaa\xaa\xaa",
2671         "\x6f\x63\x0f\xad\x67\xcd\xa0\xee\x1f\xb1\xf5\x62\xdb\x3a\xa5\x3e", },
2672       { GCRY_MD_SHA256, "what do ya want for nothing?", "Jefe",
2673         "\x5b\xdc\xc1\x46\xbf\x60\x75\x4e\x6a\x04\x24\x26\x08\x95\x75\xc7\x5a"
2674         "\x00\x3f\x08\x9d\x27\x39\x83\x9d\xec\x58\xb9\x64\xec\x38\x43" },
2675       { GCRY_MD_SHA256,
2676         "Hi There",
2677         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2678         "\x0b\x0b\x0b",
2679         "\xb0\x34\x4c\x61\xd8\xdb\x38\x53\x5c\xa8\xaf\xce\xaf\x0b\xf1\x2b\x88"
2680         "\x1d\xc2\x00\xc9\x83\x3d\xa7\x26\xe9\x37\x6c\x2e\x32\xcf\xf7" },
2681       { GCRY_MD_SHA256,
2682         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2683         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2684         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2685         "\xdd\xdd\xdd\xdd\xdd",
2686         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2687         "\xAA\xAA\xAA\xAA",
2688         "\x77\x3e\xa9\x1e\x36\x80\x0e\x46\x85\x4d\xb8\xeb\xd0\x91\x81\xa7"
2689         "\x29\x59\x09\x8b\x3e\xf8\xc1\x22\xd9\x63\x55\x14\xce\xd5\x65\xfe" },
2690       { GCRY_MD_SHA256,
2691         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2692         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2693         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2694         "\xcd\xcd\xcd\xcd\xcd",
2695         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2696         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2697         "\x82\x55\x8a\x38\x9a\x44\x3c\x0e\xa4\xcc\x81\x98\x99\xf2\x08"
2698         "\x3a\x85\xf0\xfa\xa3\xe5\x78\xf8\x07\x7a\x2e\x3f\xf4\x67\x29\x66\x5b" },
2699       { GCRY_MD_SHA256,
2700         "Test Using Larger Than Block-Size Key - Hash Key First",
2701         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2702         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2703         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2704         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2705         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2706         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2707         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2708         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2709         "\xaa\xaa\xaa",
2710         "\x60\xe4\x31\x59\x1e\xe0\xb6\x7f\x0d\x8a\x26\xaa\xcb\xf5\xb7\x7f"
2711         "\x8e\x0b\xc6\x21\x37\x28\xc5\x14\x05\x46\x04\x0f\x0e\xe3\x7f\x54" },
2712       { GCRY_MD_SHA256,
2713         "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.",
2714         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2715         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2716         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2717         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2718         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2719         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2720         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2721         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2722         "\xaa\xaa\xaa",
2723         "\x9b\x09\xff\xa7\x1b\x94\x2f\xcb\x27\x63\x5f\xbc\xd5\xb0\xe9\x44"
2724         "\xbf\xdc\x63\x64\x4f\x07\x13\x93\x8a\x7f\x51\x53\x5c\x3a\x35\xe2" },
2725       { GCRY_MD_SHA224, "what do ya want for nothing?", "Jefe",
2726         "\xa3\x0e\x01\x09\x8b\xc6\xdb\xbf\x45\x69\x0f\x3a\x7e\x9e\x6d\x0f"
2727         "\x8b\xbe\xa2\xa3\x9e\x61\x48\x00\x8f\xd0\x5e\x44" },
2728       { GCRY_MD_SHA224,
2729         "Hi There",
2730         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2731         "\x0b\x0b\x0b",
2732         "\x89\x6f\xb1\x12\x8a\xbb\xdf\x19\x68\x32\x10\x7c\xd4\x9d\xf3\x3f\x47"
2733         "\xb4\xb1\x16\x99\x12\xba\x4f\x53\x68\x4b\x22" },
2734       { GCRY_MD_SHA224,
2735         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2736         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2737         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2738         "\xdd\xdd\xdd\xdd\xdd",
2739         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2740         "\xAA\xAA\xAA\xAA",
2741         "\x7f\xb3\xcb\x35\x88\xc6\xc1\xf6\xff\xa9\x69\x4d\x7d\x6a\xd2\x64"
2742         "\x93\x65\xb0\xc1\xf6\x5d\x69\xd1\xec\x83\x33\xea" },
2743       { GCRY_MD_SHA224,
2744         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2745         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2746         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2747         "\xcd\xcd\xcd\xcd\xcd",
2748         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2749         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2750         "\x6c\x11\x50\x68\x74\x01\x3c\xac\x6a\x2a\xbc\x1b\xb3\x82\x62"
2751         "\x7c\xec\x6a\x90\xd8\x6e\xfc\x01\x2d\xe7\xaf\xec\x5a" },
2752       { GCRY_MD_SHA224,
2753         "Test Using Larger Than Block-Size Key - Hash Key First",
2754         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2755         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2756         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2757         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2758         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2759         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2760         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2761         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2762         "\xaa\xaa\xaa",
2763         "\x95\xe9\xa0\xdb\x96\x20\x95\xad\xae\xbe\x9b\x2d\x6f\x0d\xbc\xe2"
2764         "\xd4\x99\xf1\x12\xf2\xd2\xb7\x27\x3f\xa6\x87\x0e" },
2765       { GCRY_MD_SHA224,
2766         "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.",
2767         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2768         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2769         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2770         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2771         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2772         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2773         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2774         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2775         "\xaa\xaa\xaa",
2776         "\x3a\x85\x41\x66\xac\x5d\x9f\x02\x3f\x54\xd5\x17\xd0\xb3\x9d\xbd"
2777         "\x94\x67\x70\xdb\x9c\x2b\x95\xc9\xf6\xf5\x65\xd1" },
2778       { GCRY_MD_SHA384, "what do ya want for nothing?", "Jefe",
2779         "\xaf\x45\xd2\xe3\x76\x48\x40\x31\x61\x7f\x78\xd2\xb5\x8a\x6b\x1b"
2780         "\x9c\x7e\xf4\x64\xf5\xa0\x1b\x47\xe4\x2e\xc3\x73\x63\x22\x44\x5e"
2781         "\x8e\x22\x40\xca\x5e\x69\xe2\xc7\x8b\x32\x39\xec\xfa\xb2\x16\x49" },
2782       { GCRY_MD_SHA384,
2783         "Hi There",
2784         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2785         "\x0b\x0b\x0b",
2786         "\xaf\xd0\x39\x44\xd8\x48\x95\x62\x6b\x08\x25\xf4\xab\x46\x90\x7f\x15"
2787         "\xf9\xda\xdb\xe4\x10\x1e\xc6\x82\xaa\x03\x4c\x7c\xeb\xc5\x9c\xfa\xea"
2788         "\x9e\xa9\x07\x6e\xde\x7f\x4a\xf1\x52\xe8\xb2\xfa\x9c\xb6" },
2789       { GCRY_MD_SHA384,
2790         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2791         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2792         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2793         "\xdd\xdd\xdd\xdd\xdd",
2794         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2795         "\xAA\xAA\xAA\xAA",
2796         "\x88\x06\x26\x08\xd3\xe6\xad\x8a\x0a\xa2\xac\xe0\x14\xc8\xa8\x6f"
2797         "\x0a\xa6\x35\xd9\x47\xac\x9f\xeb\xe8\x3e\xf4\xe5\x59\x66\x14\x4b"
2798         "\x2a\x5a\xb3\x9d\xc1\x38\x14\xb9\x4e\x3a\xb6\xe1\x01\xa3\x4f\x27" },
2799       { GCRY_MD_SHA384,
2800         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2801         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2802         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2803         "\xcd\xcd\xcd\xcd\xcd",
2804         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2805         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2806         "\x3e\x8a\x69\xb7\x78\x3c\x25\x85\x19\x33\xab\x62\x90\xaf\x6c\xa7"
2807         "\x7a\x99\x81\x48\x08\x50\x00\x9c\xc5\x57\x7c\x6e\x1f\x57\x3b\x4e"
2808         "\x68\x01\xdd\x23\xc4\xa7\xd6\x79\xcc\xf8\xa3\x86\xc6\x74\xcf\xfb" },
2809       { GCRY_MD_SHA384,
2810         "Test Using Larger Than Block-Size Key - Hash Key First",
2811         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2812         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2813         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2814         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2815         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2816         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2817         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2818         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2819         "\xaa\xaa\xaa",
2820         "\x4e\xce\x08\x44\x85\x81\x3e\x90\x88\xd2\xc6\x3a\x04\x1b\xc5\xb4"
2821         "\x4f\x9e\xf1\x01\x2a\x2b\x58\x8f\x3c\xd1\x1f\x05\x03\x3a\xc4\xc6"
2822         "\x0c\x2e\xf6\xab\x40\x30\xfe\x82\x96\x24\x8d\xf1\x63\xf4\x49\x52" },
2823       { GCRY_MD_SHA384,
2824         "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.",
2825         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2826         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2827         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2828         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2829         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2830         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2831         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2832         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2833         "\xaa\xaa\xaa",
2834         "\x66\x17\x17\x8e\x94\x1f\x02\x0d\x35\x1e\x2f\x25\x4e\x8f\xd3\x2c"
2835         "\x60\x24\x20\xfe\xb0\xb8\xfb\x9a\xdc\xce\xbb\x82\x46\x1e\x99\xc5"
2836         "\xa6\x78\xcc\x31\xe7\x99\x17\x6d\x38\x60\xe6\x11\x0c\x46\x52\x3e" },
2837       { GCRY_MD_SHA512, "what do ya want for nothing?", "Jefe",
2838         "\x16\x4b\x7a\x7b\xfc\xf8\x19\xe2\xe3\x95\xfb\xe7\x3b\x56\xe0\xa3"
2839         "\x87\xbd\x64\x22\x2e\x83\x1f\xd6\x10\x27\x0c\xd7\xea\x25\x05\x54"
2840         "\x97\x58\xbf\x75\xc0\x5a\x99\x4a\x6d\x03\x4f\x65\xf8\xf0\xe6\xfd"
2841         "\xca\xea\xb1\xa3\x4d\x4a\x6b\x4b\x63\x6e\x07\x0a\x38\xbc\xe7\x37" },
2842       { GCRY_MD_SHA512,
2843         "Hi There",
2844         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2845         "\x0b\x0b\x0b",
2846         "\x87\xaa\x7c\xde\xa5\xef\x61\x9d\x4f\xf0\xb4\x24\x1a\x1d\x6c\xb0"
2847         "\x23\x79\xf4\xe2\xce\x4e\xc2\x78\x7a\xd0\xb3\x05\x45\xe1\x7c\xde"
2848         "\xda\xa8\x33\xb7\xd6\xb8\xa7\x02\x03\x8b\x27\x4e\xae\xa3\xf4\xe4"
2849         "\xbe\x9d\x91\x4e\xeb\x61\xf1\x70\x2e\x69\x6c\x20\x3a\x12\x68\x54" },
2850       { GCRY_MD_SHA512,
2851         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2852         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2853         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2854         "\xdd\xdd\xdd\xdd\xdd",
2855         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2856         "\xAA\xAA\xAA\xAA",
2857         "\xfa\x73\xb0\x08\x9d\x56\xa2\x84\xef\xb0\xf0\x75\x6c\x89\x0b\xe9"
2858         "\xb1\xb5\xdb\xdd\x8e\xe8\x1a\x36\x55\xf8\x3e\x33\xb2\x27\x9d\x39"
2859         "\xbf\x3e\x84\x82\x79\xa7\x22\xc8\x06\xb4\x85\xa4\x7e\x67\xc8\x07"
2860         "\xb9\x46\xa3\x37\xbe\xe8\x94\x26\x74\x27\x88\x59\xe1\x32\x92\xfb"  },
2861       { GCRY_MD_SHA512,
2862         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
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",
2866         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2867         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2868         "\xb0\xba\x46\x56\x37\x45\x8c\x69\x90\xe5\xa8\xc5\xf6\x1d\x4a\xf7"
2869         "\xe5\x76\xd9\x7f\xf9\x4b\x87\x2d\xe7\x6f\x80\x50\x36\x1e\xe3\xdb"
2870         "\xa9\x1c\xa5\xc1\x1a\xa2\x5e\xb4\xd6\x79\x27\x5c\xc5\x78\x80\x63"
2871         "\xa5\xf1\x97\x41\x12\x0c\x4f\x2d\xe2\xad\xeb\xeb\x10\xa2\x98\xdd" },
2872       { GCRY_MD_SHA512,
2873         "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\xaa"
2875         "\xaa\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\xaa"
2877         "\xaa\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\xaa"
2879         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2880         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2881         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2882         "\xaa\xaa\xaa",
2883         "\x80\xb2\x42\x63\xc7\xc1\xa3\xeb\xb7\x14\x93\xc1\xdd\x7b\xe8\xb4"
2884         "\x9b\x46\xd1\xf4\x1b\x4a\xee\xc1\x12\x1b\x01\x37\x83\xf8\xf3\x52"
2885         "\x6b\x56\xd0\x37\xe0\x5f\x25\x98\xbd\x0f\xd2\x21\x5d\x6a\x1e\x52"
2886         "\x95\xe6\x4f\x73\xf6\x3f\x0a\xec\x8b\x91\x5a\x98\x5d\x78\x65\x98" },
2887       { GCRY_MD_SHA512,
2888         "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.",
2889         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2890         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2891         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2892         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2893         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2894         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2895         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2896         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2897         "\xaa\xaa\xaa",
2898         "\xe3\x7b\x6a\x77\x5d\xc8\x7d\xba\xa4\xdf\xa9\xf9\x6e\x5e\x3f\xfd"
2899         "\xde\xbd\x71\xf8\x86\x72\x89\x86\x5d\xf5\xa3\x2d\x20\xcd\xc9\x44"
2900         "\xb6\x02\x2c\xac\x3c\x49\x82\xb1\x0d\x5e\xeb\x55\xc3\xe4\xde\x15"
2901         "\x13\x46\x76\xfb\x6d\xe0\x44\x60\x65\xc9\x74\x40\xfa\x8c\x6a\x58" },
2902       { 0 },
2903     };
2904   int i;
2905
2906   if (verbose)
2907     fprintf (stderr, "Starting hashed MAC checks.\n");
2908
2909   for (i = 0; algos[i].md; i++)
2910     {
2911       if ((gcry_md_test_algo (algos[i].md) || algos[i].md == GCRY_MD_MD5)
2912           && in_fips_mode)
2913         {
2914           if (verbose)
2915             fprintf (stderr, "  algorithm %d not available in fips mode\n",
2916                      algos[i].md);
2917           continue;
2918         }
2919       if (verbose)
2920         fprintf (stderr,
2921                  "  checking %s [%i] for %zi byte key and %zi byte data\n",
2922                  gcry_md_algo_name (algos[i].md),
2923                  algos[i].md,
2924                  strlen(algos[i].key), strlen(algos[i].data));
2925
2926       check_one_hmac (algos[i].md, algos[i].data, strlen (algos[i].data),
2927                       algos[i].key, strlen(algos[i].key),
2928                       algos[i].expect);
2929     }
2930
2931   if (verbose)
2932     fprintf (stderr, "Completed hashed MAC checks.\n");
2933  }
2934
2935 /* Check that the signature SIG matches the hash HASH. PKEY is the
2936    public key used for the verification. BADHASH is a hash value which
2937    should result in a bad signature status. */
2938 static void
2939 verify_one_signature (gcry_sexp_t pkey, gcry_sexp_t hash,
2940                       gcry_sexp_t badhash, gcry_sexp_t sig)
2941 {
2942   gcry_error_t rc;
2943
2944   rc = gcry_pk_verify (sig, hash, pkey);
2945   if (rc)
2946     fail ("gcry_pk_verify failed: %s\n", gpg_strerror (rc));
2947   rc = gcry_pk_verify (sig, badhash, pkey);
2948   if (gcry_err_code (rc) != GPG_ERR_BAD_SIGNATURE)
2949     fail ("gcry_pk_verify failed to detect a bad signature: %s\n",
2950           gpg_strerror (rc));
2951 }
2952
2953
2954 /* Test the public key sign function using the private ket SKEY. PKEY
2955    is used for verification. */
2956 static void
2957 check_pubkey_sign (int n, gcry_sexp_t skey, gcry_sexp_t pkey, int algo)
2958 {
2959   gcry_error_t rc;
2960   gcry_sexp_t sig, badhash, hash;
2961   int dataidx;
2962   static const char baddata[] =
2963     "(data\n (flags pkcs1)\n"
2964     " (hash sha1 #11223344556677889900AABBCCDDEEFF10203041#))\n";
2965   static struct
2966   {
2967     const char *data;
2968     int algo;
2969     int expected_rc;
2970   } datas[] =
2971     {
2972       { "(data\n (flags pkcs1)\n"
2973         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
2974         GCRY_PK_RSA,
2975         0 },
2976       { "(data\n (flags oaep)\n"
2977         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
2978         0,
2979         GPG_ERR_CONFLICT },
2980       /* This test is to see whether hash algorithms not hard wired in
2981          pubkey.c are detected:  */
2982       { "(data\n (flags pkcs1)\n"
2983         " (hash oid.1.3.14.3.2.29 "
2984         "       #11223344556677889900AABBCCDDEEFF10203040#))\n",
2985         GCRY_PK_RSA,
2986         0 },
2987       { "(data\n (flags )\n"
2988         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
2989         0,
2990         GPG_ERR_CONFLICT },
2991       { "(data\n (flags pkcs1)\n"
2992         " (hash foo #11223344556677889900AABBCCDDEEFF10203040#))\n",
2993         GCRY_PK_RSA,
2994         GPG_ERR_DIGEST_ALGO },
2995       { "(data\n (flags )\n" " (value #11223344556677889900AA#))\n",
2996         0,
2997         0 },
2998       { "(data\n (flags )\n" " (value #0090223344556677889900AA#))\n",
2999         0,
3000         0 },
3001       { "(data\n (flags raw)\n" " (value #11223344556677889900AA#))\n",
3002         0,
3003         0 },
3004       { "(data\n (flags pkcs1)\n"
3005         " (value #11223344556677889900AA#))\n",
3006         GCRY_PK_RSA,
3007         GPG_ERR_CONFLICT },
3008       { "(data\n (flags raw foo)\n"
3009         " (value #11223344556677889900AA#))\n",
3010         0,
3011         GPG_ERR_INV_FLAG },
3012       { "(data\n (flags pss)\n"
3013         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
3014         GCRY_PK_RSA,
3015         0 },
3016       { "(data\n (flags pss)\n"
3017         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#)\n"
3018         " (random-override #4253647587980912233445566778899019283747#))\n",
3019         GCRY_PK_RSA,
3020         0 },
3021       { NULL }
3022     };
3023
3024   rc = gcry_sexp_sscan (&badhash, NULL, baddata, strlen (baddata));
3025   if (rc)
3026     die ("converting data failed: %s\n", gpg_strerror (rc));
3027
3028   for (dataidx = 0; datas[dataidx].data; dataidx++)
3029     {
3030       if (datas[dataidx].algo && datas[dataidx].algo != algo)
3031         continue;
3032
3033       if (verbose)
3034         fprintf (stderr, "  test %d, signature test %d\n", n, dataidx);
3035
3036       rc = gcry_sexp_sscan (&hash, NULL, datas[dataidx].data,
3037                             strlen (datas[dataidx].data));
3038       if (rc)
3039         die ("converting data failed: %s\n", gpg_strerror (rc));
3040
3041       rc = gcry_pk_sign (&sig, hash, skey);
3042       if (gcry_err_code (rc) != datas[dataidx].expected_rc)
3043         fail ("gcry_pk_sign failed: %s\n", gpg_strerror (rc));
3044
3045       if (!rc)
3046         verify_one_signature (pkey, hash, badhash, sig);
3047
3048       gcry_sexp_release (sig);
3049       sig = NULL;
3050       gcry_sexp_release (hash);
3051       hash = NULL;
3052     }
3053
3054   gcry_sexp_release (badhash);
3055 }
3056
3057
3058 /* Test the public key sign function using the private ket SKEY. PKEY
3059    is used for verification.  This variant is only used for ECDSA.  */
3060 static void
3061 check_pubkey_sign_ecdsa (int n, gcry_sexp_t skey, gcry_sexp_t pkey)
3062 {
3063   gcry_error_t rc;
3064   gcry_sexp_t sig, badhash, hash;
3065   unsigned int nbits;
3066   int dataidx;
3067   static struct
3068   {
3069     unsigned int nbits;
3070     const char *data;
3071     int expected_rc;
3072     const char *baddata;
3073     int dummy;
3074   } datas[] =
3075     {
3076       { 256,
3077         "(data (flags raw)\n"
3078         " (value #00112233445566778899AABBCCDDEEFF"
3079         /* */    "000102030405060708090A0B0C0D0E0F#))",
3080         0,
3081         "(data (flags raw)\n"
3082         " (value #80112233445566778899AABBCCDDEEFF"
3083         /* */    "000102030405060708090A0B0C0D0E0F#))",
3084         0
3085       },
3086       { 192,
3087         "(data (flags raw)\n"
3088         " (value #00112233445566778899AABBCCDDEEFF0001020304050607#))",
3089         0,
3090         "(data (flags raw)\n"
3091         " (value #80112233445566778899AABBCCDDEEFF0001020304050607#))",
3092         0
3093       },
3094       { 0, NULL }
3095     };
3096
3097   nbits = gcry_pk_get_nbits (skey);
3098
3099   for (dataidx = 0; datas[dataidx].data; dataidx++)
3100     {
3101       if (datas[dataidx].nbits != nbits)
3102         continue;
3103
3104       if (verbose)
3105         fprintf (stderr, "  test %d, signature test %d (%u bit ecdsa)\n",
3106                  n, dataidx, nbits);
3107
3108       rc = gcry_sexp_sscan (&hash, NULL, datas[dataidx].data,
3109                             strlen (datas[dataidx].data));
3110       if (rc)
3111         die ("converting data failed: %s\n", gpg_strerror (rc));
3112       rc = gcry_sexp_sscan (&badhash, NULL, datas[dataidx].baddata,
3113                             strlen (datas[dataidx].baddata));
3114       if (rc)
3115         die ("converting data failed: %s\n", gpg_strerror (rc));
3116
3117       rc = gcry_pk_sign (&sig, hash, skey);
3118       if (gcry_err_code (rc) != datas[dataidx].expected_rc)
3119         fail ("gcry_pk_sign failed: %s\n", gpg_strerror (rc));
3120
3121       if (!rc && verbose > 1)
3122         show_sexp ("ECDSA signature:\n", sig);
3123
3124       if (!rc)
3125         verify_one_signature (pkey, hash, badhash, sig);
3126
3127       gcry_sexp_release (sig);
3128       sig = NULL;
3129       gcry_sexp_release (badhash);
3130       badhash = NULL;
3131       gcry_sexp_release (hash);
3132       hash = NULL;
3133     }
3134 }
3135
3136
3137 static void
3138 check_pubkey_crypt (int n, gcry_sexp_t skey, gcry_sexp_t pkey, int algo)
3139 {
3140   gcry_error_t rc;
3141   gcry_sexp_t plain, ciph, data;
3142   int dataidx;
3143   static struct
3144   {
3145     int algo;    /* If not 0 run test only if ALGO matches.  */
3146     const char *data;
3147     const char *hint;
3148     int unpadded;
3149     int encrypt_expected_rc;
3150     int decrypt_expected_rc;
3151   } datas[] =
3152     {
3153       { GCRY_PK_RSA,
3154         "(data\n (flags pkcs1)\n"
3155         " (value #11223344556677889900AA#))\n",
3156         NULL,
3157         0,
3158         0,
3159         0 },
3160       { GCRY_PK_RSA,
3161         "(data\n (flags pkcs1)\n"
3162         " (value #11223344556677889900AA#))\n",
3163         "(flags pkcs1)",
3164         1,
3165         0,
3166         0 },
3167       { GCRY_PK_RSA,
3168         "(data\n (flags oaep)\n"
3169         " (value #11223344556677889900AA#))\n",
3170         "(flags oaep)",
3171         1,
3172         0,
3173         0 },
3174       { GCRY_PK_RSA,
3175         "(data\n (flags oaep)\n (hash-algo sha1)\n"
3176         " (value #11223344556677889900AA#))\n",
3177         "(flags oaep)(hash-algo sha1)",
3178         1,
3179         0,
3180         0 },
3181       { GCRY_PK_RSA,
3182         "(data\n (flags oaep)\n (hash-algo sha1)\n (label \"test\")\n"
3183         " (value #11223344556677889900AA#))\n",
3184         "(flags oaep)(hash-algo sha1)(label \"test\")",
3185         1,
3186         0,
3187         0 },
3188       { GCRY_PK_RSA,
3189         "(data\n (flags oaep)\n (hash-algo sha1)\n (label \"test\")\n"
3190         " (value #11223344556677889900AA#)\n"
3191         " (random-override #4253647587980912233445566778899019283747#))\n",
3192         "(flags oaep)(hash-algo sha1)(label \"test\")",
3193         1,
3194         0,
3195         0 },
3196       { 0,
3197         "(data\n (flags )\n" " (value #11223344556677889900AA#))\n",
3198         NULL,
3199         1,
3200         0,
3201         0 },
3202       { 0,
3203         "(data\n (flags )\n" " (value #0090223344556677889900AA#))\n",
3204         NULL,
3205         1,
3206         0,
3207         0 },
3208       { 0,
3209         "(data\n (flags raw)\n" " (value #11223344556677889900AA#))\n",
3210         NULL,
3211         1,
3212         0,
3213         0 },
3214       { GCRY_PK_RSA,
3215         "(data\n (flags pkcs1)\n"
3216         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
3217         NULL,
3218         0,
3219         GPG_ERR_CONFLICT,
3220         0},
3221       { 0,
3222         "(data\n (flags raw foo)\n"
3223         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
3224         NULL,
3225         0,
3226         GPG_ERR_INV_FLAG,
3227         0},
3228       { 0,
3229         "(data\n (flags raw)\n"
3230         " (value #11223344556677889900AA#))\n",
3231         "(flags oaep)",
3232         1,
3233         0,
3234         GPG_ERR_ENCODING_PROBLEM },
3235       { GCRY_PK_RSA,
3236         "(data\n (flags oaep)\n"
3237         " (value #11223344556677889900AA#))\n",
3238         "(flags pkcs1)",
3239         1,
3240         0,
3241         GPG_ERR_ENCODING_PROBLEM },
3242       { 0,
3243         "(data\n (flags pss)\n"
3244         " (value #11223344556677889900AA#))\n",
3245         NULL,
3246         0,
3247         GPG_ERR_CONFLICT },
3248       { 0, NULL }
3249     };
3250
3251   (void)n;
3252
3253   for (dataidx = 0; datas[dataidx].data; dataidx++)
3254     {
3255       if (datas[dataidx].algo && datas[dataidx].algo != algo)
3256         continue;
3257
3258       if (verbose)
3259         fprintf (stderr, "  encryption/decryption test %d (algo %d)\n",
3260                  dataidx, algo);
3261
3262       rc = gcry_sexp_sscan (&data, NULL, datas[dataidx].data,
3263                             strlen (datas[dataidx].data));
3264       if (rc)
3265         die ("converting data failed: %s\n", gpg_strerror (rc));
3266
3267       rc = gcry_pk_encrypt (&ciph, data, pkey);
3268       if (gcry_err_code (rc) != datas[dataidx].encrypt_expected_rc)
3269         fail ("gcry_pk_encrypt failed: %s\n", gpg_strerror (rc));
3270
3271       if (!rc)
3272         {
3273           /* Insert decoding hint to CIPH. */
3274           if (datas[dataidx].hint)
3275             {
3276               size_t hint_len, len;
3277               char *hint, *buf;
3278               gcry_sexp_t list;
3279
3280               /* Convert decoding hint into canonical sexp. */
3281               hint_len = gcry_sexp_new (&list, datas[dataidx].hint,
3282                                         strlen (datas[dataidx].hint), 1);
3283               hint_len = gcry_sexp_sprint (list, GCRYSEXP_FMT_CANON, NULL, 0);
3284               hint = gcry_malloc (hint_len);
3285               if (!hint)
3286                 die ("can't allocate memory\n");
3287               hint_len = gcry_sexp_sprint (list, GCRYSEXP_FMT_CANON, hint,
3288                                            hint_len);
3289               gcry_sexp_release (list);
3290
3291               /* Convert CIPH into canonical sexp. */
3292               len = gcry_sexp_sprint (ciph, GCRYSEXP_FMT_CANON, NULL, 0);
3293               buf = gcry_malloc (len + hint_len);
3294               if (!buf)
3295                 die ("can't allocate memory\n");
3296               len = gcry_sexp_sprint (ciph, GCRYSEXP_FMT_CANON, buf, len);
3297               /* assert (!strcmp (buf, "(7:enc-val", 10)); */
3298
3299               /* Copy decoding hint into CIPH. */
3300               memmove (buf + 10 + hint_len, buf + 10, len - 10);
3301               memcpy (buf + 10, hint, hint_len);
3302               gcry_free (hint);
3303               gcry_sexp_new (&list, buf, len + hint_len, 1);
3304               gcry_free (buf);
3305               gcry_sexp_release (ciph);
3306               ciph = list;
3307             }
3308           rc = gcry_pk_decrypt (&plain, ciph, skey);
3309           if (gcry_err_code (rc) != datas[dataidx].decrypt_expected_rc)
3310             fail ("gcry_pk_decrypt failed: %s\n", gpg_strerror (rc));
3311
3312           if (!rc && datas[dataidx].unpadded)
3313             {
3314               gcry_sexp_t p1, p2;
3315
3316               p1 = gcry_sexp_find_token (data, "value", 0);
3317               p2 = gcry_sexp_find_token (plain, "value", 0);
3318               if (p1 && p2)
3319                 {
3320                   const char *s1, *s2;
3321                   size_t n1, n2;
3322
3323                   s1 = gcry_sexp_nth_data (p1, 1, &n1);
3324                   s2 = gcry_sexp_nth_data (p2, 1, &n2);
3325                   if (n1 != n2 || memcmp (s1, s2, n1))
3326                     fail ("gcry_pk_encrypt/gcry_pk_decrypt do not roundtrip\n");
3327                 }
3328               gcry_sexp_release (p1);
3329               gcry_sexp_release (p2);
3330             }
3331         }
3332
3333       gcry_sexp_release (plain);
3334       plain = NULL;
3335       gcry_sexp_release (ciph);
3336       ciph = NULL;
3337       gcry_sexp_release (data);
3338       data = NULL;
3339     }
3340 }
3341
3342 static void
3343 check_pubkey_grip (int n, const unsigned char *grip,
3344                    gcry_sexp_t skey, gcry_sexp_t pkey, int algo)
3345 {
3346   unsigned char sgrip[20], pgrip[20];
3347
3348   (void)algo;
3349
3350   if (!gcry_pk_get_keygrip (skey, sgrip))
3351     die ("get keygrip for private RSA key failed\n");
3352   if (!gcry_pk_get_keygrip (pkey, pgrip))
3353     die ("[%i] get keygrip for public RSA key failed\n", n);
3354   if (memcmp (sgrip, pgrip, 20))
3355     fail ("[%i] keygrips don't match\n", n);
3356   if (memcmp (sgrip, grip, 20))
3357     fail ("wrong keygrip for RSA key\n");
3358 }
3359
3360 static void
3361 do_check_one_pubkey (int n, gcry_sexp_t skey, gcry_sexp_t pkey,
3362                      const unsigned char *grip, int algo, int flags)
3363 {
3364  if (flags & FLAG_SIGN)
3365    {
3366      if (algo == GCRY_PK_ECDSA)
3367        check_pubkey_sign_ecdsa (n, skey, pkey);
3368      else
3369        check_pubkey_sign (n, skey, pkey, algo);
3370    }
3371  if (flags & FLAG_CRYPT)
3372    check_pubkey_crypt (n, skey, pkey, algo);
3373  if (grip && (flags & FLAG_GRIP))
3374    check_pubkey_grip (n, grip, skey, pkey, algo);
3375 }
3376
3377 static void
3378 check_one_pubkey (int n, test_spec_pubkey_t spec)
3379 {
3380   gcry_error_t err = GPG_ERR_NO_ERROR;
3381   gcry_sexp_t skey, pkey;
3382
3383   err = gcry_sexp_sscan (&skey, NULL, spec.key.secret,
3384                          strlen (spec.key.secret));
3385   if (!err)
3386     err = gcry_sexp_sscan (&pkey, NULL, spec.key.public,
3387                            strlen (spec.key.public));
3388   if (err)
3389     die ("converting sample key failed: %s\n", gpg_strerror (err));
3390
3391   do_check_one_pubkey (n, skey, pkey,
3392                        (const unsigned char*)spec.key.grip,
3393                        spec.id, spec.flags);
3394
3395   gcry_sexp_release (skey);
3396   gcry_sexp_release (pkey);
3397 }
3398
3399 static void
3400 get_keys_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
3401 {
3402   gcry_sexp_t key_spec, key, pub_key, sec_key;
3403   int rc;
3404   if (verbose)
3405     fprintf (stderr, "  generating RSA key:");
3406   rc = gcry_sexp_new (&key_spec,
3407                       in_fips_mode ? "(genkey (rsa (nbits 4:1024)))"
3408                       : "(genkey (rsa (nbits 4:1024)(transient-key)))",
3409                       0, 1);
3410   if (rc)
3411     die ("error creating S-expression: %s\n", gpg_strerror (rc));
3412   rc = gcry_pk_genkey (&key, key_spec);
3413   gcry_sexp_release (key_spec);
3414   if (rc)
3415     die ("error generating RSA key: %s\n", gpg_strerror (rc));
3416
3417   pub_key = gcry_sexp_find_token (key, "public-key", 0);
3418   if (! pub_key)
3419     die ("public part missing in key\n");
3420
3421   sec_key = gcry_sexp_find_token (key, "private-key", 0);
3422   if (! sec_key)
3423     die ("private part missing in key\n");
3424
3425   gcry_sexp_release (key);
3426   *pkey = pub_key;
3427   *skey = sec_key;
3428 }
3429
3430 static void
3431 check_one_pubkey_new (int n)
3432 {
3433   gcry_sexp_t skey, pkey;
3434
3435   get_keys_new (&pkey, &skey);
3436   do_check_one_pubkey (n, skey, pkey, NULL,
3437                        GCRY_PK_RSA, FLAG_SIGN | FLAG_CRYPT);
3438   gcry_sexp_release (pkey);
3439   gcry_sexp_release (skey);
3440 }
3441
3442 /* Run all tests for the public key functions. */
3443 static void
3444 check_pubkey (void)
3445 {
3446   test_spec_pubkey_t pubkeys[] = {
3447   {
3448     GCRY_PK_RSA, FLAG_CRYPT | FLAG_SIGN,
3449     {
3450       "(private-key\n"
3451       " (rsa\n"
3452       "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
3453       "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
3454       "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
3455       "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea2"
3456       "      51#)\n"
3457       "  (e #010001#)\n"
3458       "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
3459       "      7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
3460       "      C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
3461       "      C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781"
3462       "      #)\n"
3463       "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
3464       "      fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424"
3465       "      f1#)\n"
3466       "  (q #00f7a7ca5367c661f8e62df34f0d05c10c88e5492348dd7bddc942c9a8f369f9"
3467       "      35a07785d2db805215ed786e4285df1658eed3ce84f469b81b50d358407b4ad3"
3468       "      61#)\n"
3469       "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
3470       "      ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b"
3471       "      #)))\n",
3472
3473       "(public-key\n"
3474       " (rsa\n"
3475       "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
3476       "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
3477       "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
3478       "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea2"
3479       "      51#)\n"
3480       "  (e #010001#)))\n",
3481
3482       "\x32\x10\x0c\x27\x17\x3e\xf6\xe9\xc4\xe9"
3483       "\xa2\x5d\x3d\x69\xf8\x6d\x37\xa4\xf9\x39"}
3484   },
3485   {
3486     GCRY_PK_DSA, FLAG_SIGN,
3487     {
3488       "(private-key\n"
3489       " (DSA\n"
3490       "  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
3491       "      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
3492       "      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
3493       "      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D877"
3494       "      7B#)\n"
3495       "  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)\n"
3496       "  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
3497       "      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
3498       "      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
3499       "      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15"
3500       "      #)\n"
3501       "  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
3502       "      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
3503       "      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
3504       "      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB"
3505       "      #)\n"
3506       "  (x #11D54E4ADBD3034160F2CED4B7CD292A4EBF3EC0#)))\n",
3507
3508       "(public-key\n"
3509       " (DSA\n"
3510       "  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
3511       "      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
3512       "      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
3513       "      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D877"
3514       "      7B#)\n"
3515       "  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)\n"
3516       "  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
3517       "      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
3518       "      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
3519       "      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15"
3520       "      #)\n"
3521       "  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
3522       "      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
3523       "      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
3524       "      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB"
3525       "      #)))\n",
3526
3527       "\xc6\x39\x83\x1a\x43\xe5\x05\x5d\xc6\xd8"
3528       "\x4a\xa6\xf9\xeb\x23\xbf\xa9\x12\x2d\x5b" }
3529   },
3530   {
3531     GCRY_PK_ELG, FLAG_SIGN | FLAG_CRYPT,
3532     {
3533       "(private-key\n"
3534       " (ELG\n"
3535       "  (p #00B93B93386375F06C2D38560F3B9C6D6D7B7506B20C1773F73F8DE56E6CD65D"
3536       "      F48DFAAA1E93F57A2789B168362A0F787320499F0B2461D3A4268757A7B27517"
3537       "      B7D203654A0CD484DEC6AF60C85FEB84AAC382EAF2047061FE5DAB81A20A0797"
3538       "      6E87359889BAE3B3600ED718BE61D4FC993CC8098A703DD0DC942E965E8F18D2"
3539       "      A7#)\n"
3540       "  (g #05#)\n"
3541       "  (y #72DAB3E83C9F7DD9A931FDECDC6522C0D36A6F0A0FEC955C5AC3C09175BBFF2B"
3542       "      E588DB593DC2E420201BEB3AC17536918417C497AC0F8657855380C1FCF11C5B"
3543       "      D20DB4BEE9BDF916648DE6D6E419FA446C513AAB81C30CB7B34D6007637BE675"
3544       "      56CE6473E9F9EE9B9FADD275D001563336F2186F424DEC6199A0F758F6A00FF4"
3545       "      #)\n"
3546       "  (x #03C28900087B38DABF4A0AB98ACEA39BB674D6557096C01D72E31C16BDD32214"
3547       "      #)))\n",
3548
3549       "(public-key\n"
3550       " (ELG\n"
3551       "  (p #00B93B93386375F06C2D38560F3B9C6D6D7B7506B20C1773F73F8DE56E6CD65D"
3552       "      F48DFAAA1E93F57A2789B168362A0F787320499F0B2461D3A4268757A7B27517"
3553       "      B7D203654A0CD484DEC6AF60C85FEB84AAC382EAF2047061FE5DAB81A20A0797"
3554       "      6E87359889BAE3B3600ED718BE61D4FC993CC8098A703DD0DC942E965E8F18D2"
3555       "      A7#)\n"
3556       "  (g #05#)\n"
3557       "  (y #72DAB3E83C9F7DD9A931FDECDC6522C0D36A6F0A0FEC955C5AC3C09175BBFF2B"
3558       "      E588DB593DC2E420201BEB3AC17536918417C497AC0F8657855380C1FCF11C5B"
3559       "      D20DB4BEE9BDF916648DE6D6E419FA446C513AAB81C30CB7B34D6007637BE675"
3560       "      56CE6473E9F9EE9B9FADD275D001563336F2186F424DEC6199A0F758F6A00FF4"
3561       "      #)))\n",
3562
3563       "\xa7\x99\x61\xeb\x88\x83\xd2\xf4\x05\xc8"
3564       "\x4f\xba\x06\xf8\x78\x09\xbc\x1e\x20\xe5" }
3565   },
3566   { /* ECDSA test.  */
3567     GCRY_PK_ECDSA, FLAG_SIGN,
3568     {
3569       "(private-key\n"
3570       " (ecdsa\n"
3571       "  (curve nistp192)\n"
3572       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3573       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
3574       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
3575
3576       "(public-key\n"
3577       " (ecdsa\n"
3578       "  (curve nistp192)\n"
3579       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3580       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
3581
3582       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3583       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
3584   },
3585   { /* ECDSA test with the public key algorithm given as "ecc".  */
3586     GCRY_PK_ECDSA, FLAG_SIGN,
3587     {
3588       "(private-key\n"
3589       " (ecdsa\n"
3590       "  (curve nistp192)\n"
3591       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3592       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
3593       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
3594
3595       "(public-key\n"
3596       " (ecc\n"
3597       "  (curve nistp192)\n"
3598       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3599       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
3600
3601       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3602       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
3603   },
3604   { /* ECDSA test with the private key algorithm given as "ecc".  */
3605     GCRY_PK_ECDSA, FLAG_SIGN,
3606     {
3607       "(private-key\n"
3608       " (ecc\n"
3609       "  (curve nistp192)\n"
3610       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3611       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
3612       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
3613
3614       "(public-key\n"
3615       " (ecdsa\n"
3616       "  (curve nistp192)\n"
3617       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3618       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
3619
3620       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3621       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
3622   },
3623   { /* ECDSA test with the key algorithms given as "ecc".  */
3624     GCRY_PK_ECDSA, FLAG_SIGN,
3625     {
3626       "(private-key\n"
3627       " (ecc\n"
3628       "  (curve nistp192)\n"
3629       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3630       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
3631       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
3632
3633       "(public-key\n"
3634       " (ecc\n"
3635       "  (curve nistp192)\n"
3636       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
3637       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
3638
3639       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3640       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
3641   },
3642   { /* ECDSA test 256 bit.  */
3643     GCRY_PK_ECDSA, FLAG_SIGN,
3644     {
3645       "(private-key\n"
3646       " (ecc\n"
3647       "  (curve nistp256)\n"
3648       "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2B"
3649       "      EB6644D3609FC781B71F9A8072F58CB66AE2F89BB1245187"
3650       "      3ABF7D91F9E1FBF96BF2F70E73AAC9A283#)\n"
3651       "  (d #5A1EF0035118F19F3110FB81813D3547BCE1E5BCE77D1F74"
3652       "      4715E1D5BBE70378#)))\n",
3653
3654       "(public-key\n"
3655       " (ecc\n"
3656       "  (curve nistp256)\n"
3657       "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2B"
3658       "      EB6644D3609FC781B71F9A8072F58CB66AE2F89BB1245187"
3659       "      3ABF7D91F9E1FBF96BF2F70E73AAC9A283#)))\n"
3660
3661       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
3662       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
3663     }
3664   };
3665   int i;
3666
3667   if (verbose)
3668     fprintf (stderr, "Starting public key checks.\n");
3669   for (i = 0; i < sizeof (pubkeys) / sizeof (*pubkeys); i++)
3670     if (pubkeys[i].id)
3671       {
3672         if (gcry_pk_test_algo (pubkeys[i].id) && in_fips_mode)
3673           {
3674             if (verbose)
3675               fprintf (stderr, "  algorithm %d not available in fips mode\n",
3676                        pubkeys[i].id);
3677             continue;
3678           }
3679         check_one_pubkey (i, pubkeys[i]);
3680       }
3681   if (verbose)
3682     fprintf (stderr, "Completed public key checks.\n");
3683
3684   if (verbose)
3685     fprintf (stderr, "Starting additional public key checks.\n");
3686   for (i = 0; i < sizeof (pubkeys) / sizeof (*pubkeys); i++)
3687     if (pubkeys[i].id)
3688       {
3689         if (gcry_pk_test_algo (pubkeys[i].id) && in_fips_mode)
3690           {
3691             if (verbose)
3692               fprintf (stderr, "  algorithm %d not available in fips mode\n",
3693                        pubkeys[i].id);
3694             continue;
3695           }
3696         check_one_pubkey_new (i);
3697       }
3698   if (verbose)
3699     fprintf (stderr, "Completed additional public key checks.\n");
3700
3701 }
3702
3703 int
3704 main (int argc, char **argv)
3705 {
3706   gpg_error_t err;
3707   int last_argc = -1;
3708   int debug = 0;
3709   int use_fips = 0;
3710   int selftest_only = 0;
3711
3712   if (argc)
3713     { argc--; argv++; }
3714
3715   while (argc && last_argc != argc )
3716     {
3717       last_argc = argc;
3718       if (!strcmp (*argv, "--"))
3719         {
3720           argc--; argv++;
3721           break;
3722         }
3723       else if (!strcmp (*argv, "--verbose"))
3724         {
3725           verbose++;
3726           argc--; argv++;
3727         }
3728       else if (!strcmp (*argv, "--debug"))
3729         {
3730           verbose = debug = 1;
3731           argc--; argv++;
3732         }
3733       else if (!strcmp (*argv, "--fips"))
3734         {
3735           use_fips = 1;
3736           argc--; argv++;
3737         }
3738       else if (!strcmp (*argv, "--selftest"))
3739         {
3740           selftest_only = 1;
3741           verbose += 2;
3742           argc--; argv++;
3743         }
3744       else if (!strcmp (*argv, "--die"))
3745         {
3746           die_on_error = 1;
3747           argc--; argv++;
3748         }
3749     }
3750
3751   gcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
3752
3753   if (use_fips)
3754     gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
3755
3756   /* Check that we test exactly our version - including the patchlevel.  */
3757   if (strcmp (GCRYPT_VERSION, gcry_check_version (NULL)))
3758     die ("version mismatch; pgm=%s, library=%s\n",
3759          GCRYPT_VERSION,gcry_check_version (NULL));
3760
3761   if ( gcry_fips_mode_active () )
3762     in_fips_mode = 1;
3763
3764   if (!in_fips_mode)
3765     gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
3766
3767   if (verbose)
3768     gcry_set_progress_handler (progress_handler, NULL);
3769
3770   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
3771   if (debug)
3772     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
3773   /* No valuable keys are create, so we can speed up our RNG. */
3774   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
3775
3776   if (!selftest_only)
3777     {
3778       check_ciphers ();
3779       check_cipher_modes ();
3780       check_bulk_cipher_modes ();
3781       check_digests ();
3782       check_hmac ();
3783       check_pubkey ();
3784     }
3785
3786
3787   if (in_fips_mode && !selftest_only)
3788     {
3789       /* If we are in fips mode do some more tests. */
3790       gcry_md_hd_t md;
3791
3792       /* First trigger a self-test.  */
3793       gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
3794       if (!gcry_control (GCRYCTL_OPERATIONAL_P, 0))
3795         fail ("not in operational state after self-test\n");
3796
3797       /* Get us into the error state.  */
3798       err = gcry_md_open (&md, GCRY_MD_SHA1, 0);
3799       if (err)
3800         fail ("failed to open SHA-1 hash context: %s\n", gpg_strerror (err));
3801       else
3802         {
3803           err = gcry_md_enable (md, GCRY_MD_SHA256);
3804           if (err)
3805             fail ("failed to add SHA-256 hash context: %s\n",
3806                   gpg_strerror (err));
3807           else
3808             {
3809               /* gcry_md_get_algo is only defined for a context with
3810                  just one digest algorithm.  With our setup it should
3811                  put the oibrary intoerror state.  */
3812               fputs ("Note: Two lines with error messages follow "
3813                      "- this is expected\n", stderr);
3814               gcry_md_get_algo (md);
3815               gcry_md_close (md);
3816               if (gcry_control (GCRYCTL_OPERATIONAL_P, 0))
3817                 fail ("expected error state but still in operational state\n");
3818               else
3819                 {
3820                   /* Now run a self-test and to get back into
3821                      operational state.  */
3822                   gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
3823                   if (!gcry_control (GCRYCTL_OPERATIONAL_P, 0))
3824                     fail ("did not reach operational after error "
3825                           "and self-test\n");
3826                 }
3827             }
3828         }
3829
3830     }
3831   else
3832     {
3833       /* If in standard mode, run selftests.  */
3834       if (gcry_control (GCRYCTL_SELFTEST, 0))
3835         fail ("running self-test failed\n");
3836     }
3837
3838   if (verbose)
3839     fprintf (stderr, "\nAll tests completed. Errors: %i\n", error_count);
3840
3841   if (in_fips_mode && !gcry_fips_mode_active ())
3842     fprintf (stderr, "FIPS mode is not anymore active\n");
3843
3844   return error_count ? 1 : 0;
3845 }