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