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