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