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