Add crypto hash SM3.
[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       { GCRY_CIPHER_AES, 1,
898         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
899         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
900         { { "\x6b",
901             1,
902             "\x3b"},
903           { "\xc1",
904             1,
905             "\x79"},
906           { "\xbe",
907             1,
908             "\x42"},
909           { "\xe2",
910             1,
911             "\x4c"},
912         }
913       },
914       { GCRY_CIPHER_AES192, 1,
915         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b\x80\x90\x79\xe5"
916         "\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
917         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
918         { { "\x6b",
919             1,
920             "\xcd"},
921           { "\xc1",
922             1,
923             "\xa2"},
924           { "\xbe",
925             1,
926             "\x52"},
927           { "\xe2",
928             1,
929             "\x1e"},
930         }
931       },
932       { GCRY_CIPHER_AES256, 1,
933         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
934         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
935         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
936         { { "\x6b",
937             1,
938             "\xdc"},
939           { "\xc1",
940             1,
941             "\x1f"},
942           { "\xbe",
943             1,
944             "\x1a"},
945           { "\xe2",
946             1,
947             "\x85"},
948         }
949       },
950       { GCRY_CIPHER_AES, 1,
951         "\x3a\x6f\x91\x59\x26\x3f\xa6\xce\xf2\xa0\x75\xca\xfa\xce\x58\x17",
952         "\x0f\xc2\x36\x62\xb7\xdb\xf7\x38\x27\xf0\xc7\xde\x32\x1c\xa3\x6e",
953         { { "\x87\xef\xeb\x8d\x55\x9e\xd3\x36\x77\x28",
954             10,
955             "\x8e\x9c\x50\x42\x56\x14\xd5\x40\xce\x11"},
956         }
957       },
958       { GCRY_CIPHER_AES192, 1,
959         "\x53\x7e\x7b\xf6\x61\xfd\x40\x24\xa0\x24\x61\x3f\x15\xb1\x36\x90"
960         "\xf7\xd0\xc8\x47\xc1\xe1\x89\x65",
961         "\x3a\x81\xf9\xd9\xd3\xc1\x55\xb0\xca\xad\x5d\x73\x34\x94\x76\xfc",
962         { { "\xd3\xd8\xb9\xb9\x84\xad\xc2\x42\x37\xee",
963             10,
964             "\x38\x79\xfe\xa7\x2a\xc9\x99\x29\xe5\x3a"},
965         }
966       },
967       { GCRY_CIPHER_AES256, 1,
968         "\xeb\xbb\x45\x66\xb5\xe1\x82\xe0\xf0\x72\x46\x6b\x0b\x31\x1d\xf3"
969         "\x8f\x91\x75\xbc\x02\x13\xa5\x53\x0b\xce\x2e\xc4\xd7\x4f\x40\x0d",
970         "\x09\x56\xa4\x8e\x01\x00\x2c\x9e\x16\x37\x6d\x6e\x30\x8d\xba\xd1",
971         { { "\xb0\xfe\x25\xac\x8d\x3d\x28\xa2\xf4\x71",
972             10,
973             "\x63\x8c\x68\x23\xe7\x25\x6f\xb5\x62\x6e"},
974         }
975       },
976       { GCRY_CIPHER_3DES, 1,
977         "\xe3\x34\x7a\x6b\x0b\xc1\x15\x2c\x64\x2a\x25\xcb\xd3\xbc\x31\xab"
978         "\xfb\xa1\x62\xa8\x1f\x19\x7c\x15",
979         "\xb7\x40\xcc\x21\xe9\x25\xe3\xc8",
980         { { "\xdb\xe9\x15\xfc\xb3\x3b\xca\x18\xef\x14",
981             10,
982             "\xf4\x80\x1a\x8d\x03\x9d\xb4\xca\x8f\xf6"},
983         }
984       },
985       { GCRY_CIPHER_3DES, 1,
986         "\x7c\xa2\x89\x38\xba\x6b\xec\x1f\xfe\xc7\x8f\x7c\xd6\x97\x61\x94"
987         "\x7c\xa2\x89\x38\xba\x6b\xec\x1f",
988         "\x95\x38\x96\x58\x6e\x49\xd3\x8f",
989         { { "\x2e\xa9\x56\xd4\xa2\x11\xdb\x68\x59\xb7",
990             10,
991             "\xf2\x0e\x53\x66\x74\xa6\x6f\xa7\x38\x05"},
992         }
993       },
994     };
995   gcry_cipher_hd_t hde, hdd;
996   unsigned char out[MAX_DATA_LEN];
997   int i, j, keylen, blklen, mode;
998   gcry_error_t err = 0;
999
1000   if (verbose)
1001     fprintf (stderr, "  Starting CFB checks.\n");
1002
1003   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
1004     {
1005       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
1006         {
1007           if (verbose)
1008             fprintf (stderr, "  algorithm %d not available in fips mode\n",
1009                      tv[i].algo);
1010           continue;
1011         }
1012
1013       mode = tv[i].cfb8? GCRY_CIPHER_MODE_CFB8 : GCRY_CIPHER_MODE_CFB;
1014
1015       if (verbose)
1016         fprintf (stderr, "    checking CFB mode for %s [%i]\n",
1017                  gcry_cipher_algo_name (tv[i].algo),
1018                  tv[i].algo);
1019       err = gcry_cipher_open (&hde, tv[i].algo, mode, 0);
1020       if (!err)
1021         err = gcry_cipher_open (&hdd, tv[i].algo, mode, 0);
1022       if (err)
1023         {
1024           fail ("aes-cfb, gcry_cipher_open failed: %s\n", gpg_strerror (err));
1025           return;
1026         }
1027
1028       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
1029       if (!keylen)
1030         {
1031           fail ("aes-cfb, gcry_cipher_get_algo_keylen failed\n");
1032           return;
1033         }
1034
1035       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
1036       if (!err)
1037         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
1038       if (err)
1039         {
1040           fail ("aes-cfb, gcry_cipher_setkey failed: %s\n",
1041                 gpg_strerror (err));
1042           gcry_cipher_close (hde);
1043           gcry_cipher_close (hdd);
1044           return;
1045         }
1046
1047       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
1048       if (!blklen)
1049         {
1050           fail ("aes-cfb, gcry_cipher_get_algo_blklen failed\n");
1051           return;
1052         }
1053
1054       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
1055       if (!err)
1056         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
1057       if (err)
1058         {
1059           fail ("aes-cfb, gcry_cipher_setiv failed: %s\n",
1060                 gpg_strerror (err));
1061           gcry_cipher_close (hde);
1062           gcry_cipher_close (hdd);
1063           return;
1064         }
1065
1066       for (j = 0; tv[i].data[j].inlen; j++)
1067         {
1068           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
1069                                      tv[i].data[j].plaintext,
1070                                      tv[i].data[j].inlen);
1071           if (err)
1072             {
1073               fail ("aes-cfb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
1074                     i, j, gpg_strerror (err));
1075               gcry_cipher_close (hde);
1076               gcry_cipher_close (hdd);
1077               return;
1078             }
1079
1080           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen)) {
1081             fail ("aes-cfb, encrypt mismatch entry %d:%d\n", i, j);
1082           }
1083           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
1084           if (err)
1085             {
1086               fail ("aes-cfb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
1087                     i, j, gpg_strerror (err));
1088               gcry_cipher_close (hde);
1089               gcry_cipher_close (hdd);
1090               return;
1091             }
1092
1093           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
1094             fail ("aes-cfb, decrypt mismatch entry %d:%d\n", i, j);
1095         }
1096
1097       gcry_cipher_close (hde);
1098       gcry_cipher_close (hdd);
1099     }
1100   if (verbose)
1101     fprintf (stderr, "  Completed CFB checks.\n");
1102 }
1103
1104 static void
1105 check_ofb_cipher (void)
1106 {
1107   static const struct tv
1108   {
1109     int algo;
1110     char key[MAX_DATA_LEN];
1111     char iv[MAX_DATA_LEN];
1112     struct data
1113     {
1114       unsigned char plaintext[MAX_DATA_LEN];
1115       int inlen;
1116       char out[MAX_DATA_LEN];
1117     }
1118     data[MAX_DATA_LEN];
1119   } tv[] =
1120     {
1121       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
1122       { GCRY_CIPHER_AES,
1123         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
1124         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
1125         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
1126             16,
1127             "\x3b\x3f\xd9\x2e\xb7\x2d\xad\x20\x33\x34\x49\xf8\xe8\x3c\xfb\x4a" },
1128           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
1129             16,
1130             "\x77\x89\x50\x8d\x16\x91\x8f\x03\xf5\x3c\x52\xda\xc5\x4e\xd8\x25"},
1131           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
1132             16,
1133             "\x97\x40\x05\x1e\x9c\x5f\xec\xf6\x43\x44\xf7\xa8\x22\x60\xed\xcc" },
1134           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
1135             16,
1136             "\x30\x4c\x65\x28\xf6\x59\xc7\x78\x66\xa5\x10\xd9\xc1\xd6\xae\x5e" },
1137         }
1138       },
1139       { GCRY_CIPHER_AES192,
1140         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
1141         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
1142         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
1143         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
1144             16,
1145             "\xcd\xc8\x0d\x6f\xdd\xf1\x8c\xab\x34\xc2\x59\x09\xc9\x9a\x41\x74" },
1146           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
1147             16,
1148             "\xfc\xc2\x8b\x8d\x4c\x63\x83\x7c\x09\xe8\x17\x00\xc1\x10\x04\x01" },
1149           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
1150             16,
1151             "\x8d\x9a\x9a\xea\xc0\xf6\x59\x6f\x55\x9c\x6d\x4d\xaf\x59\xa5\xf2" },
1152           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
1153             16,
1154             "\x6d\x9f\x20\x08\x57\xca\x6c\x3e\x9c\xac\x52\x4b\xd9\xac\xc9\x2a" },
1155         }
1156       },
1157       { GCRY_CIPHER_AES256,
1158         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
1159         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
1160         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
1161         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
1162             16,
1163             "\xdc\x7e\x84\xbf\xda\x79\x16\x4b\x7e\xcd\x84\x86\x98\x5d\x38\x60" },
1164           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
1165             16,
1166             "\x4f\xeb\xdc\x67\x40\xd2\x0b\x3a\xc8\x8f\x6a\xd8\x2a\x4f\xb0\x8d" },
1167           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
1168             16,
1169             "\x71\xab\x47\xa0\x86\xe8\x6e\xed\xf3\x9d\x1c\x5b\xba\x97\xc4\x08" },
1170           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
1171             16,
1172             "\x01\x26\x14\x1d\x67\xf3\x7b\xe8\x53\x8f\x5a\x8b\xe7\x40\xe4\x84" }
1173         }
1174       }
1175     };
1176   gcry_cipher_hd_t hde, hdd;
1177   unsigned char out[MAX_DATA_LEN];
1178   int i, j, keylen, blklen;
1179   gcry_error_t err = 0;
1180
1181   if (verbose)
1182     fprintf (stderr, "  Starting OFB checks.\n");
1183
1184   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
1185     {
1186       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
1187         {
1188           if (verbose)
1189             fprintf (stderr, "  algorithm %d not available in fips mode\n",
1190                      tv[i].algo);
1191           continue;
1192         }
1193
1194       if (verbose)
1195         fprintf (stderr, "    checking OFB mode for %s [%i]\n",
1196                  gcry_cipher_algo_name (tv[i].algo),
1197                  tv[i].algo);
1198       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_OFB, 0);
1199       if (!err)
1200         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_OFB, 0);
1201       if (err)
1202         {
1203           fail ("aes-ofb, gcry_cipher_open failed: %s\n", gpg_strerror (err));
1204           return;
1205         }
1206
1207       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
1208       if (!keylen)
1209         {
1210           fail ("aes-ofb, gcry_cipher_get_algo_keylen failed\n");
1211           return;
1212         }
1213
1214       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
1215       if (!err)
1216         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
1217       if (err)
1218         {
1219           fail ("aes-ofb, gcry_cipher_setkey failed: %s\n",
1220                 gpg_strerror (err));
1221           gcry_cipher_close (hde);
1222           gcry_cipher_close (hdd);
1223           return;
1224         }
1225
1226       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
1227       if (!blklen)
1228         {
1229           fail ("aes-ofb, gcry_cipher_get_algo_blklen failed\n");
1230           return;
1231         }
1232
1233       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
1234       if (!err)
1235         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
1236       if (err)
1237         {
1238           fail ("aes-ofb, gcry_cipher_setiv failed: %s\n",
1239                 gpg_strerror (err));
1240           gcry_cipher_close (hde);
1241           gcry_cipher_close (hdd);
1242           return;
1243         }
1244
1245       for (j = 0; tv[i].data[j].inlen; j++)
1246         {
1247           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
1248                                      tv[i].data[j].plaintext,
1249                                      tv[i].data[j].inlen);
1250           if (err)
1251             {
1252               fail ("aes-ofb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
1253                     i, j, gpg_strerror (err));
1254               gcry_cipher_close (hde);
1255               gcry_cipher_close (hdd);
1256               return;
1257             }
1258
1259           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
1260             fail ("aes-ofb, encrypt mismatch entry %d:%d\n", i, j);
1261
1262           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
1263           if (err)
1264             {
1265               fail ("aes-ofb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
1266                     i, j, gpg_strerror (err));
1267               gcry_cipher_close (hde);
1268               gcry_cipher_close (hdd);
1269               return;
1270             }
1271
1272           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
1273             fail ("aes-ofb, decrypt mismatch entry %d:%d\n", i, j);
1274         }
1275
1276       err = gcry_cipher_reset(hde);
1277       if (!err)
1278         err = gcry_cipher_reset(hdd);
1279       if (err)
1280         {
1281           fail ("aes-ofb, gcry_cipher_reset (%d, %d) failed: %s\n",
1282                 i, j, gpg_strerror (err));
1283           gcry_cipher_close (hde);
1284           gcry_cipher_close (hdd);
1285           return;
1286         }
1287
1288       /* gcry_cipher_reset clears the IV */
1289       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
1290       if (!err)
1291         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
1292       if (err)
1293         {
1294           fail ("aes-ofb, gcry_cipher_setiv failed: %s\n",
1295                 gpg_strerror (err));
1296           gcry_cipher_close (hde);
1297           gcry_cipher_close (hdd);
1298           return;
1299         }
1300
1301       /* this time we encrypt and decrypt one byte at a time */
1302       for (j = 0; tv[i].data[j].inlen; j++)
1303         {
1304           int byteNum;
1305           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
1306             {
1307               err = gcry_cipher_encrypt (hde, out+byteNum, 1,
1308                                          (tv[i].data[j].plaintext) + byteNum,
1309                                          1);
1310               if (err)
1311                 {
1312                   fail ("aes-ofb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
1313                         i, j, gpg_strerror (err));
1314                   gcry_cipher_close (hde);
1315                   gcry_cipher_close (hdd);
1316                   return;
1317                 }
1318             }
1319
1320           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
1321             fail ("aes-ofb, encrypt mismatch entry %d:%d\n", i, j);
1322
1323           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
1324             {
1325               err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
1326               if (err)
1327                 {
1328                   fail ("aes-ofb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
1329                         i, j, gpg_strerror (err));
1330                   gcry_cipher_close (hde);
1331                   gcry_cipher_close (hdd);
1332                   return;
1333                 }
1334             }
1335
1336           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
1337             fail ("aes-ofb, decrypt mismatch entry %d:%d\n", i, j);
1338         }
1339
1340       gcry_cipher_close (hde);
1341       gcry_cipher_close (hdd);
1342     }
1343   if (verbose)
1344     fprintf (stderr, "  Completed OFB checks.\n");
1345 }
1346
1347 static void
1348 _check_gcm_cipher (unsigned int step)
1349 {
1350   struct tv
1351   {
1352     int algo;
1353     char key[MAX_DATA_LEN];
1354     char iv[MAX_DATA_LEN];
1355     int ivlen;
1356     unsigned char aad[MAX_DATA_LEN];
1357     int aadlen;
1358     unsigned char plaintext[MAX_DATA_LEN];
1359     int inlen;
1360     char out[MAX_DATA_LEN];
1361     char tag[MAX_DATA_LEN];
1362     int taglen;
1363     int should_fail;
1364   } tv[] =
1365     {
1366       /* http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/gcm/gcm-revised-spec.pdf */
1367       { GCRY_CIPHER_AES,
1368         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
1369         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
1370         "", 0,
1371         "",
1372         0,
1373         "",
1374         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57\xa4\xe7\x45\x5a" },
1375       { GCRY_CIPHER_AES,
1376         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
1377         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
1378         "", 0,
1379         "",
1380         0,
1381         "",
1382         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57\xa4\xe7\x45",
1383         15 },
1384       { GCRY_CIPHER_AES,
1385         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
1386         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
1387         "", 0,
1388         "",
1389         0,
1390         "",
1391         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57\xa4\xe7",
1392         14 },
1393       { GCRY_CIPHER_AES,
1394         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
1395         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
1396         "", 0,
1397         "",
1398         0,
1399         "",
1400         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57\xa4",
1401         13 },
1402       { GCRY_CIPHER_AES,
1403         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
1404         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
1405         "", 0,
1406         "",
1407         0,
1408         "",
1409         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57",
1410         12 },
1411       { GCRY_CIPHER_AES,
1412         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
1413         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
1414         "", 0,
1415         "",
1416         0,
1417         "",
1418         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d",
1419         11, 1 },
1420       { GCRY_CIPHER_AES,
1421         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
1422         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
1423         "", 0,
1424         "",
1425         0,
1426         "",
1427         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61",
1428         8 },
1429       { GCRY_CIPHER_AES,
1430         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
1431         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
1432         "", 0,
1433         "",
1434         0,
1435         "",
1436         "\x58\xe2\xfc\xce",
1437         4 },
1438       { GCRY_CIPHER_AES,
1439         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
1440         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
1441         "", 0,
1442         "",
1443         0,
1444         "",
1445         "\x58",
1446         1, 1 },
1447       { GCRY_CIPHER_AES,
1448         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
1449         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
1450         "", 0,
1451         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
1452         16,
1453         "\x03\x88\xda\xce\x60\xb6\xa3\x92\xf3\x28\xc2\xb9\x71\xb2\xfe\x78",
1454         "\xab\x6e\x47\xd4\x2c\xec\x13\xbd\xf5\x3a\x67\xb2\x12\x57\xbd\xdf" },
1455       { GCRY_CIPHER_AES,
1456         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08",
1457         "\xca\xfe\xba\xbe\xfa\xce\xdb\xad\xde\xca\xf8\x88", 12,
1458         "", 0,
1459         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
1460         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
1461         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
1462         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39\x1a\xaf\xd2\x55",
1463         64,
1464         "\x42\x83\x1e\xc2\x21\x77\x74\x24\x4b\x72\x21\xb7\x84\xd0\xd4\x9c"
1465         "\xe3\xaa\x21\x2f\x2c\x02\xa4\xe0\x35\xc1\x7e\x23\x29\xac\xa1\x2e"
1466         "\x21\xd5\x14\xb2\x54\x66\x93\x1c\x7d\x8f\x6a\x5a\xac\x84\xaa\x05"
1467         "\x1b\xa3\x0b\x39\x6a\x0a\xac\x97\x3d\x58\xe0\x91\x47\x3f\x59\x85",
1468         "\x4d\x5c\x2a\xf3\x27\xcd\x64\xa6\x2c\xf3\x5a\xbd\x2b\xa6\xfa\xb4" },
1469       { GCRY_CIPHER_AES,
1470         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08",
1471         "\xca\xfe\xba\xbe\xfa\xce\xdb\xad\xde\xca\xf8\x88", 12,
1472         "\xfe\xed\xfa\xce\xde\xad\xbe\xef\xfe\xed\xfa\xce\xde\xad\xbe\xef"
1473         "\xab\xad\xda\xd2", 20,
1474         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
1475         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
1476         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
1477         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39",
1478         60,
1479         "\x42\x83\x1e\xc2\x21\x77\x74\x24\x4b\x72\x21\xb7\x84\xd0\xd4\x9c"
1480         "\xe3\xaa\x21\x2f\x2c\x02\xa4\xe0\x35\xc1\x7e\x23\x29\xac\xa1\x2e"
1481         "\x21\xd5\x14\xb2\x54\x66\x93\x1c\x7d\x8f\x6a\x5a\xac\x84\xaa\x05"
1482         "\x1b\xa3\x0b\x39\x6a\x0a\xac\x97\x3d\x58\xe0\x91\x47\x3f\x59\x85",
1483         "\x5b\xc9\x4f\xbc\x32\x21\xa5\xdb\x94\xfa\xe9\x5a\xe7\x12\x1a\x47" },
1484       { GCRY_CIPHER_AES,
1485         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08",
1486         "\xca\xfe\xba\xbe\xfa\xce\xdb\xad", 8,
1487         "\xfe\xed\xfa\xce\xde\xad\xbe\xef\xfe\xed\xfa\xce\xde\xad\xbe\xef"
1488         "\xab\xad\xda\xd2", 20,
1489         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
1490         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
1491         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
1492         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39",
1493         60,
1494         "\x61\x35\x3b\x4c\x28\x06\x93\x4a\x77\x7f\xf5\x1f\xa2\x2a\x47\x55"
1495         "\x69\x9b\x2a\x71\x4f\xcd\xc6\xf8\x37\x66\xe5\xf9\x7b\x6c\x74\x23"
1496         "\x73\x80\x69\x00\xe4\x9f\x24\xb2\x2b\x09\x75\x44\xd4\x89\x6b\x42"
1497         "\x49\x89\xb5\xe1\xeb\xac\x0f\x07\xc2\x3f\x45\x98",
1498         "\x36\x12\xd2\xe7\x9e\x3b\x07\x85\x56\x1b\xe1\x4a\xac\xa2\xfc\xcb" },
1499       { GCRY_CIPHER_AES,
1500         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08",
1501         "\x93\x13\x22\x5d\xf8\x84\x06\xe5\x55\x90\x9c\x5a\xff\x52\x69\xaa"
1502         "\x6a\x7a\x95\x38\x53\x4f\x7d\xa1\xe4\xc3\x03\xd2\xa3\x18\xa7\x28"
1503         "\xc3\xc0\xc9\x51\x56\x80\x95\x39\xfc\xf0\xe2\x42\x9a\x6b\x52\x54"
1504         "\x16\xae\xdb\xf5\xa0\xde\x6a\x57\xa6\x37\xb3\x9b", 60,
1505         "\xfe\xed\xfa\xce\xde\xad\xbe\xef\xfe\xed\xfa\xce\xde\xad\xbe\xef"
1506         "\xab\xad\xda\xd2", 20,
1507         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
1508         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
1509         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
1510         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39",
1511         60,
1512         "\x8c\xe2\x49\x98\x62\x56\x15\xb6\x03\xa0\x33\xac\xa1\x3f\xb8\x94"
1513         "\xbe\x91\x12\xa5\xc3\xa2\x11\xa8\xba\x26\x2a\x3c\xca\x7e\x2c\xa7"
1514         "\x01\xe4\xa9\xa4\xfb\xa4\x3c\x90\xcc\xdc\xb2\x81\xd4\x8c\x7c\x6f"
1515         "\xd6\x28\x75\xd2\xac\xa4\x17\x03\x4c\x34\xae\xe5",
1516         "\x61\x9c\xc5\xae\xff\xfe\x0b\xfa\x46\x2a\xf4\x3c\x16\x99\xd0\x50" },
1517       { GCRY_CIPHER_AES192,
1518         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08"
1519         "\xfe\xff\xe9\x92\x86\x65\x73\x1c",
1520         "\x93\x13\x22\x5d\xf8\x84\x06\xe5\x55\x90\x9c\x5a\xff\x52\x69\xaa"
1521         "\x6a\x7a\x95\x38\x53\x4f\x7d\xa1\xe4\xc3\x03\xd2\xa3\x18\xa7\x28"
1522         "\xc3\xc0\xc9\x51\x56\x80\x95\x39\xfc\xf0\xe2\x42\x9a\x6b\x52\x54"
1523         "\x16\xae\xdb\xf5\xa0\xde\x6a\x57\xa6\x37\xb3\x9b", 60,
1524         "\xfe\xed\xfa\xce\xde\xad\xbe\xef\xfe\xed\xfa\xce\xde\xad\xbe\xef"
1525         "\xab\xad\xda\xd2", 20,
1526         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
1527         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
1528         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
1529         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39",
1530         60,
1531         "\xd2\x7e\x88\x68\x1c\xe3\x24\x3c\x48\x30\x16\x5a\x8f\xdc\xf9\xff"
1532         "\x1d\xe9\xa1\xd8\xe6\xb4\x47\xef\x6e\xf7\xb7\x98\x28\x66\x6e\x45"
1533         "\x81\xe7\x90\x12\xaf\x34\xdd\xd9\xe2\xf0\x37\x58\x9b\x29\x2d\xb3"
1534         "\xe6\x7c\x03\x67\x45\xfa\x22\xe7\xe9\xb7\x37\x3b",
1535         "\xdc\xf5\x66\xff\x29\x1c\x25\xbb\xb8\x56\x8f\xc3\xd3\x76\xa6\xd9" },
1536       { GCRY_CIPHER_AES256,
1537         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08"
1538         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08",
1539         "\x93\x13\x22\x5d\xf8\x84\x06\xe5\x55\x90\x9c\x5a\xff\x52\x69\xaa"
1540         "\x6a\x7a\x95\x38\x53\x4f\x7d\xa1\xe4\xc3\x03\xd2\xa3\x18\xa7\x28"
1541         "\xc3\xc0\xc9\x51\x56\x80\x95\x39\xfc\xf0\xe2\x42\x9a\x6b\x52\x54"
1542         "\x16\xae\xdb\xf5\xa0\xde\x6a\x57\xa6\x37\xb3\x9b", 60,
1543         "\xfe\xed\xfa\xce\xde\xad\xbe\xef\xfe\xed\xfa\xce\xde\xad\xbe\xef"
1544         "\xab\xad\xda\xd2", 20,
1545         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
1546         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
1547         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
1548         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39",
1549         60,
1550         "\x5a\x8d\xef\x2f\x0c\x9e\x53\xf1\xf7\x5d\x78\x53\x65\x9e\x2a\x20"
1551         "\xee\xb2\xb2\x2a\xaf\xde\x64\x19\xa0\x58\xab\x4f\x6f\x74\x6b\xf4"
1552         "\x0f\xc0\xc3\xb7\x80\xf2\x44\x45\x2d\xa3\xeb\xf1\xc5\xd8\x2c\xde"
1553         "\xa2\x41\x89\x97\x20\x0e\xf8\x2e\x44\xae\x7e\x3f",
1554         "\xa4\x4a\x82\x66\xee\x1c\x8e\xb0\xc8\xb5\xd4\xcf\x5a\xe9\xf1\x9a" }
1555     };
1556
1557   gcry_cipher_hd_t hde, hdd;
1558   unsigned char out[MAX_DATA_LEN];
1559   unsigned char tag[GCRY_GCM_BLOCK_LEN];
1560   int i, keylen;
1561   gcry_error_t err = 0;
1562   size_t pos, poslen, taglen2;
1563   int byteNum;
1564
1565   if (verbose)
1566     fprintf (stderr, "  Starting GCM checks.\n");
1567
1568   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
1569     {
1570       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
1571         {
1572           if (verbose)
1573             fprintf (stderr, "  algorithm %d not available in fips mode\n",
1574                      tv[i].algo);
1575           continue;
1576         }
1577
1578       if (verbose)
1579         fprintf (stderr, "    checking GCM mode for %s [%i]\n",
1580                  gcry_cipher_algo_name (tv[i].algo),
1581                  tv[i].algo);
1582       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_GCM, 0);
1583       if (!err)
1584         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_GCM, 0);
1585       if (err)
1586         {
1587           fail ("aes-gcm, gcry_cipher_open failed: %s\n", gpg_strerror (err));
1588           return;
1589         }
1590
1591       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
1592       if (!keylen)
1593         {
1594           fail ("aes-gcm, gcry_cipher_get_algo_keylen failed\n");
1595           return;
1596         }
1597
1598       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
1599       if (!err)
1600         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
1601       if (err)
1602         {
1603           fail ("aes-gcm, gcry_cipher_setkey failed: %s\n",
1604                 gpg_strerror (err));
1605           gcry_cipher_close (hde);
1606           gcry_cipher_close (hdd);
1607           return;
1608         }
1609
1610       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
1611       if (!err)
1612         err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
1613       if (err)
1614         {
1615           fail ("aes-gcm, gcry_cipher_setiv failed: %s\n",
1616                 gpg_strerror (err));
1617           gcry_cipher_close (hde);
1618           gcry_cipher_close (hdd);
1619           return;
1620         }
1621
1622       err = gcry_cipher_info (hde, GCRYCTL_GET_TAGLEN, NULL, &taglen2);
1623       if (err)
1624         {
1625           fail ("cipher-gcm, gcryctl_get_taglen failed (tv %d): %s\n",
1626                 i, gpg_strerror (err));
1627           gcry_cipher_close (hde);
1628           gcry_cipher_close (hdd);
1629           return;
1630         }
1631       if (taglen2 != GCRY_GCM_BLOCK_LEN)
1632         {
1633           fail ("cipher-gcm, gcryctl_get_taglen returned bad length"
1634                 " (tv %d): got=%zu want=%d\n",
1635                 i, taglen2, GCRY_GCM_BLOCK_LEN);
1636           gcry_cipher_close (hde);
1637           gcry_cipher_close (hdd);
1638           return;
1639         }
1640
1641       for (pos = 0; pos < tv[i].aadlen; pos += step)
1642         {
1643           poslen = (pos + step < tv[i].aadlen) ? step : tv[i].aadlen - pos;
1644
1645           err = gcry_cipher_authenticate(hde, tv[i].aad + pos, poslen);
1646           if (err)
1647             {
1648               fail ("aes-gcm, gcry_cipher_authenticate (%d) (%lu:%d) failed: "
1649                     "%s\n", i, (unsigned long) pos, step, gpg_strerror (err));
1650               gcry_cipher_close (hde);
1651               gcry_cipher_close (hdd);
1652               return;
1653             }
1654           err = gcry_cipher_authenticate(hdd, tv[i].aad + pos, poslen);
1655           if (err)
1656             {
1657               fail ("aes-gcm, de gcry_cipher_authenticate (%d) (%lu:%d) failed: "
1658                     "%s\n", i, (unsigned long) pos, step, gpg_strerror (err));
1659               gcry_cipher_close (hde);
1660               gcry_cipher_close (hdd);
1661               return;
1662             }
1663         }
1664
1665       for (pos = 0; pos < tv[i].inlen; pos += step)
1666         {
1667           poslen = (pos + step < tv[i].inlen) ? step : tv[i].inlen - pos;
1668
1669           err = gcry_cipher_encrypt (hde, out + pos, poslen,
1670                                      tv[i].plaintext + pos, poslen);
1671           if (err)
1672             {
1673               fail ("aes-gcm, gcry_cipher_encrypt (%d) (%lu:%d) failed: %s\n",
1674                     i, (unsigned long) pos, step, gpg_strerror (err));
1675               gcry_cipher_close (hde);
1676               gcry_cipher_close (hdd);
1677               return;
1678             }
1679         }
1680
1681       if (memcmp (tv[i].out, out, tv[i].inlen))
1682         fail ("aes-gcm, encrypt mismatch entry %d (step %d)\n", i, step);
1683
1684       for (pos = 0; pos < tv[i].inlen; pos += step)
1685         {
1686           poslen = (pos + step < tv[i].inlen) ? step : tv[i].inlen - pos;
1687
1688           err = gcry_cipher_decrypt (hdd, out + pos, poslen, NULL, 0);
1689           if (err)
1690             {
1691               fail ("aes-gcm, gcry_cipher_decrypt (%d) (%lu:%d) failed: %s\n",
1692                     i, (unsigned long) pos, step, gpg_strerror (err));
1693               gcry_cipher_close (hde);
1694               gcry_cipher_close (hdd);
1695               return;
1696             }
1697         }
1698
1699       if (memcmp (tv[i].plaintext, out, tv[i].inlen))
1700         fail ("aes-gcm, decrypt mismatch entry %d (step %d)\n", i, step);
1701
1702       taglen2 = tv[i].taglen ? tv[i].taglen : GCRY_GCM_BLOCK_LEN;
1703
1704       err = gcry_cipher_gettag (hde, out, taglen2);
1705       if (err)
1706         {
1707           if (tv[i].should_fail)
1708             goto next_tv;
1709
1710           fail ("aes-gcm, gcry_cipher_gettag(%d) failed: %s\n",
1711                 i, gpg_strerror (err));
1712           gcry_cipher_close (hde);
1713           gcry_cipher_close (hdd);
1714           return;
1715         }
1716
1717       if (memcmp (tv[i].tag, out, taglen2))
1718         fail ("aes-gcm, encrypt tag mismatch entry %d\n", i);
1719
1720       err = gcry_cipher_checktag (hdd, out, taglen2);
1721       if (err)
1722         {
1723           fail ("aes-gcm, gcry_cipher_checktag(%d) failed: %s\n",
1724                 i, gpg_strerror (err));
1725           gcry_cipher_close (hde);
1726           gcry_cipher_close (hdd);
1727           return;
1728         }
1729
1730       err = gcry_cipher_reset(hde);
1731       if (!err)
1732         err = gcry_cipher_reset(hdd);
1733       if (err)
1734         {
1735           fail ("aes-gcm, gcry_cipher_reset (%d) failed: %s\n",
1736                 i, gpg_strerror (err));
1737           gcry_cipher_close (hde);
1738           gcry_cipher_close (hdd);
1739           return;
1740         }
1741
1742       /* gcry_cipher_reset clears the IV */
1743       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
1744       if (!err)
1745         err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
1746       if (err)
1747         {
1748           fail ("aes-gcm, gcry_cipher_setiv failed: %s\n",
1749                 gpg_strerror (err));
1750           gcry_cipher_close (hde);
1751           gcry_cipher_close (hdd);
1752           return;
1753         }
1754
1755       /* this time we authenticate, encrypt and decrypt one byte at a time */
1756       for (byteNum = 0; byteNum < tv[i].aadlen; ++byteNum)
1757         {
1758           err = gcry_cipher_authenticate(hde, tv[i].aad + byteNum, 1);
1759           if (err)
1760             {
1761               fail ("aes-gcm, gcry_cipher_authenticate (%d) (byte-buf) failed: "
1762                     "%s\n", i, gpg_strerror (err));
1763               gcry_cipher_close (hde);
1764               gcry_cipher_close (hdd);
1765               return;
1766             }
1767           err = gcry_cipher_authenticate(hdd, tv[i].aad + byteNum, 1);
1768           if (err)
1769             {
1770               fail ("aes-gcm, de gcry_cipher_authenticate (%d) (byte-buf) "
1771                     "failed: %s\n", i, gpg_strerror (err));
1772               gcry_cipher_close (hde);
1773               gcry_cipher_close (hdd);
1774               return;
1775             }
1776         }
1777
1778       for (byteNum = 0; byteNum < tv[i].inlen; ++byteNum)
1779         {
1780           err = gcry_cipher_encrypt (hde, out+byteNum, 1,
1781                                      (tv[i].plaintext) + byteNum,
1782                                      1);
1783           if (err)
1784             {
1785               fail ("aes-gcm, gcry_cipher_encrypt (%d) (byte-buf) failed: %s\n",
1786                     i,  gpg_strerror (err));
1787               gcry_cipher_close (hde);
1788               gcry_cipher_close (hdd);
1789               return;
1790             }
1791         }
1792
1793       if (memcmp (tv[i].out, out, tv[i].inlen))
1794         fail ("aes-gcm, encrypt mismatch entry %d, (byte-buf)\n", i);
1795
1796       /* Test output to larger than 16-byte buffer. */
1797       taglen2 = tv[i].taglen ? tv[i].taglen : GCRY_GCM_BLOCK_LEN + 1;
1798
1799       err = gcry_cipher_gettag (hde, tag, taglen2);
1800       if (err)
1801         {
1802           if (tv[i].should_fail)
1803             goto next_tv;
1804
1805           fail ("aes-gcm, gcry_cipher_gettag(%d, %lu) (byte-buf) failed: %s\n",
1806                 i, (unsigned long) taglen2, gpg_strerror (err));
1807           gcry_cipher_close (hde);
1808           gcry_cipher_close (hdd);
1809           return;
1810         }
1811
1812       taglen2 = tv[i].taglen ? tv[i].taglen : GCRY_GCM_BLOCK_LEN;
1813
1814       if (memcmp (tv[i].tag, tag, taglen2))
1815         fail ("aes-gcm, encrypt tag mismatch entry %d, (byte-buf)\n", i);
1816
1817       for (byteNum = 0; byteNum < tv[i].inlen; ++byteNum)
1818         {
1819           err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
1820           if (err)
1821             {
1822               fail ("aes-gcm, gcry_cipher_decrypt (%d) (byte-buf) failed: %s\n",
1823                     i, gpg_strerror (err));
1824               gcry_cipher_close (hde);
1825               gcry_cipher_close (hdd);
1826               return;
1827             }
1828         }
1829
1830       if (memcmp (tv[i].plaintext, out, tv[i].inlen))
1831         fail ("aes-gcm, decrypt mismatch entry %d\n", i);
1832
1833       err = gcry_cipher_checktag (hdd, tag, taglen2);
1834       if (err)
1835         {
1836           fail ("aes-gcm, gcry_cipher_checktag(%d) (byte-buf) failed: %s\n",
1837                 i, gpg_strerror (err));
1838           gcry_cipher_close (hde);
1839           gcry_cipher_close (hdd);
1840           return;
1841         }
1842
1843       err = gcry_cipher_checktag (hdd, tag, 1);
1844       if (!err)
1845         {
1846           fail ("aes-gcm, gcry_cipher_checktag(%d) did not fail for invalid "
1847                 " tag length of '%d'\n", i, 1);
1848           gcry_cipher_close (hde);
1849           gcry_cipher_close (hdd);
1850           return;
1851         }
1852       err = gcry_cipher_checktag (hdd, tag, 17);
1853       if (!err)
1854         {
1855           fail ("aes-gcm, gcry_cipher_checktag(%d) did not fail for invalid "
1856                 " tag length of '%d'\n", i, 17);
1857           gcry_cipher_close (hde);
1858           gcry_cipher_close (hdd);
1859           return;
1860         }
1861
1862       if (tv[i].should_fail)
1863         {
1864           fail ("aes-gcm, negative test succeeded %d\n", i);
1865           gcry_cipher_close (hde);
1866           gcry_cipher_close (hdd);
1867           return;
1868         }
1869
1870     next_tv:
1871       gcry_cipher_close (hde);
1872       gcry_cipher_close (hdd);
1873     }
1874   if (verbose)
1875     fprintf (stderr, "  Completed GCM checks.\n");
1876 }
1877
1878
1879 static void
1880 check_gcm_cipher (void)
1881 {
1882   /* Large buffers, no splitting. */
1883   _check_gcm_cipher(0xffffffff);
1884   /* Split input to one byte buffers. */
1885   _check_gcm_cipher(1);
1886   /* Split input to 7 byte buffers. */
1887   _check_gcm_cipher(7);
1888   /* Split input to 16 byte buffers. */
1889   _check_gcm_cipher(16);
1890 }
1891
1892
1893 static void
1894 _check_poly1305_cipher (unsigned int step)
1895 {
1896   struct tv
1897   {
1898     int algo;
1899     const char *key;
1900     const char *iv;
1901     int ivlen;
1902     const char *aad;
1903     int aadlen;
1904     const char *plaintext;
1905     int inlen;
1906     const char *out;
1907     const char *tag;
1908   } tv[] =
1909     {
1910       /* draft-irtf-cfrg-chacha20-poly1305-03 */
1911       { GCRY_CIPHER_CHACHA20,
1912         "\x1c\x92\x40\xa5\xeb\x55\xd3\x8a\xf3\x33\x88\x86\x04\xf6\xb5\xf0"
1913         "\x47\x39\x17\xc1\x40\x2b\x80\x09\x9d\xca\x5c\xbc\x20\x70\x75\xc0",
1914         "\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08", 12,
1915         "\xf3\x33\x88\x86\x00\x00\x00\x00\x00\x00\x4e\x91", 12,
1916         "\x49\x6e\x74\x65\x72\x6e\x65\x74\x2d\x44\x72\x61\x66\x74\x73\x20"
1917         "\x61\x72\x65\x20\x64\x72\x61\x66\x74\x20\x64\x6f\x63\x75\x6d\x65"
1918         "\x6e\x74\x73\x20\x76\x61\x6c\x69\x64\x20\x66\x6f\x72\x20\x61\x20"
1919         "\x6d\x61\x78\x69\x6d\x75\x6d\x20\x6f\x66\x20\x73\x69\x78\x20\x6d"
1920         "\x6f\x6e\x74\x68\x73\x20\x61\x6e\x64\x20\x6d\x61\x79\x20\x62\x65"
1921         "\x20\x75\x70\x64\x61\x74\x65\x64\x2c\x20\x72\x65\x70\x6c\x61\x63"
1922         "\x65\x64\x2c\x20\x6f\x72\x20\x6f\x62\x73\x6f\x6c\x65\x74\x65\x64"
1923         "\x20\x62\x79\x20\x6f\x74\x68\x65\x72\x20\x64\x6f\x63\x75\x6d\x65"
1924         "\x6e\x74\x73\x20\x61\x74\x20\x61\x6e\x79\x20\x74\x69\x6d\x65\x2e"
1925         "\x20\x49\x74\x20\x69\x73\x20\x69\x6e\x61\x70\x70\x72\x6f\x70\x72"
1926         "\x69\x61\x74\x65\x20\x74\x6f\x20\x75\x73\x65\x20\x49\x6e\x74\x65"
1927         "\x72\x6e\x65\x74\x2d\x44\x72\x61\x66\x74\x73\x20\x61\x73\x20\x72"
1928         "\x65\x66\x65\x72\x65\x6e\x63\x65\x20\x6d\x61\x74\x65\x72\x69\x61"
1929         "\x6c\x20\x6f\x72\x20\x74\x6f\x20\x63\x69\x74\x65\x20\x74\x68\x65"
1930         "\x6d\x20\x6f\x74\x68\x65\x72\x20\x74\x68\x61\x6e\x20\x61\x73\x20"
1931         "\x2f\xe2\x80\x9c\x77\x6f\x72\x6b\x20\x69\x6e\x20\x70\x72\x6f\x67"
1932         "\x72\x65\x73\x73\x2e\x2f\xe2\x80\x9d", 265,
1933         "\x64\xa0\x86\x15\x75\x86\x1a\xf4\x60\xf0\x62\xc7\x9b\xe6\x43\xbd"
1934         "\x5e\x80\x5c\xfd\x34\x5c\xf3\x89\xf1\x08\x67\x0a\xc7\x6c\x8c\xb2"
1935         "\x4c\x6c\xfc\x18\x75\x5d\x43\xee\xa0\x9e\xe9\x4e\x38\x2d\x26\xb0"
1936         "\xbd\xb7\xb7\x3c\x32\x1b\x01\x00\xd4\xf0\x3b\x7f\x35\x58\x94\xcf"
1937         "\x33\x2f\x83\x0e\x71\x0b\x97\xce\x98\xc8\xa8\x4a\xbd\x0b\x94\x81"
1938         "\x14\xad\x17\x6e\x00\x8d\x33\xbd\x60\xf9\x82\xb1\xff\x37\xc8\x55"
1939         "\x97\x97\xa0\x6e\xf4\xf0\xef\x61\xc1\x86\x32\x4e\x2b\x35\x06\x38"
1940         "\x36\x06\x90\x7b\x6a\x7c\x02\xb0\xf9\xf6\x15\x7b\x53\xc8\x67\xe4"
1941         "\xb9\x16\x6c\x76\x7b\x80\x4d\x46\xa5\x9b\x52\x16\xcd\xe7\xa4\xe9"
1942         "\x90\x40\xc5\xa4\x04\x33\x22\x5e\xe2\x82\xa1\xb0\xa0\x6c\x52\x3e"
1943         "\xaf\x45\x34\xd7\xf8\x3f\xa1\x15\x5b\x00\x47\x71\x8c\xbc\x54\x6a"
1944         "\x0d\x07\x2b\x04\xb3\x56\x4e\xea\x1b\x42\x22\x73\xf5\x48\x27\x1a"
1945         "\x0b\xb2\x31\x60\x53\xfa\x76\x99\x19\x55\xeb\xd6\x31\x59\x43\x4e"
1946         "\xce\xbb\x4e\x46\x6d\xae\x5a\x10\x73\xa6\x72\x76\x27\x09\x7a\x10"
1947         "\x49\xe6\x17\xd9\x1d\x36\x10\x94\xfa\x68\xf0\xff\x77\x98\x71\x30"
1948         "\x30\x5b\xea\xba\x2e\xda\x04\xdf\x99\x7b\x71\x4d\x6c\x6f\x2c\x29"
1949         "\xa6\xad\x5c\xb4\x02\x2b\x02\x70\x9b",
1950         "\xee\xad\x9d\x67\x89\x0c\xbb\x22\x39\x23\x36\xfe\xa1\x85\x1f\x38" },
1951       /* draft-irtf-cfrg-chacha20-poly1305-03 */
1952       { GCRY_CIPHER_CHACHA20,
1953         "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
1954         "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f",
1955         "\x07\x00\x00\x00\x40\x41\x42\x43\x44\x45\x46\x47", 12,
1956         "\x50\x51\x52\x53\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7", 12,
1957         "Ladies and Gentlemen of the class of '99: If I could offer you "
1958         "only one tip for the future, sunscreen would be it.", 114,
1959         "\xd3\x1a\x8d\x34\x64\x8e\x60\xdb\x7b\x86\xaf\xbc\x53\xef\x7e\xc2"
1960         "\xa4\xad\xed\x51\x29\x6e\x08\xfe\xa9\xe2\xb5\xa7\x36\xee\x62\xd6"
1961         "\x3d\xbe\xa4\x5e\x8c\xa9\x67\x12\x82\xfa\xfb\x69\xda\x92\x72\x8b"
1962         "\x1a\x71\xde\x0a\x9e\x06\x0b\x29\x05\xd6\xa5\xb6\x7e\xcd\x3b\x36"
1963         "\x92\xdd\xbd\x7f\x2d\x77\x8b\x8c\x98\x03\xae\xe3\x28\x09\x1b\x58"
1964         "\xfa\xb3\x24\xe4\xfa\xd6\x75\x94\x55\x85\x80\x8b\x48\x31\xd7\xbc"
1965         "\x3f\xf4\xde\xf0\x8e\x4b\x7a\x9d\xe5\x76\xd2\x65\x86\xce\xc6\x4b"
1966         "\x61\x16",
1967         "\x1a\xe1\x0b\x59\x4f\x09\xe2\x6a\x7e\x90\x2e\xcb\xd0\x60\x06\x91" },
1968     };
1969
1970   gcry_cipher_hd_t hde, hdd;
1971   unsigned char out[1024];
1972   unsigned char tag[16];
1973   int i, keylen;
1974   gcry_error_t err = 0;
1975   size_t pos, poslen, taglen2;
1976   int byteNum;
1977
1978   if (verbose)
1979     fprintf (stderr, "  Starting POLY1305 checks.\n");
1980
1981   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
1982     {
1983       if (verbose)
1984         fprintf (stderr, "    checking POLY1305 mode for %s [%i]\n",
1985                  gcry_cipher_algo_name (tv[i].algo),
1986                  tv[i].algo);
1987       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_POLY1305, 0);
1988       if (!err)
1989         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_POLY1305, 0);
1990       if (err)
1991         {
1992           fail ("poly1305, gcry_cipher_open failed: %s\n", gpg_strerror (err));
1993           return;
1994         }
1995
1996       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
1997       if (!keylen)
1998         {
1999           fail ("poly1305, gcry_cipher_get_algo_keylen failed\n");
2000           return;
2001         }
2002
2003       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
2004       if (!err)
2005         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
2006       if (err)
2007         {
2008           fail ("poly1305, gcry_cipher_setkey failed: %s\n",
2009                 gpg_strerror (err));
2010           gcry_cipher_close (hde);
2011           gcry_cipher_close (hdd);
2012           return;
2013         }
2014
2015       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
2016       if (!err)
2017         err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
2018       if (err)
2019         {
2020           fail ("poly1305, gcry_cipher_setiv failed: %s\n",
2021                 gpg_strerror (err));
2022           gcry_cipher_close (hde);
2023           gcry_cipher_close (hdd);
2024           return;
2025         }
2026
2027       err = gcry_cipher_info (hde, GCRYCTL_GET_TAGLEN, NULL, &taglen2);
2028       if (err)
2029         {
2030           fail ("cipher-poly1305, gcryctl_get_taglen failed (tv %d): %s\n",
2031                 i, gpg_strerror (err));
2032           gcry_cipher_close (hde);
2033           gcry_cipher_close (hdd);
2034           return;
2035         }
2036       if (taglen2 != 16)
2037         {
2038           fail ("cipher-poly1305, gcryctl_get_taglen returned bad length"
2039                 " (tv %d): got=%zu want=%d\n",
2040                 i, taglen2, 16);
2041           gcry_cipher_close (hde);
2042           gcry_cipher_close (hdd);
2043           return;
2044         }
2045
2046       for (pos = 0; pos < tv[i].aadlen; pos += step)
2047         {
2048           poslen = (pos + step < tv[i].aadlen) ? step : tv[i].aadlen - pos;
2049
2050           err = gcry_cipher_authenticate(hde, tv[i].aad + pos, poslen);
2051           if (err)
2052             {
2053               fail ("poly1305, gcry_cipher_authenticate (%d) (%lu:%d) failed: "
2054                     "%s\n", i, (unsigned long) pos, step, gpg_strerror (err));
2055               gcry_cipher_close (hde);
2056               gcry_cipher_close (hdd);
2057               return;
2058             }
2059           err = gcry_cipher_authenticate(hdd, tv[i].aad + pos, poslen);
2060           if (err)
2061             {
2062               fail ("poly1305, de gcry_cipher_authenticate (%d) (%lu:%d) failed: "
2063                     "%s\n", i, (unsigned long) pos, step, gpg_strerror (err));
2064               gcry_cipher_close (hde);
2065               gcry_cipher_close (hdd);
2066               return;
2067             }
2068         }
2069
2070       for (pos = 0; pos < tv[i].inlen; pos += step)
2071         {
2072           poslen = (pos + step < tv[i].inlen) ? step : tv[i].inlen - pos;
2073
2074           err = gcry_cipher_encrypt (hde, out + pos, poslen,
2075                                      tv[i].plaintext + pos, poslen);
2076           if (err)
2077             {
2078               fail ("poly1305, gcry_cipher_encrypt (%d) (%lu:%d) failed: %s\n",
2079                     i, (unsigned long) pos, step, gpg_strerror (err));
2080               gcry_cipher_close (hde);
2081               gcry_cipher_close (hdd);
2082               return;
2083             }
2084         }
2085
2086       if (memcmp (tv[i].out, out, tv[i].inlen))
2087         fail ("poly1305, encrypt mismatch entry %d (step %d)\n", i, step);
2088
2089       for (pos = 0; pos < tv[i].inlen; pos += step)
2090         {
2091           poslen = (pos + step < tv[i].inlen) ? step : tv[i].inlen - pos;
2092
2093           err = gcry_cipher_decrypt (hdd, out + pos, poslen, NULL, 0);
2094           if (err)
2095             {
2096               fail ("poly1305, gcry_cipher_decrypt (%d) (%lu:%d) failed: %s\n",
2097                     i, (unsigned long) pos, step, gpg_strerror (err));
2098               gcry_cipher_close (hde);
2099               gcry_cipher_close (hdd);
2100               return;
2101             }
2102         }
2103
2104       if (memcmp (tv[i].plaintext, out, tv[i].inlen))
2105         fail ("poly1305, decrypt mismatch entry %d (step %d)\n", i, step);
2106
2107       err = gcry_cipher_gettag (hde, out, 16);
2108       if (err)
2109         {
2110           fail ("poly1305, gcry_cipher_gettag(%d) failed: %s\n",
2111                 i, gpg_strerror (err));
2112           gcry_cipher_close (hde);
2113           gcry_cipher_close (hdd);
2114           return;
2115         }
2116
2117       if (memcmp (tv[i].tag, out, 16))
2118         fail ("poly1305, encrypt tag mismatch entry %d\n", i);
2119
2120
2121       err = gcry_cipher_checktag (hdd, out, 16);
2122       if (err)
2123         {
2124           fail ("poly1305, gcry_cipher_checktag(%d) failed: %s\n",
2125                 i, gpg_strerror (err));
2126           gcry_cipher_close (hde);
2127           gcry_cipher_close (hdd);
2128           return;
2129         }
2130
2131       err = gcry_cipher_reset(hde);
2132       if (!err)
2133         err = gcry_cipher_reset(hdd);
2134       if (err)
2135         {
2136           fail ("poly1305, gcry_cipher_reset (%d) failed: %s\n",
2137                 i, gpg_strerror (err));
2138           gcry_cipher_close (hde);
2139           gcry_cipher_close (hdd);
2140           return;
2141         }
2142
2143       /* gcry_cipher_reset clears the IV */
2144       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
2145       if (!err)
2146         err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
2147       if (err)
2148         {
2149           fail ("poly1305, gcry_cipher_setiv failed: %s\n",
2150                 gpg_strerror (err));
2151           gcry_cipher_close (hde);
2152           gcry_cipher_close (hdd);
2153           return;
2154         }
2155
2156       /* this time we authenticate, encrypt and decrypt one byte at a time */
2157       for (byteNum = 0; byteNum < tv[i].aadlen; ++byteNum)
2158         {
2159           err = gcry_cipher_authenticate(hde, tv[i].aad + byteNum, 1);
2160           if (err)
2161             {
2162               fail ("poly1305, gcry_cipher_authenticate (%d) (byte-buf) failed: "
2163                     "%s\n", i, gpg_strerror (err));
2164               gcry_cipher_close (hde);
2165               gcry_cipher_close (hdd);
2166               return;
2167             }
2168           err = gcry_cipher_authenticate(hdd, tv[i].aad + byteNum, 1);
2169           if (err)
2170             {
2171               fail ("poly1305, de gcry_cipher_authenticate (%d) (byte-buf) "
2172                     "failed: %s\n", i, gpg_strerror (err));
2173               gcry_cipher_close (hde);
2174               gcry_cipher_close (hdd);
2175               return;
2176             }
2177         }
2178
2179       for (byteNum = 0; byteNum < tv[i].inlen; ++byteNum)
2180         {
2181           err = gcry_cipher_encrypt (hde, out+byteNum, 1,
2182                                      (tv[i].plaintext) + byteNum,
2183                                      1);
2184           if (err)
2185             {
2186               fail ("poly1305, gcry_cipher_encrypt (%d) (byte-buf) failed: %s\n",
2187                     i,  gpg_strerror (err));
2188               gcry_cipher_close (hde);
2189               gcry_cipher_close (hdd);
2190               return;
2191             }
2192         }
2193
2194       if (memcmp (tv[i].out, out, tv[i].inlen))
2195         fail ("poly1305, encrypt mismatch entry %d, (byte-buf)\n", i);
2196
2197       err = gcry_cipher_gettag (hde, tag, 16);
2198       if (err)
2199         {
2200           fail ("poly1305, gcry_cipher_gettag(%d) (byte-buf) failed: %s\n",
2201                 i, gpg_strerror (err));
2202           gcry_cipher_close (hde);
2203           gcry_cipher_close (hdd);
2204           return;
2205         }
2206
2207       if (memcmp (tv[i].tag, tag, 16))
2208         fail ("poly1305, encrypt tag mismatch entry %d, (byte-buf)\n", i);
2209
2210       for (byteNum = 0; byteNum < tv[i].inlen; ++byteNum)
2211         {
2212           err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
2213           if (err)
2214             {
2215               fail ("poly1305, gcry_cipher_decrypt (%d) (byte-buf) failed: %s\n",
2216                     i, gpg_strerror (err));
2217               gcry_cipher_close (hde);
2218               gcry_cipher_close (hdd);
2219               return;
2220             }
2221         }
2222
2223       if (memcmp (tv[i].plaintext, out, tv[i].inlen))
2224         fail ("poly1305, decrypt mismatch entry %d\n", i);
2225
2226       err = gcry_cipher_checktag (hdd, tag, 16);
2227       if (err)
2228         {
2229           fail ("poly1305, gcry_cipher_checktag(%d) (byte-buf) failed: %s\n",
2230                 i, gpg_strerror (err));
2231           gcry_cipher_close (hde);
2232           gcry_cipher_close (hdd);
2233           return;
2234         }
2235
2236       gcry_cipher_close (hde);
2237       gcry_cipher_close (hdd);
2238     }
2239   if (verbose)
2240     fprintf (stderr, "  Completed POLY1305 checks.\n");
2241 }
2242
2243
2244 static void
2245 check_poly1305_cipher (void)
2246 {
2247   /* Large buffers, no splitting. */
2248   _check_poly1305_cipher(0xffffffff);
2249   /* Split input to one byte buffers. */
2250   _check_poly1305_cipher(1);
2251   /* Split input to 7 byte buffers. */
2252   _check_poly1305_cipher(7);
2253   /* Split input to 16 byte buffers. */
2254   _check_poly1305_cipher(16);
2255 }
2256
2257
2258 static void
2259 check_ccm_cipher (void)
2260 {
2261   static const struct tv
2262   {
2263     int algo;
2264     int keylen;
2265     const char *key;
2266     int noncelen;
2267     const char *nonce;
2268     int aadlen;
2269     const char *aad;
2270     int plainlen;
2271     const char *plaintext;
2272     int cipherlen;
2273     const char *ciphertext;
2274   } tv[] =
2275     {
2276       /* RFC 3610 */
2277       { GCRY_CIPHER_AES, /* Packet Vector #1 */
2278           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2279           13, "\x00\x00\x00\x03\x02\x01\x00\xA0\xA1\xA2\xA3\xA4\xA5",
2280           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2281           23,
2282           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
2283           31,
2284           "\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"},
2285       { GCRY_CIPHER_AES, /* Packet Vector #2 */
2286           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2287           13, "\x00\x00\x00\x04\x03\x02\x01\xA0\xA1\xA2\xA3\xA4\xA5",
2288           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2289           24,
2290           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
2291           32,
2292           "\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"},
2293       { GCRY_CIPHER_AES, /* Packet Vector #3 */
2294           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2295           13, "\x00\x00\x00\x05\x04\x03\x02\xA0\xA1\xA2\xA3\xA4\xA5",
2296           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2297           25,
2298           "\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",
2299           33,
2300           "\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"},
2301       { GCRY_CIPHER_AES, /* Packet Vector #4 */
2302           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2303           13, "\x00\x00\x00\x06\x05\x04\x03\xA0\xA1\xA2\xA3\xA4\xA5",
2304           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2305           19,
2306           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
2307           27,
2308           "\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"},
2309       { GCRY_CIPHER_AES, /* Packet Vector #5 */
2310           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2311           13, "\x00\x00\x00\x07\x06\x05\x04\xA0\xA1\xA2\xA3\xA4\xA5",
2312           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2313           20,
2314           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
2315           28,
2316           "\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"},
2317       { GCRY_CIPHER_AES, /* Packet Vector #6 */
2318           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2319           13, "\x00\x00\x00\x08\x07\x06\x05\xA0\xA1\xA2\xA3\xA4\xA5",
2320           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2321           21,
2322           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
2323           29,
2324           "\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"},
2325       { GCRY_CIPHER_AES, /* Packet Vector #7 */
2326           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2327           13, "\x00\x00\x00\x09\x08\x07\x06\xA0\xA1\xA2\xA3\xA4\xA5",
2328           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2329           23,
2330           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
2331           33,
2332           "\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"},
2333       { GCRY_CIPHER_AES, /* Packet Vector #8 */
2334           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2335           13, "\x00\x00\x00\x0A\x09\x08\x07\xA0\xA1\xA2\xA3\xA4\xA5",
2336           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2337           24,
2338           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
2339           34,
2340           "\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"},
2341       { GCRY_CIPHER_AES, /* Packet Vector #9 */
2342           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2343           13, "\x00\x00\x00\x0B\x0A\x09\x08\xA0\xA1\xA2\xA3\xA4\xA5",
2344           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2345           25,
2346           "\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",
2347           35,
2348           "\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"},
2349       { GCRY_CIPHER_AES, /* Packet Vector #10 */
2350           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2351           13, "\x00\x00\x00\x0C\x0B\x0A\x09\xA0\xA1\xA2\xA3\xA4\xA5",
2352           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2353           19,
2354           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
2355           29,
2356           "\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"},
2357       { GCRY_CIPHER_AES, /* Packet Vector #11 */
2358           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2359           13, "\x00\x00\x00\x0D\x0C\x0B\x0A\xA0\xA1\xA2\xA3\xA4\xA5",
2360           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2361           20,
2362           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
2363           30,
2364           "\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"},
2365       { GCRY_CIPHER_AES, /* Packet Vector #12 */
2366           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2367           13, "\x00\x00\x00\x0E\x0D\x0C\x0B\xA0\xA1\xA2\xA3\xA4\xA5",
2368           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2369           21,
2370           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
2371           31,
2372           "\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"},
2373       { GCRY_CIPHER_AES, /* Packet Vector #13 */
2374           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2375           13, "\x00\x41\x2B\x4E\xA9\xCD\xBE\x3C\x96\x96\x76\x6C\xFA",
2376           8, "\x0B\xE1\xA8\x8B\xAC\xE0\x18\xB1",
2377           23,
2378           "\x08\xE8\xCF\x97\xD8\x20\xEA\x25\x84\x60\xE9\x6A\xD9\xCF\x52\x89\x05\x4D\x89\x5C\xEA\xC4\x7C",
2379           31,
2380           "\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"},
2381       { GCRY_CIPHER_AES, /* Packet Vector #14 */
2382           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2383           13, "\x00\x33\x56\x8E\xF7\xB2\x63\x3C\x96\x96\x76\x6C\xFA",
2384           8, "\x63\x01\x8F\x76\xDC\x8A\x1B\xCB",
2385           24,
2386           "\x90\x20\xEA\x6F\x91\xBD\xD8\x5A\xFA\x00\x39\xBA\x4B\xAF\xF9\xBF\xB7\x9C\x70\x28\x94\x9C\xD0\xEC",
2387           32,
2388           "\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"},
2389       { GCRY_CIPHER_AES, /* Packet Vector #15 */
2390           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2391           13, "\x00\x10\x3F\xE4\x13\x36\x71\x3C\x96\x96\x76\x6C\xFA",
2392           8, "\xAA\x6C\xFA\x36\xCA\xE8\x6B\x40",
2393           25,
2394           "\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",
2395           33,
2396           "\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"},
2397       { GCRY_CIPHER_AES, /* Packet Vector #16 */
2398           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2399           13, "\x00\x76\x4C\x63\xB8\x05\x8E\x3C\x96\x96\x76\x6C\xFA",
2400           12, "\xD0\xD0\x73\x5C\x53\x1E\x1B\xEC\xF0\x49\xC2\x44",
2401           19,
2402           "\x12\xDA\xAC\x56\x30\xEF\xA5\x39\x6F\x77\x0C\xE1\xA6\x6B\x21\xF7\xB2\x10\x1C",
2403           27,
2404           "\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"},
2405       { GCRY_CIPHER_AES, /* Packet Vector #17 */
2406           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2407           13, "\x00\xF8\xB6\x78\x09\x4E\x3B\x3C\x96\x96\x76\x6C\xFA",
2408           12, "\x77\xB6\x0F\x01\x1C\x03\xE1\x52\x58\x99\xBC\xAE",
2409           20,
2410           "\xE8\x8B\x6A\x46\xC7\x8D\x63\xE5\x2E\xB8\xC5\x46\xEF\xB5\xDE\x6F\x75\xE9\xCC\x0D",
2411           28,
2412           "\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"},
2413       { GCRY_CIPHER_AES, /* Packet Vector #18 */
2414           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2415           13, "\x00\xD5\x60\x91\x2D\x3F\x70\x3C\x96\x96\x76\x6C\xFA",
2416           12, "\xCD\x90\x44\xD2\xB7\x1F\xDB\x81\x20\xEA\x60\xC0",
2417           21,
2418           "\x64\x35\xAC\xBA\xFB\x11\xA8\x2E\x2F\x07\x1D\x7C\xA4\xA5\xEB\xD9\x3A\x80\x3B\xA8\x7F",
2419           29,
2420           "\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"},
2421       { GCRY_CIPHER_AES, /* Packet Vector #19 */
2422           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2423           13, "\x00\x42\xFF\xF8\xF1\x95\x1C\x3C\x96\x96\x76\x6C\xFA",
2424           8, "\xD8\x5B\xC7\xE6\x9F\x94\x4F\xB8",
2425           23,
2426           "\x8A\x19\xB9\x50\xBC\xF7\x1A\x01\x8E\x5E\x67\x01\xC9\x17\x87\x65\x98\x09\xD6\x7D\xBE\xDD\x18",
2427           33,
2428           "\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"},
2429       { GCRY_CIPHER_AES, /* Packet Vector #20 */
2430           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2431           13, "\x00\x92\x0F\x40\xE5\x6C\xDC\x3C\x96\x96\x76\x6C\xFA",
2432           8, "\x74\xA0\xEB\xC9\x06\x9F\x5B\x37",
2433           24,
2434           "\x17\x61\x43\x3C\x37\xC5\xA3\x5F\xC1\xF3\x9F\x40\x63\x02\xEB\x90\x7C\x61\x63\xBE\x38\xC9\x84\x37",
2435           34,
2436           "\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"},
2437       { GCRY_CIPHER_AES, /* Packet Vector #21 */
2438           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2439           13, "\x00\x27\xCA\x0C\x71\x20\xBC\x3C\x96\x96\x76\x6C\xFA",
2440           8, "\x44\xA3\xAA\x3A\xAE\x64\x75\xCA",
2441           25,
2442           "\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",
2443           35,
2444           "\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"},
2445       { GCRY_CIPHER_AES, /* Packet Vector #22 */
2446           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2447           13, "\x00\x5B\x8C\xCB\xCD\x9A\xF8\x3C\x96\x96\x76\x6C\xFA",
2448           12, "\xEC\x46\xBB\x63\xB0\x25\x20\xC3\x3C\x49\xFD\x70",
2449           19,
2450           "\xB9\x6B\x49\xE2\x1D\x62\x17\x41\x63\x28\x75\xDB\x7F\x6C\x92\x43\xD2\xD7\xC2",
2451           29,
2452           "\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"},
2453       { GCRY_CIPHER_AES, /* Packet Vector #23 */
2454           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2455           13, "\x00\x3E\xBE\x94\x04\x4B\x9A\x3C\x96\x96\x76\x6C\xFA",
2456           12, "\x47\xA6\x5A\xC7\x8B\x3D\x59\x42\x27\xE8\x5E\x71",
2457           20,
2458           "\xE2\xFC\xFB\xB8\x80\x44\x2C\x73\x1B\xF9\x51\x67\xC8\xFF\xD7\x89\x5E\x33\x70\x76",
2459           30,
2460           "\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"},
2461       { GCRY_CIPHER_AES, /* Packet Vector #24 */
2462           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
2463           13, "\x00\x8D\x49\x3B\x30\xAE\x8B\x3C\x96\x96\x76\x6C\xFA",
2464           12, "\x6E\x37\xA6\xEF\x54\x6D\x95\x5D\x34\xAB\x60\x59",
2465           21,
2466           "\xAB\xF2\x1C\x0B\x02\xFE\xB8\x8F\x85\x6D\xF4\xA3\x73\x81\xBC\xE3\xCC\x12\x85\x17\xD4",
2467           31,
2468           "\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"},
2469       /* RFC 5528 */
2470       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #1 */
2471           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2472           13, "\x00\x00\x00\x03\x02\x01\x00\xA0\xA1\xA2\xA3\xA4\xA5",
2473           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2474           23,
2475           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
2476           31,
2477           "\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"},
2478       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #2 */
2479           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2480           13, "\x00\x00\x00\x04\x03\x02\x01\xA0\xA1\xA2\xA3\xA4\xA5",
2481           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2482           24,
2483           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
2484           32,
2485           "\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"},
2486       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #3 */
2487           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2488           13, "\x00\x00\x00\x05\x04\x03\x02\xA0\xA1\xA2\xA3\xA4\xA5",
2489           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2490           25,
2491           "\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",
2492           33,
2493           "\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"},
2494       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #4 */
2495           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2496           13, "\x00\x00\x00\x06\x05\x04\x03\xA0\xA1\xA2\xA3\xA4\xA5",
2497           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2498           19,
2499           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
2500           27,
2501           "\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"},
2502       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #5 */
2503           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2504           13, "\x00\x00\x00\x07\x06\x05\x04\xA0\xA1\xA2\xA3\xA4\xA5",
2505           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2506           20,
2507           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
2508           28,
2509           "\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"},
2510       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #6 */
2511           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2512           13, "\x00\x00\x00\x08\x07\x06\x05\xA0\xA1\xA2\xA3\xA4\xA5",
2513           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2514           21,
2515           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
2516           29,
2517           "\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"},
2518       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #7 */
2519           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2520           13, "\x00\x00\x00\x09\x08\x07\x06\xA0\xA1\xA2\xA3\xA4\xA5",
2521           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2522           23,
2523           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
2524           33,
2525           "\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"},
2526       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #8 */
2527           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2528           13, "\x00\x00\x00\x0A\x09\x08\x07\xA0\xA1\xA2\xA3\xA4\xA5",
2529           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2530           24,
2531           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
2532           34,
2533           "\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"},
2534       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #9 */
2535           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2536           13, "\x00\x00\x00\x0B\x0A\x09\x08\xA0\xA1\xA2\xA3\xA4\xA5",
2537           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
2538           25,
2539           "\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",
2540           35,
2541           "\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"},
2542       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #10 */
2543           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2544           13, "\x00\x00\x00\x0C\x0B\x0A\x09\xA0\xA1\xA2\xA3\xA4\xA5",
2545           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2546           19,
2547           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
2548           29,
2549           "\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"},
2550       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #11 */
2551           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2552           13, "\x00\x00\x00\x0D\x0C\x0B\x0A\xA0\xA1\xA2\xA3\xA4\xA5",
2553           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2554           20,
2555           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
2556           30,
2557           "\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"},
2558       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #12 */
2559           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
2560           13, "\x00\x00\x00\x0E\x0D\x0C\x0B\xA0\xA1\xA2\xA3\xA4\xA5",
2561           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
2562           21,
2563           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
2564           31,
2565           "\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"},
2566       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #13 */
2567           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2568           13, "\x00\xA9\x70\x11\x0E\x19\x27\xB1\x60\xB6\xA3\x1C\x1C",
2569           8, "\x6B\x7F\x46\x45\x07\xFA\xE4\x96",
2570           23,
2571           "\xC6\xB5\xF3\xE6\xCA\x23\x11\xAE\xF7\x47\x2B\x20\x3E\x73\x5E\xA5\x61\xAD\xB1\x7D\x56\xC5\xA3",
2572           31,
2573           "\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"},
2574       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #14 */
2575           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2576           13, "\x00\x83\xCD\x8C\xE0\xCB\x42\xB1\x60\xB6\xA3\x1C\x1C",
2577           8, "\x98\x66\x05\xB4\x3D\xF1\x5D\xE7",
2578           24,
2579           "\x01\xF6\xCE\x67\x64\xC5\x74\x48\x3B\xB0\x2E\x6B\xBF\x1E\x0A\xBD\x26\xA2\x25\x72\xB4\xD8\x0E\xE7",
2580           32,
2581           "\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"},
2582       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #15 */
2583           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2584           13, "\x00\x5F\x54\x95\x0B\x18\xF2\xB1\x60\xB6\xA3\x1C\x1C",
2585           8, "\x48\xF2\xE7\xE1\xA7\x67\x1A\x51",
2586           25,
2587           "\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",
2588           33,
2589           "\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"},
2590       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #16 */
2591           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2592           13, "\x00\xEC\x60\x08\x63\x31\x9A\xB1\x60\xB6\xA3\x1C\x1C",
2593           12, "\xDE\x97\xDF\x3B\x8C\xBD\x6D\x8E\x50\x30\xDA\x4C",
2594           19,
2595           "\xB0\x05\xDC\xFA\x0B\x59\x18\x14\x26\xA9\x61\x68\x5A\x99\x3D\x8C\x43\x18\x5B",
2596           27,
2597           "\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"},
2598       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #17 */
2599           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2600           13, "\x00\x60\xCF\xF1\xA3\x1E\xA1\xB1\x60\xB6\xA3\x1C\x1C",
2601           12, "\xA5\xEE\x93\xE4\x57\xDF\x05\x46\x6E\x78\x2D\xCF",
2602           20,
2603           "\x2E\x20\x21\x12\x98\x10\x5F\x12\x9D\x5E\xD9\x5B\x93\xF7\x2D\x30\xB2\xFA\xCC\xD7",
2604           28,
2605           "\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"},
2606       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #18 */
2607           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2608           13, "\x00\x0F\x85\xCD\x99\x5C\x97\xB1\x60\xB6\xA3\x1C\x1C",
2609           12, "\x24\xAA\x1B\xF9\xA5\xCD\x87\x61\x82\xA2\x50\x74",
2610           21,
2611           "\x26\x45\x94\x1E\x75\x63\x2D\x34\x91\xAF\x0F\xC0\xC9\x87\x6C\x3B\xE4\xAA\x74\x68\xC9",
2612           29,
2613           "\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"},
2614       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #19 */
2615           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2616           13, "\x00\xC2\x9B\x2C\xAA\xC4\xCD\xB1\x60\xB6\xA3\x1C\x1C",
2617           8, "\x69\x19\x46\xB9\xCA\x07\xBE\x87",
2618           23,
2619           "\x07\x01\x35\xA6\x43\x7C\x9D\xB1\x20\xCD\x61\xD8\xF6\xC3\x9C\x3E\xA1\x25\xFD\x95\xA0\xD2\x3D",
2620           33,
2621           "\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"},
2622       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #20 */
2623           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2624           13, "\x00\x2C\x6B\x75\x95\xEE\x62\xB1\x60\xB6\xA3\x1C\x1C",
2625           8, "\xD0\xC5\x4E\xCB\x84\x62\x7D\xC4",
2626           24,
2627           "\xC8\xC0\x88\x0E\x6C\x63\x6E\x20\x09\x3D\xD6\x59\x42\x17\xD2\xE1\x88\x77\xDB\x26\x4E\x71\xA5\xCC",
2628           34,
2629           "\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"},
2630       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #21 */
2631           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2632           13, "\x00\xC5\x3C\xD4\xC2\xAA\x24\xB1\x60\xB6\xA3\x1C\x1C",
2633           8, "\xE2\x85\xE0\xE4\x80\x8C\xDA\x3D",
2634           25,
2635           "\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",
2636           35,
2637           "\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"},
2638       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #22 */
2639           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2640           13, "\x00\xBE\xE9\x26\x7F\xBA\xDC\xB1\x60\xB6\xA3\x1C\x1C",
2641           12, "\x6C\xAE\xF9\x94\x11\x41\x57\x0D\x7C\x81\x34\x05",
2642           19,
2643           "\xC2\x38\x82\x2F\xAC\x5F\x98\xFF\x92\x94\x05\xB0\xAD\x12\x7A\x4E\x41\x85\x4E",
2644           29,
2645           "\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"},
2646       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #23 */
2647           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2648           13, "\x00\xDF\xA8\xB1\x24\x50\x07\xB1\x60\xB6\xA3\x1C\x1C",
2649           12, "\x36\xA5\x2C\xF1\x6B\x19\xA2\x03\x7A\xB7\x01\x1E",
2650           20,
2651           "\x4D\xBF\x3E\x77\x4A\xD2\x45\xE5\xD5\x89\x1F\x9D\x1C\x32\xA0\xAE\x02\x2C\x85\xD7",
2652           30,
2653           "\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"},
2654       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #24 */
2655           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
2656           13, "\x00\x3B\x8F\xD8\xD3\xA9\x37\xB1\x60\xB6\xA3\x1C\x1C",
2657           12, "\xA4\xD4\x99\xF7\x84\x19\x72\x8C\x19\x17\x8B\x0C",
2658           21,
2659           "\x9D\xC9\xED\xAE\x2F\xF5\xDF\x86\x36\xE8\xC6\xDE\x0E\xED\x55\xF7\x86\x7E\x33\x33\x7D",
2660           31,
2661           "\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"}
2662     };
2663   static const int cut[] = { 0, 1, 8, 10, 16, 19, -1 };
2664   gcry_cipher_hd_t hde, hdd;
2665   unsigned char out[MAX_DATA_LEN];
2666   u64 ctl_params[3];
2667   int split, aadsplit;
2668   size_t j, i, keylen, blklen, authlen, taglen2;
2669   gcry_error_t err = 0;
2670
2671   if (verbose)
2672     fprintf (stderr, "  Starting CCM checks.\n");
2673
2674   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
2675     {
2676       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
2677         {
2678           if (verbose)
2679             fprintf (stderr, "  algorithm %d not available in fips mode\n",
2680                      tv[i].algo);
2681           continue;
2682         }
2683
2684       if (verbose)
2685         fprintf (stderr, "    checking CCM mode for %s [%i]\n",
2686                  gcry_cipher_algo_name (tv[i].algo),
2687                  tv[i].algo);
2688
2689       for (j = 0; j < sizeof (cut) / sizeof (cut[0]); j++)
2690         {
2691           split = cut[j] < 0 ? tv[i].plainlen : cut[j];
2692           if (tv[i].plainlen < split)
2693             continue;
2694
2695           err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_CCM, 0);
2696           if (!err)
2697             err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_CCM, 0);
2698           if (err)
2699             {
2700               fail ("cipher-ccm, gcry_cipher_open failed: %s\n",
2701                     gpg_strerror (err));
2702               return;
2703             }
2704
2705           keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
2706           if (!keylen)
2707             {
2708               fail ("cipher-ccm, gcry_cipher_get_algo_keylen failed\n");
2709               return;
2710             }
2711
2712           err = gcry_cipher_setkey (hde, tv[i].key, keylen);
2713           if (!err)
2714             err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
2715           if (err)
2716             {
2717               fail ("cipher-ccm, gcry_cipher_setkey failed: %s\n",
2718                     gpg_strerror (err));
2719               gcry_cipher_close (hde);
2720               gcry_cipher_close (hdd);
2721               return;
2722             }
2723
2724           blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
2725           if (!blklen)
2726             {
2727               fail ("cipher-ccm, gcry_cipher_get_algo_blklen failed\n");
2728               return;
2729             }
2730
2731           err = gcry_cipher_setiv (hde, tv[i].nonce, tv[i].noncelen);
2732           if (!err)
2733             err = gcry_cipher_setiv (hdd, tv[i].nonce, tv[i].noncelen);
2734           if (err)
2735             {
2736               fail ("cipher-ccm, gcry_cipher_setiv failed: %s\n",
2737                     gpg_strerror (err));
2738               gcry_cipher_close (hde);
2739               gcry_cipher_close (hdd);
2740               return;
2741             }
2742
2743           authlen = tv[i].cipherlen - tv[i].plainlen;
2744           ctl_params[0] = tv[i].plainlen; /* encryptedlen */
2745           ctl_params[1] = tv[i].aadlen; /* aadlen */
2746           ctl_params[2] = authlen; /* authtaglen */
2747           err = gcry_cipher_ctl (hde, GCRYCTL_SET_CCM_LENGTHS, ctl_params,
2748                                  sizeof(ctl_params));
2749           if (!err)
2750             err = gcry_cipher_ctl (hdd, GCRYCTL_SET_CCM_LENGTHS, ctl_params,
2751                                    sizeof(ctl_params));
2752           if (err)
2753             {
2754               fail ("cipher-ccm, gcry_cipher_ctl GCRYCTL_SET_CCM_LENGTHS "
2755                     "failed: %s\n", gpg_strerror (err));
2756               gcry_cipher_close (hde);
2757               gcry_cipher_close (hdd);
2758               return;
2759             }
2760
2761           err = gcry_cipher_info (hde, GCRYCTL_GET_TAGLEN, NULL, &taglen2);
2762           if (err)
2763             {
2764               fail ("cipher-ccm, gcryctl_get_taglen failed (tv %lu): %s\n",
2765                     (unsigned long) i, gpg_strerror (err));
2766               gcry_cipher_close (hde);
2767               gcry_cipher_close (hdd);
2768               return;
2769             }
2770           if (taglen2 != authlen)
2771             {
2772               fail ("cipher-ccm, gcryctl_get_taglen returned bad length"
2773                     " (tv %lu): got=%zu want=%zu\n",
2774                     (unsigned long) i, taglen2, authlen);
2775               gcry_cipher_close (hde);
2776               gcry_cipher_close (hdd);
2777               return;
2778             }
2779
2780           aadsplit = split > tv[i].aadlen ? 0 : split;
2781
2782           err = gcry_cipher_authenticate (hde, tv[i].aad,
2783                                           tv[i].aadlen - aadsplit);
2784           if (!err)
2785             err = gcry_cipher_authenticate (hde,
2786                                             &tv[i].aad[tv[i].aadlen - aadsplit],
2787                                             aadsplit);
2788           if (!err)
2789             err = gcry_cipher_authenticate (hdd, tv[i].aad,
2790                                             tv[i].aadlen - aadsplit);
2791           if (!err)
2792             err = gcry_cipher_authenticate (hdd,
2793                                             &tv[i].aad[tv[i].aadlen - aadsplit],
2794                                             aadsplit);
2795           if (err)
2796             {
2797               fail ("cipher-ccm, gcry_cipher_authenticate failed: %s\n",
2798                    gpg_strerror (err));
2799               gcry_cipher_close (hde);
2800               gcry_cipher_close (hdd);
2801               return;
2802             }
2803
2804           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN, tv[i].plaintext,
2805                                      tv[i].plainlen - split);
2806           if (!err)
2807             err = gcry_cipher_encrypt (hde, &out[tv[i].plainlen - split],
2808                                        MAX_DATA_LEN - (tv[i].plainlen - split),
2809                                        &tv[i].plaintext[tv[i].plainlen - split],
2810                                        split);
2811           if (err)
2812             {
2813               fail ("cipher-ccm, gcry_cipher_encrypt (%lu:%lu) failed: %s\n",
2814                     (unsigned long) i, (unsigned long) j, gpg_strerror (err));
2815               gcry_cipher_close (hde);
2816               gcry_cipher_close (hdd);
2817               return;
2818             }
2819
2820           err = gcry_cipher_gettag (hde, &out[tv[i].plainlen], authlen);
2821           if (err)
2822             {
2823               fail ("cipher-ccm, gcry_cipher_gettag (%lu:%lu) failed: %s\n",
2824                     (unsigned long) i, (unsigned long) j, gpg_strerror (err));
2825               gcry_cipher_close (hde);
2826               gcry_cipher_close (hdd);
2827               return;
2828             }
2829
2830           if (memcmp (tv[i].ciphertext, out, tv[i].cipherlen))
2831             fail ("cipher-ccm, encrypt mismatch entry %lu:%lu\n",
2832                   (unsigned long) i, (unsigned long) j);
2833
2834           err = gcry_cipher_decrypt (hdd, out, tv[i].plainlen - split, NULL, 0);
2835           if (!err)
2836             err = gcry_cipher_decrypt (hdd, &out[tv[i].plainlen - split], split,
2837                                        NULL, 0);
2838           if (err)
2839             {
2840               fail ("cipher-ccm, gcry_cipher_decrypt (%lu:%lu) failed: %s\n",
2841                     (unsigned long) i, (unsigned long) j, gpg_strerror (err));
2842               gcry_cipher_close (hde);
2843               gcry_cipher_close (hdd);
2844               return;
2845             }
2846
2847           if (memcmp (tv[i].plaintext, out, tv[i].plainlen))
2848             fail ("cipher-ccm, decrypt mismatch entry %lu:%lu\n",
2849                   (unsigned long) i, (unsigned long) j);
2850
2851           err = gcry_cipher_checktag (hdd, &out[tv[i].plainlen], authlen);
2852           if (err)
2853             {
2854               fail ("cipher-ccm, gcry_cipher_checktag (%lu:%lu) failed: %s\n",
2855                     (unsigned long) i, (unsigned long) j, gpg_strerror (err));
2856               gcry_cipher_close (hde);
2857               gcry_cipher_close (hdd);
2858               return;
2859             }
2860
2861           gcry_cipher_close (hde);
2862           gcry_cipher_close (hdd);
2863         }
2864     }
2865
2866   /* Large buffer tests.  */
2867
2868   /* Test encoding of aadlen > 0xfeff.  */
2869   {
2870     static const char key[]={0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
2871                              0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f};
2872     static const char iv[]={0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19};
2873     static const char tag[]={0x9C,0x76,0xE7,0x33,0xD5,0x15,0xB3,0x6C,
2874                              0xBA,0x76,0x95,0xF7,0xFB,0x91};
2875     char buf[1024];
2876     size_t enclen = 0x20000;
2877     size_t aadlen = 0x20000;
2878     size_t taglen = sizeof(tag);
2879
2880     err = gcry_cipher_open (&hde, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CCM, 0);
2881     if (err)
2882       {
2883         fail ("cipher-ccm-large, gcry_cipher_open failed: %s\n",
2884               gpg_strerror (err));
2885         return;
2886       }
2887
2888     err = gcry_cipher_setkey (hde, key, sizeof (key));
2889     if (err)
2890       {
2891          fail ("cipher-ccm-large, gcry_cipher_setkey failed: %s\n",
2892                gpg_strerror (err));
2893          gcry_cipher_close (hde);
2894          return;
2895       }
2896
2897     err = gcry_cipher_setiv (hde, iv, sizeof (iv));
2898     if (err)
2899       {
2900         fail ("cipher-ccm-large, gcry_cipher_setiv failed: %s\n",
2901               gpg_strerror (err));
2902         gcry_cipher_close (hde);
2903         return;
2904       }
2905
2906     ctl_params[0] = enclen; /* encryptedlen */
2907     ctl_params[1] = aadlen; /* aadlen */
2908     ctl_params[2] = taglen; /* authtaglen */
2909     err = gcry_cipher_ctl (hde, GCRYCTL_SET_CCM_LENGTHS, ctl_params,
2910                            sizeof(ctl_params));
2911     if (err)
2912       {
2913         fail ("cipher-ccm-large, gcry_cipher_ctl GCRYCTL_SET_CCM_LENGTHS "
2914               "failed: %s\n", gpg_strerror (err));
2915         gcry_cipher_close (hde);
2916         return;
2917       }
2918
2919     memset (buf, 0xaa, sizeof(buf));
2920
2921     for (i = 0; i < aadlen; i += sizeof(buf))
2922       {
2923         err = gcry_cipher_authenticate (hde, buf, sizeof (buf));
2924         if (err)
2925           {
2926             fail ("cipher-ccm-large, gcry_cipher_authenticate failed: %s\n",
2927                  gpg_strerror (err));
2928             gcry_cipher_close (hde);
2929             return;
2930           }
2931       }
2932
2933     for (i = 0; i < enclen; i += sizeof(buf))
2934       {
2935         memset (buf, 0xee, sizeof(buf));
2936         err = gcry_cipher_encrypt (hde, buf, sizeof (buf), NULL, 0);
2937         if (err)
2938           {
2939             fail ("cipher-ccm-large, gcry_cipher_encrypt failed: %s\n",
2940                  gpg_strerror (err));
2941             gcry_cipher_close (hde);
2942             return;
2943           }
2944       }
2945
2946     err = gcry_cipher_gettag (hde, buf, taglen);
2947     if (err)
2948       {
2949         fail ("cipher-ccm-large, gcry_cipher_gettag failed: %s\n",
2950               gpg_strerror (err));
2951         gcry_cipher_close (hde);
2952         return;
2953       }
2954
2955     if (memcmp (buf, tag, taglen) != 0)
2956       fail ("cipher-ccm-large, encrypt mismatch entry\n");
2957
2958     gcry_cipher_close (hde);
2959   }
2960
2961 #if 0
2962   /* Test encoding of aadlen > 0xffffffff.  */
2963   {
2964     static const char key[]={0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
2965                              0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f};
2966     static const char iv[]={0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19};
2967     static const char tag[]={0x01,0xB2,0xC3,0x4A,0xA6,0x6A,0x07,0x6D,
2968                              0xBC,0xBD,0xEA,0x17,0xD3,0x73,0xD7,0xD4};
2969     char buf[1024];
2970     size_t enclen = (size_t)0xffffffff + 1 + 1024;
2971     size_t aadlen = (size_t)0xffffffff + 1 + 1024;
2972     size_t taglen = sizeof(tag);
2973
2974     err = gcry_cipher_open (&hde, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CCM, 0);
2975     if (err)
2976       {
2977         fail ("cipher-ccm-huge, gcry_cipher_open failed: %s\n",
2978               gpg_strerror (err));
2979         return;
2980       }
2981
2982     err = gcry_cipher_setkey (hde, key, sizeof (key));
2983     if (err)
2984       {
2985          fail ("cipher-ccm-huge, gcry_cipher_setkey failed: %s\n",
2986                gpg_strerror (err));
2987          gcry_cipher_close (hde);
2988          return;
2989       }
2990
2991     err = gcry_cipher_setiv (hde, iv, sizeof (iv));
2992     if (err)
2993       {
2994         fail ("cipher-ccm-huge, gcry_cipher_setiv failed: %s\n",
2995               gpg_strerror (err));
2996         gcry_cipher_close (hde);
2997         return;
2998       }
2999
3000     ctl_params[0] = enclen; /* encryptedlen */
3001     ctl_params[1] = aadlen; /* aadlen */
3002     ctl_params[2] = taglen; /* authtaglen */
3003     err = gcry_cipher_ctl (hde, GCRYCTL_SET_CCM_LENGTHS, ctl_params,
3004                            sizeof(ctl_params));
3005     if (err)
3006       {
3007         fail ("cipher-ccm-huge, gcry_cipher_ctl GCRYCTL_SET_CCM_LENGTHS failed:"
3008               "%s\n", gpg_strerror (err));
3009         gcry_cipher_close (hde);
3010         return;
3011       }
3012
3013     memset (buf, 0xaa, sizeof(buf));
3014
3015     for (i = 0; i < aadlen; i += sizeof(buf))
3016       {
3017         err = gcry_cipher_authenticate (hde, buf, sizeof (buf));
3018         if (err)
3019           {
3020             fail ("cipher-ccm-huge, gcry_cipher_authenticate failed: %s\n",
3021                  gpg_strerror (err));
3022             gcry_cipher_close (hde);
3023             return;
3024           }
3025       }
3026
3027     for (i = 0; i < enclen; i += sizeof(buf))
3028       {
3029         memset (buf, 0xee, sizeof(buf));
3030         err = gcry_cipher_encrypt (hde, buf, sizeof (buf), NULL, 0);
3031         if (err)
3032           {
3033             fail ("cipher-ccm-huge, gcry_cipher_encrypt failed: %s\n",
3034                  gpg_strerror (err));
3035             gcry_cipher_close (hde);
3036             return;
3037           }
3038       }
3039
3040     err = gcry_cipher_gettag (hde, buf, taglen);
3041     if (err)
3042       {
3043         fail ("cipher-ccm-huge, gcry_cipher_gettag failed: %s\n",
3044               gpg_strerror (err));
3045         gcry_cipher_close (hde);
3046         return;
3047       }
3048
3049     if (memcmp (buf, tag, taglen) != 0)
3050       fail ("cipher-ccm-huge, encrypt mismatch entry\n");
3051
3052     gcry_cipher_close (hde);
3053   }
3054
3055   if (verbose)
3056     fprintf (stderr, "  Completed CCM checks.\n");
3057 #endif
3058 }
3059
3060
3061 static void
3062 do_check_ocb_cipher (int inplace)
3063 {
3064   /* Note that we use hex strings and not binary strings in TV.  That
3065      makes it easier to maintain the test vectors.  */
3066   static const struct
3067   {
3068     int algo;
3069     int taglen;         /* 16, 12, or 8 bytes  */
3070     const char *key;    /* NULL means "000102030405060708090A0B0C0D0E0F" */
3071     const char *nonce;
3072     const char *aad;
3073     const char *plain;
3074     const char *ciph;
3075   } tv[] = {
3076     /* The RFC-7253 test vectos*/
3077     { GCRY_CIPHER_AES, 16, NULL,
3078       "BBAA99887766554433221100",
3079       "",
3080       "",
3081       "785407BFFFC8AD9EDCC5520AC9111EE6"
3082     },
3083     { GCRY_CIPHER_AES, 16, NULL,
3084       "BBAA99887766554433221101",
3085       "0001020304050607",
3086       "0001020304050607",
3087       "6820B3657B6F615A5725BDA0D3B4EB3A257C9AF1F8F03009"
3088     },
3089     { GCRY_CIPHER_AES, 16, NULL,
3090       "BBAA99887766554433221102",
3091       "0001020304050607",
3092       "",
3093       "81017F8203F081277152FADE694A0A00"
3094     },
3095     { GCRY_CIPHER_AES, 16, NULL,
3096       "BBAA99887766554433221103",
3097       "",
3098       "0001020304050607",
3099       "45DD69F8F5AAE72414054CD1F35D82760B2CD00D2F99BFA9"
3100     },
3101     { GCRY_CIPHER_AES, 16, NULL,
3102       "BBAA99887766554433221104",
3103       "000102030405060708090A0B0C0D0E0F",
3104       "000102030405060708090A0B0C0D0E0F",
3105       "571D535B60B277188BE5147170A9A22C3AD7A4FF3835B8C5"
3106       "701C1CCEC8FC3358"
3107     },
3108     { GCRY_CIPHER_AES, 16, NULL,
3109       "BBAA99887766554433221105",
3110       "000102030405060708090A0B0C0D0E0F",
3111       "",
3112       "8CF761B6902EF764462AD86498CA6B97"
3113     },
3114     { GCRY_CIPHER_AES, 16, NULL,
3115       "BBAA99887766554433221106",
3116       "",
3117       "000102030405060708090A0B0C0D0E0F",
3118       "5CE88EC2E0692706A915C00AEB8B2396F40E1C743F52436B"
3119       "DF06D8FA1ECA343D"
3120     },
3121     { GCRY_CIPHER_AES, 16, NULL,
3122       "BBAA99887766554433221107",
3123       "000102030405060708090A0B0C0D0E0F1011121314151617",
3124       "000102030405060708090A0B0C0D0E0F1011121314151617",
3125       "1CA2207308C87C010756104D8840CE1952F09673A448A122"
3126       "C92C62241051F57356D7F3C90BB0E07F"
3127     },
3128     { GCRY_CIPHER_AES, 16, NULL,
3129       "BBAA99887766554433221108",
3130       "000102030405060708090A0B0C0D0E0F1011121314151617",
3131       "",
3132       "6DC225A071FC1B9F7C69F93B0F1E10DE"
3133     },
3134     { GCRY_CIPHER_AES, 16, NULL,
3135       "BBAA99887766554433221109",
3136       "",
3137       "000102030405060708090A0B0C0D0E0F1011121314151617",
3138       "221BD0DE7FA6FE993ECCD769460A0AF2D6CDED0C395B1C3C"
3139       "E725F32494B9F914D85C0B1EB38357FF"
3140     },
3141     { GCRY_CIPHER_AES, 16, NULL,
3142       "BBAA9988776655443322110A",
3143       "000102030405060708090A0B0C0D0E0F1011121314151617"
3144       "18191A1B1C1D1E1F",
3145       "000102030405060708090A0B0C0D0E0F1011121314151617"
3146       "18191A1B1C1D1E1F",
3147       "BD6F6C496201C69296C11EFD138A467ABD3C707924B964DE"
3148       "AFFC40319AF5A48540FBBA186C5553C68AD9F592A79A4240"
3149     },
3150     { GCRY_CIPHER_AES, 16, NULL,
3151       "BBAA9988776655443322110B",
3152       "000102030405060708090A0B0C0D0E0F1011121314151617"
3153       "18191A1B1C1D1E1F",
3154       "",
3155       "FE80690BEE8A485D11F32965BC9D2A32"
3156     },
3157     { GCRY_CIPHER_AES, 16, NULL,
3158       "BBAA9988776655443322110C",
3159       "",
3160       "000102030405060708090A0B0C0D0E0F1011121314151617"
3161       "18191A1B1C1D1E1F",
3162       "2942BFC773BDA23CABC6ACFD9BFD5835BD300F0973792EF4"
3163       "6040C53F1432BCDFB5E1DDE3BC18A5F840B52E653444D5DF"
3164     },
3165     { GCRY_CIPHER_AES, 16, NULL,
3166       "BBAA9988776655443322110D",
3167       "000102030405060708090A0B0C0D0E0F1011121314151617"
3168       "18191A1B1C1D1E1F2021222324252627",
3169       "000102030405060708090A0B0C0D0E0F1011121314151617"
3170       "18191A1B1C1D1E1F2021222324252627",
3171       "D5CA91748410C1751FF8A2F618255B68A0A12E093FF45460"
3172       "6E59F9C1D0DDC54B65E8628E568BAD7AED07BA06A4A69483"
3173       "A7035490C5769E60"
3174     },
3175     { GCRY_CIPHER_AES, 16, NULL,
3176       "BBAA9988776655443322110E",
3177       "000102030405060708090A0B0C0D0E0F1011121314151617"
3178       "18191A1B1C1D1E1F2021222324252627",
3179       "",
3180       "C5CD9D1850C141E358649994EE701B68"
3181     },
3182     { GCRY_CIPHER_AES, 16, NULL,
3183       "BBAA9988776655443322110F",
3184       "",
3185       "000102030405060708090A0B0C0D0E0F1011121314151617"
3186       "18191A1B1C1D1E1F2021222324252627",
3187       "4412923493C57D5DE0D700F753CCE0D1D2D95060122E9F15"
3188       "A5DDBFC5787E50B5CC55EE507BCB084E479AD363AC366B95"
3189       "A98CA5F3000B1479"
3190     },
3191     { GCRY_CIPHER_AES, 12, "0F0E0D0C0B0A09080706050403020100",
3192       "BBAA9988776655443322110D",
3193       "000102030405060708090A0B0C0D0E0F1011121314151617"
3194       "18191A1B1C1D1E1F2021222324252627",
3195       "000102030405060708090A0B0C0D0E0F1011121314151617"
3196       "18191A1B1C1D1E1F2021222324252627",
3197       "1792A4E31E0755FB03E31B22116E6C2DDF9EFD6E33D536F1"
3198       "A0124B0A55BAE884ED93481529C76B6AD0C515F4D1CDD4FD"
3199       "AC4F02AA"
3200     }
3201   };
3202   gpg_error_t err = 0;
3203   gcry_cipher_hd_t hde, hdd;
3204   unsigned char out[MAX_DATA_LEN];
3205   unsigned char tag[16];
3206   int tidx;
3207
3208   if (verbose)
3209     fprintf (stderr, "  Starting OCB checks.\n");
3210
3211   for (tidx = 0; tidx < DIM (tv); tidx++)
3212     {
3213       char *key, *nonce, *aad, *ciph, *plain;
3214       size_t keylen, noncelen, aadlen, ciphlen, plainlen;
3215       int taglen;
3216       size_t taglen2;
3217
3218       if (verbose)
3219         fprintf (stderr, "    checking OCB mode for %s [%i] (tv %d)\n",
3220                  gcry_cipher_algo_name (tv[tidx].algo), tv[tidx].algo, tidx);
3221
3222       /* Convert to hex strings to binary.  */
3223       key   = hex2buffer (tv[tidx].key? tv[tidx].key
3224                           /*        */: "000102030405060708090A0B0C0D0E0F",
3225                           &keylen);
3226       nonce = hex2buffer (tv[tidx].nonce, &noncelen);
3227       aad   = hex2buffer (tv[tidx].aad, &aadlen);
3228       plain = hex2buffer (tv[tidx].plain, &plainlen);
3229       ciph  = hex2buffer (tv[tidx].ciph, &ciphlen);
3230
3231       /* Check that our test vectors are sane.  */
3232       assert (plainlen <= sizeof out);
3233       assert (tv[tidx].taglen <= ciphlen);
3234       assert (tv[tidx].taglen <= sizeof tag);
3235
3236       err = gcry_cipher_open (&hde, tv[tidx].algo, GCRY_CIPHER_MODE_OCB, 0);
3237       if (!err)
3238         err = gcry_cipher_open (&hdd, tv[tidx].algo, GCRY_CIPHER_MODE_OCB, 0);
3239       if (err)
3240         {
3241           fail ("cipher-ocb, gcry_cipher_open failed (tv %d): %s\n",
3242                 tidx, gpg_strerror (err));
3243           return;
3244         }
3245
3246       /* Set the taglen.  For the first handle we do this only for a
3247          non-default taglen.  For the second handle we check that we
3248          can also set to the default taglen.  */
3249       taglen = tv[tidx].taglen;
3250       if (taglen != 16)
3251         {
3252           err = gcry_cipher_ctl (hde, GCRYCTL_SET_TAGLEN,
3253                                  &taglen, sizeof taglen);
3254           if (err)
3255             {
3256               fail ("cipher-ocb, gcryctl_set_taglen failed (tv %d): %s\n",
3257                     tidx, gpg_strerror (err));
3258               gcry_cipher_close (hde);
3259               gcry_cipher_close (hdd);
3260               return;
3261             }
3262         }
3263       err = gcry_cipher_ctl (hdd, GCRYCTL_SET_TAGLEN,
3264                              &taglen, sizeof taglen);
3265       if (err)
3266         {
3267           fail ("cipher-ocb, gcryctl_set_taglen failed (tv %d): %s\n",
3268                 tidx, gpg_strerror (err));
3269           gcry_cipher_close (hde);
3270           gcry_cipher_close (hdd);
3271           return;
3272         }
3273
3274       err = gcry_cipher_info (hde, GCRYCTL_GET_TAGLEN, NULL, &taglen2);
3275       if (err)
3276         {
3277           fail ("cipher-ocb, gcryctl_get_taglen failed (tv %d): %s\n",
3278                 tidx, gpg_strerror (err));
3279           gcry_cipher_close (hde);
3280           gcry_cipher_close (hdd);
3281           return;
3282         }
3283       if (taglen2 != tv[tidx].taglen)
3284         {
3285           fail ("cipher-ocb, gcryctl_get_taglen returned bad length (tv %d): "
3286                 "got=%zu want=%d\n",
3287                 tidx, taglen2, tv[tidx].taglen);
3288           gcry_cipher_close (hde);
3289           gcry_cipher_close (hdd);
3290           return;
3291         }
3292
3293       err = gcry_cipher_setkey (hde, key, keylen);
3294       if (!err)
3295         err = gcry_cipher_setkey (hdd, key, keylen);
3296       if (err)
3297         {
3298           fail ("cipher-ocb, gcry_cipher_setkey failed (tv %d): %s\n",
3299                 tidx, gpg_strerror (err));
3300           gcry_cipher_close (hde);
3301           gcry_cipher_close (hdd);
3302           return;
3303         }
3304
3305       err = gcry_cipher_setiv (hde, nonce, noncelen);
3306       if (!err)
3307         err = gcry_cipher_setiv (hdd, nonce, noncelen);
3308       if (err)
3309         {
3310           fail ("cipher-ocb, gcry_cipher_setiv failed (tv %d): %s\n",
3311                 tidx, gpg_strerror (err));
3312           gcry_cipher_close (hde);
3313           gcry_cipher_close (hdd);
3314           return;
3315         }
3316
3317       err = gcry_cipher_authenticate (hde, aad, aadlen);
3318       if (err)
3319         {
3320           fail ("cipher-ocb, gcry_cipher_authenticate failed (tv %d): %s\n",
3321                 tidx, gpg_strerror (err));
3322           gcry_cipher_close (hde);
3323           gcry_cipher_close (hdd);
3324           return;
3325         }
3326
3327       err = gcry_cipher_final (hde);
3328       if (!err)
3329         {
3330           if (inplace)
3331             {
3332               memcpy(out, plain, plainlen);
3333               err = gcry_cipher_encrypt (hde, out, plainlen, NULL, 0);
3334             }
3335           else
3336             {
3337               err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
3338                                          plain, plainlen);
3339             }
3340         }
3341       if (err)
3342         {
3343           fail ("cipher-ocb, gcry_cipher_encrypt failed (tv %d): %s\n",
3344                 tidx, gpg_strerror (err));
3345           gcry_cipher_close (hde);
3346           gcry_cipher_close (hdd);
3347           return;
3348         }
3349
3350       /* Check that the encrypt output matches the expected cipher
3351          text without the tag (i.e. at the length of plaintext).  */
3352       if (memcmp (ciph, out, plainlen))
3353         {
3354           mismatch (ciph, plainlen, out, plainlen);
3355           fail ("cipher-ocb, encrypt data mismatch (tv %d)\n", tidx);
3356         }
3357
3358       /* Check that the tag matches TAGLEN bytes from the end of the
3359          expected ciphertext.  */
3360       err = gcry_cipher_gettag (hde, tag, tv[tidx].taglen);
3361       if (err)
3362         {
3363           fail ("cipher_ocb, gcry_cipher_gettag failed (tv %d): %s\n",
3364                 tidx, gpg_strerror (err));
3365         }
3366       if (memcmp (ciph + ciphlen - tv[tidx].taglen, tag, tv[tidx].taglen))
3367         {
3368           mismatch (ciph + ciphlen - tv[tidx].taglen, tv[tidx].taglen,
3369                     tag, tv[tidx].taglen);
3370           fail ("cipher-ocb, encrypt tag mismatch (tv %d)\n", tidx);
3371         }
3372
3373
3374       err = gcry_cipher_authenticate (hdd, aad, aadlen);
3375       if (err)
3376         {
3377           fail ("cipher-ocb, gcry_cipher_authenticate failed (tv %d): %s\n",
3378                 tidx, gpg_strerror (err));
3379           gcry_cipher_close (hde);
3380           gcry_cipher_close (hdd);