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