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