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