CTR mode may now be used with arbitrary long data chunks.
[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  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <stdarg.h>
28
29 #include "../src/gcrypt.h"
30
31 #ifndef DIM
32 # define DIM(v)              (sizeof(v)/sizeof((v)[0]))
33 #endif
34
35
36 typedef struct test_spec_pubkey_key
37 {
38   const char *secret;
39   const char *public;
40   const char *grip;
41 }
42 test_spec_pubkey_key_t;
43
44 typedef struct test_spec_pubkey
45 {
46   int id;
47   int flags;
48   test_spec_pubkey_key_t key;
49 }
50 test_spec_pubkey_t;
51
52 #define FLAG_CRYPT (1 << 0)
53 #define FLAG_SIGN  (1 << 1)
54 #define FLAG_GRIP  (1 << 2)
55
56 static int verbose;
57 static int error_count;
58 static int in_fips_mode;
59
60 static void
61 fail (const char *format, ...)
62 {
63   va_list arg_ptr;
64
65   va_start (arg_ptr, format);
66   vfprintf (stderr, format, arg_ptr);
67   va_end (arg_ptr);
68   error_count++;
69 }
70
71 static void
72 mismatch (const void *expected, size_t expectedlen,
73           const void *computed, size_t computedlen)
74 {
75   const unsigned char *p;
76
77   fprintf (stderr, "expected:");
78   for (p = expected; expectedlen; p++, expectedlen--)
79     fprintf (stderr, " %02x", *p);
80   fprintf (stderr, "\ncomputed:");
81   for (p = computed; computedlen; p++, computedlen--)
82     fprintf (stderr, " %02x", *p);
83   fprintf (stderr, "\n");
84 }
85
86
87 static void
88 die (const char *format, ...)
89 {
90   va_list arg_ptr;
91
92   va_start (arg_ptr, format);
93   vfprintf (stderr, format, arg_ptr);
94   va_end (arg_ptr);
95   exit (1);
96 }
97
98 #define MAX_DATA_LEN 100
99
100 void
101 progress_handler (void *cb_data, const char *what, int printchar,
102                   int current, int total)
103 {
104   (void)cb_data;
105   (void)what;
106   (void)current;
107   (void)total;
108
109   if (printchar == '\n')
110     fputs ( "<LF>", stdout);
111   else
112     putchar (printchar);
113   fflush (stdout);
114 }
115
116 static void
117 check_cbc_mac_cipher (void)
118 {
119   struct tv
120   {
121     int algo;
122     char key[MAX_DATA_LEN];
123     unsigned char plaintext[MAX_DATA_LEN];
124     size_t plaintextlen;
125     char mac[MAX_DATA_LEN];
126   }
127   tv[] =
128     {
129       { GCRY_CIPHER_AES,
130         "chicken teriyaki",
131         "This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
132         0, "\x23\x8f\x6d\xc7\x53\x6a\x62\x97\x11\xc4\xa5\x16\x43\xea\xb0\xb6" },
133       { GCRY_CIPHER_3DES,
134         "abcdefghABCDEFGH01234567",
135         "This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
136         0, "\x5c\x11\xf0\x01\x47\xbd\x3d\x3a" },
137       { GCRY_CIPHER_DES,
138         "abcdefgh",
139         "This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
140         0, "\xfa\x4b\xdf\x9d\xfa\xab\x01\x70" }
141     };
142   gcry_cipher_hd_t hd;
143   unsigned char out[MAX_DATA_LEN];
144   int i, blklen, keylen;
145   gcry_error_t err = 0;
146
147   if (verbose)
148     fprintf (stderr, "  Starting CBC MAC checks.\n");
149
150   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
151     {
152       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
153         {
154           if (verbose)
155             fprintf (stderr, "  algorithm %d not available in fips mode\n",
156                      tv[i].algo);
157           continue;
158         }
159
160       err = gcry_cipher_open (&hd,
161                               tv[i].algo,
162                               GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_MAC);
163       if (!hd)
164         {
165           fail ("cbc-mac algo %d, gcry_cipher_open failed: %s\n",
166                 tv[i].algo, gpg_strerror (err));
167           return;
168         }
169
170       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
171       if (!blklen)
172         {
173           fail ("cbc-mac algo %d, gcry_cipher_get_algo_blklen failed\n",
174                  tv[i].algo);
175           gcry_cipher_close (hd);
176           return;
177         }
178
179       keylen = gcry_cipher_get_algo_keylen (tv[i].algo);
180       if (!keylen)
181         {
182           fail ("cbc-mac algo %d, gcry_cipher_get_algo_keylen failed\n",
183                 tv[i].algo);
184           return;
185         }
186
187       err = gcry_cipher_setkey (hd, tv[i].key, keylen);
188       if (err)
189         {
190           fail ("cbc-mac algo %d, gcry_cipher_setkey failed: %s\n",
191                 tv[i].algo, gpg_strerror (err));
192           gcry_cipher_close (hd);
193           return;
194         }
195
196       err = gcry_cipher_setiv (hd, NULL, 0);
197       if (err)
198         {
199           fail ("cbc-mac algo %d, gcry_cipher_setiv failed: %s\n",
200                 tv[i].algo, gpg_strerror (err));
201           gcry_cipher_close (hd);
202           return;
203         }
204
205       if (verbose)
206         fprintf (stderr, "    checking CBC MAC for %s [%i]\n",
207                  gcry_cipher_algo_name (tv[i].algo),
208                  tv[i].algo);
209       err = gcry_cipher_encrypt (hd,
210                                  out, blklen,
211                                  tv[i].plaintext,
212                                  tv[i].plaintextlen ?
213                                  tv[i].plaintextlen :
214                                  strlen ((char*)tv[i].plaintext));
215       if (err)
216         {
217           fail ("cbc-mac algo %d, gcry_cipher_encrypt failed: %s\n",
218                 tv[i].algo, gpg_strerror (err));
219           gcry_cipher_close (hd);
220           return;
221         }
222
223 #if 0
224       {
225         int j;
226         for (j = 0; j < gcry_cipher_get_algo_blklen (tv[i].algo); j++)
227           printf ("\\x%02x", out[j] & 0xFF);
228         printf ("\n");
229       }
230 #endif
231
232       if (memcmp (tv[i].mac, out, blklen))
233         fail ("cbc-mac algo %d, encrypt mismatch entry %d\n", tv[i].algo, i);
234
235       gcry_cipher_close (hd);
236     }
237   if (verbose)
238     fprintf (stderr, "  Completed CBC MAC checks.\n");
239 }
240
241 static void
242 check_aes128_cbc_cts_cipher (void)
243 {
244   char key[128 / 8] = "chicken teriyaki";
245   unsigned char plaintext[] =
246     "I would like the General Gau's Chicken, please, and wonton soup.";
247   struct tv
248   {
249     unsigned char out[MAX_DATA_LEN];
250     int inlen;
251   } tv[] =
252     {
253       { "\xc6\x35\x35\x68\xf2\xbf\x8c\xb4\xd8\xa5\x80\x36\x2d\xa7\xff\x7f"
254         "\x97",
255         17 },
256       { "\xfc\x00\x78\x3e\x0e\xfd\xb2\xc1\xd4\x45\xd4\xc8\xef\xf7\xed\x22"
257         "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5",
258         31 },
259       { "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8"
260         "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84",
261         32 },
262       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
263         "\xb3\xff\xfd\x94\x0c\x16\xa1\x8c\x1b\x55\x49\xd2\xf8\x38\x02\x9e"
264         "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5",
265         47 },
266       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
267         "\x9d\xad\x8b\xbb\x96\xc4\xcd\xc0\x3b\xc1\x03\xe1\xa1\x94\xbb\xd8"
268         "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8",
269         48 },
270       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
271         "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8"
272         "\x48\x07\xef\xe8\x36\xee\x89\xa5\x26\x73\x0d\xbc\x2f\x7b\xc8\x40"
273         "\x9d\xad\x8b\xbb\x96\xc4\xcd\xc0\x3b\xc1\x03\xe1\xa1\x94\xbb\xd8",
274         64 },
275     };
276   gcry_cipher_hd_t hd;
277   unsigned char out[MAX_DATA_LEN];
278   int i;
279   gcry_error_t err = 0;
280
281   if (verbose)
282     fprintf (stderr, "  Starting AES128 CBC CTS checks.\n");
283   err = gcry_cipher_open (&hd,
284                           GCRY_CIPHER_AES,
285                           GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_CTS);
286   if (err)
287     {
288       fail ("aes-cbc-cts, gcry_cipher_open failed: %s\n", gpg_strerror (err));
289       return;
290     }
291
292   err = gcry_cipher_setkey (hd, key, 128 / 8);
293   if (err)
294     {
295       fail ("aes-cbc-cts, gcry_cipher_setkey failed: %s\n",
296             gpg_strerror (err));
297       gcry_cipher_close (hd);
298       return;
299     }
300
301   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
302     {
303       err = gcry_cipher_setiv (hd, NULL, 0);
304       if (err)
305         {
306           fail ("aes-cbc-cts, gcry_cipher_setiv failed: %s\n",
307                 gpg_strerror (err));
308           gcry_cipher_close (hd);
309           return;
310         }
311
312       if (verbose)
313         fprintf (stderr, "    checking encryption for length %i\n", tv[i].inlen);
314       err = gcry_cipher_encrypt (hd, out, MAX_DATA_LEN,
315                                  plaintext, tv[i].inlen);
316       if (err)
317         {
318           fail ("aes-cbc-cts, gcry_cipher_encrypt failed: %s\n",
319                 gpg_strerror (err));
320           gcry_cipher_close (hd);
321           return;
322         }
323
324       if (memcmp (tv[i].out, out, tv[i].inlen))
325         fail ("aes-cbc-cts, encrypt mismatch entry %d\n", i);
326
327       err = gcry_cipher_setiv (hd, NULL, 0);
328       if (err)
329         {
330           fail ("aes-cbc-cts, gcry_cipher_setiv failed: %s\n",
331                 gpg_strerror (err));
332           gcry_cipher_close (hd);
333           return;
334         }
335       if (verbose)
336         fprintf (stderr, "    checking decryption for length %i\n", tv[i].inlen);
337       err = gcry_cipher_decrypt (hd, out, tv[i].inlen, NULL, 0);
338       if (err)
339         {
340           fail ("aes-cbc-cts, gcry_cipher_decrypt failed: %s\n",
341                 gpg_strerror (err));
342           gcry_cipher_close (hd);
343           return;
344         }
345
346       if (memcmp (plaintext, out, tv[i].inlen))
347         fail ("aes-cbc-cts, decrypt mismatch entry %d\n", i);
348     }
349
350   gcry_cipher_close (hd);
351   if (verbose)
352     fprintf (stderr, "  Completed AES128 CBC CTS checks.\n");
353 }
354
355 static void
356 check_ctr_cipher (void)
357 {
358   struct tv
359   {
360     int algo;
361     char key[MAX_DATA_LEN];
362     char ctr[MAX_DATA_LEN];
363     struct data
364     {
365       unsigned char plaintext[MAX_DATA_LEN];
366       int inlen;
367       char out[MAX_DATA_LEN];
368     } data[8];
369   } tv[] =
370     {
371       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
372       { GCRY_CIPHER_AES,
373         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
374         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
375         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
376             16,
377             "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
378           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
379             16,
380             "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd\xff" },
381           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
382             16,
383             "\x5a\xe4\xdf\x3e\xdb\xd5\xd3\x5e\x5b\x4f\x09\x02\x0d\xb0\x3e\xab" },
384           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
385             16,
386             "\x1e\x03\x1d\xda\x2f\xbe\x03\xd1\x79\x21\x70\xa0\xf3\x00\x9c\xee" },
387
388           { "", 0, "" }
389         }
390       },
391       { GCRY_CIPHER_AES192,
392         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
393         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
394         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
395         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
396             16,
397             "\x1a\xbc\x93\x24\x17\x52\x1c\xa2\x4f\x2b\x04\x59\xfe\x7e\x6e\x0b" },
398           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
399             16,
400             "\x09\x03\x39\xec\x0a\xa6\xfa\xef\xd5\xcc\xc2\xc6\xf4\xce\x8e\x94" },
401           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
402             16,
403             "\x1e\x36\xb2\x6b\xd1\xeb\xc6\x70\xd1\xbd\x1d\x66\x56\x20\xab\xf7" },
404           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
405             16,
406             "\x4f\x78\xa7\xf6\xd2\x98\x09\x58\x5a\x97\xda\xec\x58\xc6\xb0\x50" },
407           { "", 0, "" }
408         }
409       },
410       { GCRY_CIPHER_AES256,
411         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
412         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
413         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
414         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
415             16,
416             "\x60\x1e\xc3\x13\x77\x57\x89\xa5\xb7\xa7\xf5\x04\xbb\xf3\xd2\x28" },
417           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
418             16,
419             "\xf4\x43\xe3\xca\x4d\x62\xb5\x9a\xca\x84\xe9\x90\xca\xca\xf5\xc5" },
420           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
421             16,
422             "\x2b\x09\x30\xda\xa2\x3d\xe9\x4c\xe8\x70\x17\xba\x2d\x84\x98\x8d" },
423           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
424             16,
425             "\xdf\xc9\xc5\x8d\xb6\x7a\xad\xa6\x13\xc2\xdd\x08\x45\x79\x41\xa6" },
426           { "", 0, "" }
427         }
428       },
429       /* Some truncation tests.  With a truncated second block and
430          also with a single truncated block.  */
431       { GCRY_CIPHER_AES,
432         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
433         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
434         {{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
435           16,
436           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
437          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e",
438           15,
439           "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd" },
440          {"", 0, "" }
441         }
442       },
443       { GCRY_CIPHER_AES,
444         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
445         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
446         {{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
447           16,
448           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
449          {"\xae",
450           1,
451           "\x98" },
452          {"", 0, "" }
453         }
454       },
455       { GCRY_CIPHER_AES,
456         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
457         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
458         {{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17",
459           15,
460           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6" },
461          {"", 0, "" }
462         }
463       },
464       { GCRY_CIPHER_AES,
465         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
466         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
467         {{"\x6b",
468           1,
469           "\x87" },
470          {"", 0, "" }
471         }
472       },
473       /* Tests to see whether it works correctly as a stream cipher.  */
474       { GCRY_CIPHER_AES,
475         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
476         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
477         {{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
478           16,
479           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
480          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e",
481           15,
482           "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd" },
483          {"\x51\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
484           17,
485           "\xff\x5a\xe4\xdf\x3e\xdb\xd5\xd3\x5e\x5b\x4f\x09\x02\x0d\xb0\x3e\xab" },
486          {"\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
487           16,
488           "\x1e\x03\x1d\xda\x2f\xbe\x03\xd1\x79\x21\x70\xa0\xf3\x00\x9c\xee" },
489
490           { "", 0, "" }
491         }
492       },
493       { GCRY_CIPHER_AES,
494         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
495         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
496         {{"\x6b",
497           1,
498           "\x87" },
499          {"\xc1\xbe",
500           2,
501           "\x4d\x61" },
502          {"\xe2\x2e\x40",
503           3,
504           "\x91\xb6\x20" },
505          {"\x9f",
506           1,
507           "\xe3" },
508          {"\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
509           9,
510           "\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
511          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e",
512           15,
513           "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd" },
514          {"\x51\x30\xc8\x1c\x46\xa3\x5c\xe4\x11",
515           9,
516           "\xff\x5a\xe4\xdf\x3e\xdb\xd5\xd3\x5e" },
517
518           { "", 0, "" }
519         }
520       },
521 #if USE_CAST5
522       /* A selfmade test vector using an 64 bit block cipher.  */
523       { GCRY_CIPHER_CAST5,
524         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
525         "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8",
526         {{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
527           16,
528           "\xe8\xa7\xac\x68\xca\xca\xa0\x20\x10\xcb\x1b\xcc\x79\x2c\xc4\x48" },
529          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c",
530           8,
531           "\x16\xe8\x72\x77\xb0\x98\x29\x68" },
532          {"\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
533           8,
534           "\x9a\xb3\xa8\x03\x3b\xb4\x14\xba" },
535          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\xa1\x00",
536           10,
537           "\x31\x5e\xd3\xfb\x1b\x8d\xd1\xf9\xb0\x83" },
538          { "", 0, "" }
539         }
540       },
541 #endif /*USE_CAST5*/
542       { 0,
543         "",
544         "",
545         {
546          {"", 0, "" }
547         }
548       }
549     };
550   gcry_cipher_hd_t hde, hdd;
551   unsigned char out[MAX_DATA_LEN];
552   int i, j, keylen, blklen;
553   gcry_error_t err = 0;
554
555   if (verbose)
556     fprintf (stderr, "  Starting CTR cipher checks.\n");
557   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
558     {
559       if (!tv[i].algo)
560         continue;
561
562       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_CTR, 0);
563       if (!err)
564         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_CTR, 0);
565       if (err)
566         {
567           fail ("aes-ctr, gcry_cipher_open failed: %s\n", gpg_strerror (err));
568           return;
569         }
570
571       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
572       if (!keylen)
573         {
574           fail ("aes-ctr, gcry_cipher_get_algo_keylen failed\n");
575           return;
576         }
577
578       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
579       if (!err)
580         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
581       if (err)
582         {
583           fail ("aes-ctr, gcry_cipher_setkey failed: %s\n",
584                 gpg_strerror (err));
585           gcry_cipher_close (hde);
586           gcry_cipher_close (hdd);
587           return;
588         }
589
590       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
591       if (!blklen)
592         {
593           fail ("aes-ctr, gcry_cipher_get_algo_blklen failed\n");
594           return;
595         }
596
597       err = gcry_cipher_setctr (hde, tv[i].ctr, blklen);
598       if (!err)
599         err = gcry_cipher_setctr (hdd, tv[i].ctr, blklen);
600       if (err)
601         {
602           fail ("aes-ctr, gcry_cipher_setctr failed: %s\n",
603                 gpg_strerror (err));
604           gcry_cipher_close (hde);
605           gcry_cipher_close (hdd);
606           return;
607         }
608
609       if (verbose)
610         fprintf (stderr, "    checking CTR mode for %s [%i]\n",
611                  gcry_cipher_algo_name (tv[i].algo),
612                  tv[i].algo);
613       for (j = 0; tv[i].data[j].inlen; j++)
614         {
615           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
616                                      tv[i].data[j].plaintext,
617                                      tv[i].data[j].inlen == -1 ?
618                                      strlen ((char*)tv[i].data[j].plaintext) :
619                                      tv[i].data[j].inlen);
620           if (err)
621             {
622               fail ("aes-ctr, gcry_cipher_encrypt (%d, %d) failed: %s\n",
623                     i, j, gpg_strerror (err));
624               gcry_cipher_close (hde);
625               gcry_cipher_close (hdd);
626               return;
627             }
628
629           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
630             {
631               fail ("aes-ctr, encrypt mismatch entry %d:%d\n", i, j);
632               mismatch (tv[i].data[j].out, tv[i].data[j].inlen,
633                         out, tv[i].data[j].inlen);
634             }
635
636           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
637           if (err)
638             {
639               fail ("aes-ctr, gcry_cipher_decrypt (%d, %d) failed: %s\n",
640                     i, j, gpg_strerror (err));
641               gcry_cipher_close (hde);
642               gcry_cipher_close (hdd);
643               return;
644             }
645
646           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
647             {
648               fail ("aes-ctr, decrypt mismatch entry %d:%d\n", i, j);
649               mismatch (tv[i].data[j].plaintext, tv[i].data[j].inlen,
650                         out, tv[i].data[j].inlen);
651             }
652
653         }
654
655       /* Now check that we get valid return codes back for good and
656          bad inputs.  */
657       err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
658                                  "1234567890123456", 16);
659       if (err)
660         fail ("aes-ctr, encryption failed for valid input");
661
662       err = gcry_cipher_encrypt (hde, out, 15,
663                                  "1234567890123456", 16);
664       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
665         fail ("aes-ctr, too short output buffer returned wrong error: %s\n",
666               gpg_strerror (err));
667
668       err = gcry_cipher_encrypt (hde, out, 0,
669                                  "1234567890123456", 16);
670       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
671         fail ("aes-ctr, 0 length output buffer returned wrong error: %s\n",
672               gpg_strerror (err));
673
674       err = gcry_cipher_encrypt (hde, out, 16,
675                                  "1234567890123456", 16);
676       if (err)
677         fail ("aes-ctr, correct length output buffer returned error: %s\n",
678               gpg_strerror (err));
679
680       /* Again, now for decryption.  */
681       err = gcry_cipher_decrypt (hde, out, MAX_DATA_LEN,
682                                  "1234567890123456", 16);
683       if (err)
684         fail ("aes-ctr, decryption failed for valid input");
685
686       err = gcry_cipher_decrypt (hde, out, 15,
687                                  "1234567890123456", 16);
688       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
689         fail ("aes-ctr, too short output buffer returned wrong error: %s\n",
690               gpg_strerror (err));
691
692       err = gcry_cipher_decrypt (hde, out, 0,
693                                  "1234567890123456", 16);
694       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
695         fail ("aes-ctr, 0 length output buffer returned wrong error: %s\n",
696               gpg_strerror (err));
697
698       err = gcry_cipher_decrypt (hde, out, 16,
699                                  "1234567890123456", 16);
700       if (err)
701         fail ("aes-ctr, correct length output buffer returned error: %s\n",
702               gpg_strerror (err));
703
704       gcry_cipher_close (hde);
705       gcry_cipher_close (hdd);
706     }
707   if (verbose)
708     fprintf (stderr, "  Completed CTR cipher checks.\n");
709 }
710
711 static void
712 check_cfb_cipher (void)
713 {
714   struct tv
715   {
716     int algo;
717     char key[MAX_DATA_LEN];
718     char iv[MAX_DATA_LEN];
719     struct data
720     {
721       unsigned char plaintext[MAX_DATA_LEN];
722       int inlen;
723       char out[MAX_DATA_LEN];
724     }
725     data[MAX_DATA_LEN];
726   } tv[] =
727     {
728       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
729       { GCRY_CIPHER_AES,
730         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
731         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
732         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
733             16,
734             "\x3b\x3f\xd9\x2e\xb7\x2d\xad\x20\x33\x34\x49\xf8\xe8\x3c\xfb\x4a" },
735           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
736             16,
737             "\xc8\xa6\x45\x37\xa0\xb3\xa9\x3f\xcd\xe3\xcd\xad\x9f\x1c\xe5\x8b"},
738           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
739             16,
740             "\x26\x75\x1f\x67\xa3\xcb\xb1\x40\xb1\x80\x8c\xf1\x87\xa4\xf4\xdf" },
741           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
742             16,
743             "\xc0\x4b\x05\x35\x7c\x5d\x1c\x0e\xea\xc4\xc6\x6f\x9f\xf7\xf2\xe6" },
744         }
745       },
746       { GCRY_CIPHER_AES192,
747         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
748         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
749         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
750         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
751             16,
752             "\xcd\xc8\x0d\x6f\xdd\xf1\x8c\xab\x34\xc2\x59\x09\xc9\x9a\x41\x74" },
753           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
754             16,
755             "\x67\xce\x7f\x7f\x81\x17\x36\x21\x96\x1a\x2b\x70\x17\x1d\x3d\x7a" },
756           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
757             16,
758             "\x2e\x1e\x8a\x1d\xd5\x9b\x88\xb1\xc8\xe6\x0f\xed\x1e\xfa\xc4\xc9" },
759           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
760             16,
761             "\xc0\x5f\x9f\x9c\xa9\x83\x4f\xa0\x42\xae\x8f\xba\x58\x4b\x09\xff" },
762         }
763       },
764       { GCRY_CIPHER_AES256,
765         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
766         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
767         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
768         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
769             16,
770             "\xdc\x7e\x84\xbf\xda\x79\x16\x4b\x7e\xcd\x84\x86\x98\x5d\x38\x60" },
771           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
772             16,
773             "\x39\xff\xed\x14\x3b\x28\xb1\xc8\x32\x11\x3c\x63\x31\xe5\x40\x7b" },
774           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
775             16,
776             "\xdf\x10\x13\x24\x15\xe5\x4b\x92\xa1\x3e\xd0\xa8\x26\x7a\xe2\xf9" },
777           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
778             16,
779             "\x75\xa3\x85\x74\x1a\xb9\xce\xf8\x20\x31\x62\x3d\x55\xb1\xe4\x71" }
780         }
781       }
782     };
783   gcry_cipher_hd_t hde, hdd;
784   unsigned char out[MAX_DATA_LEN];
785   int i, j, keylen, blklen;
786   gcry_error_t err = 0;
787
788   if (verbose)
789     fprintf (stderr, "  Starting CFB checks.\n");
790
791   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
792     {
793       if (verbose)
794         fprintf (stderr, "    checking CFB mode for %s [%i]\n",
795                  gcry_cipher_algo_name (tv[i].algo),
796                  tv[i].algo);
797       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_CFB, 0);
798       if (!err)
799         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_CFB, 0);
800       if (err)
801         {
802           fail ("aes-cfb, gcry_cipher_open failed: %s\n", gpg_strerror (err));
803           return;
804         }
805
806       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
807       if (!keylen)
808         {
809           fail ("aes-cfb, gcry_cipher_get_algo_keylen failed\n");
810           return;
811         }
812
813       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
814       if (!err)
815         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
816       if (err)
817         {
818           fail ("aes-cfb, gcry_cipher_setkey failed: %s\n",
819                 gpg_strerror (err));
820           gcry_cipher_close (hde);
821           gcry_cipher_close (hdd);
822           return;
823         }
824
825       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
826       if (!blklen)
827         {
828           fail ("aes-cfb, gcry_cipher_get_algo_blklen failed\n");
829           return;
830         }
831
832       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
833       if (!err)
834         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
835       if (err)
836         {
837           fail ("aes-cfb, gcry_cipher_setiv failed: %s\n",
838                 gpg_strerror (err));
839           gcry_cipher_close (hde);
840           gcry_cipher_close (hdd);
841           return;
842         }
843
844       for (j = 0; tv[i].data[j].inlen; j++)
845         {
846           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
847                                      tv[i].data[j].plaintext,
848                                      tv[i].data[j].inlen);
849           if (err)
850             {
851               fail ("aes-cfb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
852                     i, j, gpg_strerror (err));
853               gcry_cipher_close (hde);
854               gcry_cipher_close (hdd);
855               return;
856             }
857
858           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen)) {
859             fail ("aes-cfb, encrypt mismatch entry %d:%d\n", i, j);
860           }
861           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
862           if (err)
863             {
864               fail ("aes-cfb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
865                     i, j, gpg_strerror (err));
866               gcry_cipher_close (hde);
867               gcry_cipher_close (hdd);
868               return;
869             }
870
871           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
872             fail ("aes-cfb, decrypt mismatch entry %d:%d\n", i, j);
873         }
874
875       gcry_cipher_close (hde);
876       gcry_cipher_close (hdd);
877     }
878   if (verbose)
879     fprintf (stderr, "  Completed CFB checks.\n");
880 }
881
882 static void
883 check_ofb_cipher (void)
884 {
885   struct tv
886   {
887     int algo;
888     char key[MAX_DATA_LEN];
889     char iv[MAX_DATA_LEN];
890     struct data
891     {
892       unsigned char plaintext[MAX_DATA_LEN];
893       int inlen;
894       char out[MAX_DATA_LEN];
895     }
896     data[MAX_DATA_LEN];
897   } tv[] =
898     {
899       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
900       { GCRY_CIPHER_AES,
901         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
902         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
903         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
904             16,
905             "\x3b\x3f\xd9\x2e\xb7\x2d\xad\x20\x33\x34\x49\xf8\xe8\x3c\xfb\x4a" },
906           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
907             16,
908             "\x77\x89\x50\x8d\x16\x91\x8f\x03\xf5\x3c\x52\xda\xc5\x4e\xd8\x25"},
909           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
910             16,
911             "\x97\x40\x05\x1e\x9c\x5f\xec\xf6\x43\x44\xf7\xa8\x22\x60\xed\xcc" },
912           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
913             16,
914             "\x30\x4c\x65\x28\xf6\x59\xc7\x78\x66\xa5\x10\xd9\xc1\xd6\xae\x5e" },
915         }
916       },
917       { GCRY_CIPHER_AES192,
918         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
919         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
920         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
921         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
922             16,
923             "\xcd\xc8\x0d\x6f\xdd\xf1\x8c\xab\x34\xc2\x59\x09\xc9\x9a\x41\x74" },
924           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
925             16,
926             "\xfc\xc2\x8b\x8d\x4c\x63\x83\x7c\x09\xe8\x17\x00\xc1\x10\x04\x01" },
927           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
928             16,
929             "\x8d\x9a\x9a\xea\xc0\xf6\x59\x6f\x55\x9c\x6d\x4d\xaf\x59\xa5\xf2" },
930           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
931             16,
932             "\x6d\x9f\x20\x08\x57\xca\x6c\x3e\x9c\xac\x52\x4b\xd9\xac\xc9\x2a" },
933         }
934       },
935       { GCRY_CIPHER_AES256,
936         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
937         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
938         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
939         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
940             16,
941             "\xdc\x7e\x84\xbf\xda\x79\x16\x4b\x7e\xcd\x84\x86\x98\x5d\x38\x60" },
942           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
943             16,
944             "\x4f\xeb\xdc\x67\x40\xd2\x0b\x3a\xc8\x8f\x6a\xd8\x2a\x4f\xb0\x8d" },
945           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
946             16,
947             "\x71\xab\x47\xa0\x86\xe8\x6e\xed\xf3\x9d\x1c\x5b\xba\x97\xc4\x08" },
948           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
949             16,
950             "\x01\x26\x14\x1d\x67\xf3\x7b\xe8\x53\x8f\x5a\x8b\xe7\x40\xe4\x84" }
951         }
952       }
953     };
954   gcry_cipher_hd_t hde, hdd;
955   unsigned char out[MAX_DATA_LEN];
956   int i, j, keylen, blklen;
957   gcry_error_t err = 0;
958
959   if (verbose)
960     fprintf (stderr, "  Starting OFB checks.\n");
961
962   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
963     {
964       if (verbose)
965         fprintf (stderr, "    checking OFB mode for %s [%i]\n",
966                  gcry_cipher_algo_name (tv[i].algo),
967                  tv[i].algo);
968       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_OFB, 0);
969       if (!err)
970         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_OFB, 0);
971       if (err)
972         {
973           fail ("aes-ofb, gcry_cipher_open failed: %s\n", gpg_strerror (err));
974           return;
975         }
976
977       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
978       if (!keylen)
979         {
980           fail ("aes-ofb, gcry_cipher_get_algo_keylen failed\n");
981           return;
982         }
983
984       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
985       if (!err)
986         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
987       if (err)
988         {
989           fail ("aes-ofb, gcry_cipher_setkey failed: %s\n",
990                 gpg_strerror (err));
991           gcry_cipher_close (hde);
992           gcry_cipher_close (hdd);
993           return;
994         }
995
996       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
997       if (!blklen)
998         {
999           fail ("aes-ofb, gcry_cipher_get_algo_blklen failed\n");
1000           return;
1001         }
1002
1003       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
1004       if (!err)
1005         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
1006       if (err)
1007         {
1008           fail ("aes-ofb, gcry_cipher_setiv failed: %s\n",
1009                 gpg_strerror (err));
1010           gcry_cipher_close (hde);
1011           gcry_cipher_close (hdd);
1012           return;
1013         }
1014
1015       for (j = 0; tv[i].data[j].inlen; j++)
1016         {
1017           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
1018                                      tv[i].data[j].plaintext,
1019                                      tv[i].data[j].inlen);
1020           if (err)
1021             {
1022               fail ("aes-ofb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
1023                     i, j, gpg_strerror (err));
1024               gcry_cipher_close (hde);
1025               gcry_cipher_close (hdd);
1026               return;
1027             }
1028
1029           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
1030             fail ("aes-ofb, encrypt mismatch entry %d:%d\n", i, j);
1031
1032           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
1033           if (err)
1034             {
1035               fail ("aes-ofb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
1036                     i, j, gpg_strerror (err));
1037               gcry_cipher_close (hde);
1038               gcry_cipher_close (hdd);
1039               return;
1040             }
1041
1042           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
1043             fail ("aes-ofb, decrypt mismatch entry %d:%d\n", i, j);
1044         }
1045
1046       err = gcry_cipher_reset(hde);
1047       if (!err)
1048         err = gcry_cipher_reset(hdd);
1049       if (err)
1050         {
1051           fail ("aes-ofb, gcry_cipher_reset (%d, %d) failed: %s\n",
1052                 i, j, gpg_strerror (err));
1053           gcry_cipher_close (hde);
1054           gcry_cipher_close (hdd);
1055           return;
1056         }
1057
1058       /* gcry_cipher_reset clears the IV */
1059       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
1060       if (!err)
1061         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
1062       if (err)
1063         {
1064           fail ("aes-ofb, gcry_cipher_setiv failed: %s\n",
1065                 gpg_strerror (err));
1066           gcry_cipher_close (hde);
1067           gcry_cipher_close (hdd);
1068           return;
1069         }
1070
1071       /* this time we encrypt and decrypt one byte at a time */
1072       for (j = 0; tv[i].data[j].inlen; j++)
1073         {
1074           int byteNum;
1075           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
1076             {
1077               err = gcry_cipher_encrypt (hde, out+byteNum, 1,
1078                                          (tv[i].data[j].plaintext) + byteNum,
1079                                          1);
1080               if (err)
1081                 {
1082                   fail ("aes-ofb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
1083                         i, j, gpg_strerror (err));
1084                   gcry_cipher_close (hde);
1085                   gcry_cipher_close (hdd);
1086                   return;
1087                 }
1088             }
1089
1090           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
1091             fail ("aes-ofb, encrypt mismatch entry %d:%d\n", i, j);
1092
1093           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
1094             {
1095               err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
1096               if (err)
1097                 {
1098                   fail ("aes-ofb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
1099                         i, j, gpg_strerror (err));
1100                   gcry_cipher_close (hde);
1101                   gcry_cipher_close (hdd);
1102                   return;
1103                 }
1104             }
1105
1106           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
1107             fail ("aes-ofb, decrypt mismatch entry %d:%d\n", i, j);
1108         }
1109
1110       gcry_cipher_close (hde);
1111       gcry_cipher_close (hdd);
1112     }
1113   if (verbose)
1114     fprintf (stderr, "  Completed OFB checks.\n");
1115 }
1116
1117
1118 /* Check that our bulk encryption fucntions work properly.  */
1119 static void
1120 check_bulk_cipher_modes (void)
1121 {
1122   struct
1123   {
1124     int algo;
1125     int mode;
1126     const char *key;
1127     int  keylen;
1128     const char *iv;
1129     int ivlen;
1130     char t1_hash[20];
1131   } tv[] = {
1132     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CFB,
1133       "abcdefghijklmnop", 16,
1134       "1234567890123456", 16,
1135 /*[0]*/
1136       { 0x53, 0xda, 0x27, 0x3c, 0x78, 0x3d, 0x54, 0x66, 0x19, 0x63,
1137         0xd7, 0xe6, 0x20, 0x10, 0xcd, 0xc0, 0x5a, 0x0b, 0x06, 0xcc }
1138     },
1139     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CFB,
1140       "abcdefghijklmnopABCDEFG", 24,
1141       "1234567890123456", 16,
1142 /*[1]*/
1143       { 0xc7, 0xb1, 0xd0, 0x09, 0x95, 0x04, 0x34, 0x61, 0x2b, 0xd9,
1144         0xcb, 0xb3, 0xc7, 0xcb, 0xef, 0xea, 0x16, 0x19, 0x9b, 0x3e }
1145     },
1146     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB,
1147       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1148       "1234567890123456", 16,
1149 /*[2]*/
1150       { 0x31, 0xe1, 0x1f, 0x63, 0x65, 0x47, 0x8c, 0x3f, 0x53, 0xdb,
1151         0xd9, 0x4d, 0x91, 0x1d, 0x02, 0x9c, 0x05, 0x25, 0x58, 0x29 }
1152     },
1153     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CBC,
1154       "abcdefghijklmnop", 16,
1155       "1234567890123456", 16,
1156 /*[3]*/
1157       { 0xdc, 0x0c, 0xc2, 0xd9, 0x6b, 0x47, 0xf9, 0xeb, 0x06, 0xb4,
1158         0x2f, 0x6e, 0xec, 0x72, 0xbf, 0x55, 0x26, 0x7f, 0xa9, 0x97 }
1159     },
1160     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC,
1161       "abcdefghijklmnopABCDEFG", 24,
1162       "1234567890123456", 16,
1163 /*[4]*/
1164       { 0x2b, 0x90, 0x9b, 0xe6, 0x40, 0xab, 0x6e, 0xc2, 0xc5, 0xb1,
1165         0x87, 0xf5, 0x43, 0x84, 0x7b, 0x04, 0x06, 0x47, 0xd1, 0x8f }
1166     },
1167     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC,
1168       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1169       "1234567890123456", 16,
1170 /*[5]*/
1171       { 0xaa, 0xa8, 0xdf, 0x03, 0xb0, 0xba, 0xc4, 0xe3, 0xc1, 0x02,
1172         0x38, 0x31, 0x8d, 0x86, 0xcb, 0x49, 0x6d, 0xad, 0xae, 0x01 }
1173     },
1174     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_OFB,
1175       "abcdefghijklmnop", 16,
1176       "1234567890123456", 16,
1177 /*[6]*/
1178       { 0x65, 0xfe, 0xde, 0x48, 0xd0, 0xa1, 0xa6, 0xf9, 0x24, 0x6b,
1179         0x52, 0x5f, 0x21, 0x8a, 0x6f, 0xc7, 0x70, 0x3b, 0xd8, 0x4a }
1180     },
1181     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_OFB,
1182       "abcdefghijklmnopABCDEFG", 24,
1183       "1234567890123456", 16,
1184 /*[7]*/
1185       { 0x59, 0x5b, 0x02, 0xa2, 0x88, 0xc0, 0xbe, 0x94, 0x43, 0xaa,
1186         0x39, 0xf6, 0xbd, 0xcc, 0x83, 0x99, 0xee, 0x00, 0xa1, 0x91 }
1187     },
1188     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB,
1189       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1190       "1234567890123456", 16,
1191 /*[8]*/
1192       { 0x38, 0x8c, 0xe1, 0xe2, 0xbe, 0x67, 0x60, 0xe8, 0xeb, 0xce,
1193         0xd0, 0xc6, 0xaa, 0xd6, 0xf6, 0x26, 0x15, 0x56, 0xd0, 0x2b }
1194     },
1195     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CTR,
1196       "abcdefghijklmnop", 16,
1197       "1234567890123456", 16,
1198 /*[9]*/
1199       { 0x9a, 0x48, 0x94, 0xd6, 0x50, 0x46, 0x81, 0xdb, 0x68, 0x34,
1200         0x3b, 0xc5, 0x9e, 0x66, 0x94, 0x81, 0x98, 0xa0, 0xf9, 0xff }
1201     },
1202     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CTR,
1203       "abcdefghijklmnopABCDEFG", 24,
1204       "1234567890123456", 16,
1205 /*[10]*/
1206       { 0x2c, 0x2c, 0xd3, 0x75, 0x81, 0x2a, 0x59, 0x07, 0xeb, 0x08,
1207         0xce, 0x28, 0x4c, 0x0c, 0x6a, 0xa8, 0x8f, 0xa3, 0x98, 0x7e }
1208     },
1209     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CTR,
1210       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1211       "1234567890123456", 16,
1212 /*[11]*/
1213       { 0x64, 0xce, 0x73, 0x03, 0xc7, 0x89, 0x99, 0x1f, 0xf1, 0xce,
1214         0xfe, 0xfb, 0xb9, 0x42, 0x30, 0xdf, 0xbb, 0x68, 0x6f, 0xd3 }
1215     },
1216     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB,
1217       "abcdefghijklmnop", 16,
1218       "1234567890123456", 16,
1219 /*[12]*/
1220       { 0x51, 0xae, 0xf5, 0xac, 0x22, 0xa0, 0xba, 0x11, 0xc5, 0xaa,
1221         0xb4, 0x70, 0x99, 0xce, 0x18, 0x08, 0x12, 0x9b, 0xb1, 0xc5 }
1222     },
1223     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_ECB,
1224       "abcdefghijklmnopABCDEFG", 24,
1225       "1234567890123456", 16,
1226 /*[13]*/
1227       { 0x57, 0x91, 0xea, 0x48, 0xd8, 0xbf, 0x9e, 0xc1, 0xae, 0x33,
1228         0xb3, 0xfd, 0xf7, 0x7a, 0xeb, 0x30, 0xb1, 0x62, 0x0d, 0x82 }
1229     },
1230     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_ECB,
1231       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
1232       "1234567890123456", 16,
1233 /*[14]*/
1234       { 0x2d, 0x71, 0x54, 0xb9, 0xc5, 0x28, 0x76, 0xff, 0x76, 0xb5,
1235         0x99, 0x37, 0x99, 0x9d, 0xf7, 0x10, 0x6d, 0x86, 0x4f, 0x3f }
1236     }
1237   };
1238   gcry_cipher_hd_t hde = NULL;
1239   gcry_cipher_hd_t hdd = NULL;
1240   unsigned char *buffer_base, *outbuf_base; /* Allocated buffers.  */
1241   unsigned char *buffer, *outbuf;           /* Aligned buffers.  */
1242   size_t buflen;
1243   unsigned char hash[20];
1244   int i, j, keylen, blklen;
1245   gcry_error_t err = 0;
1246
1247   if (verbose)
1248     fprintf (stderr, "Starting bulk cipher checks.\n");
1249
1250   buflen = 16*100;  /* We check a 1600 byte buffer.  */
1251   buffer_base = gcry_xmalloc (buflen+15);
1252   buffer = buffer_base + (16 - ((size_t)buffer_base & 0x0f));
1253   outbuf_base = gcry_xmalloc (buflen+15);
1254   outbuf = outbuf_base + (16 - ((size_t)outbuf_base & 0x0f));
1255
1256
1257   for (i = 0; i < DIM (tv); i++)
1258     {
1259       if (verbose)
1260         fprintf (stderr, "    checking bulk encryption for %s [%i], mode %d\n",
1261                  gcry_cipher_algo_name (tv[i].algo),
1262                  tv[i].algo, tv[i].mode);
1263       err = gcry_cipher_open (&hde, tv[i].algo, tv[i].mode, 0);
1264       if (!err)
1265         err = gcry_cipher_open (&hdd, tv[i].algo, tv[i].mode, 0);
1266       if (err)
1267         {
1268           fail ("gcry_cipher_open failed: %s\n", gpg_strerror (err));
1269           goto leave;
1270         }
1271
1272       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
1273       if (!keylen)
1274         {
1275           fail ("gcry_cipher_get_algo_keylen failed\n");
1276           goto leave;
1277         }
1278
1279       err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
1280       if (!err)
1281         err = gcry_cipher_setkey (hdd, tv[i].key, tv[i].keylen);
1282       if (err)
1283         {
1284           fail ("gcry_cipher_setkey failed: %s\n", gpg_strerror (err));
1285           goto leave;
1286         }
1287
1288       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
1289       if (!blklen)
1290         {
1291           fail ("gcry_cipher_get_algo_blklen failed\n");
1292           goto leave;
1293         }
1294
1295       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
1296       if (!err)
1297         err = gcry_cipher_setiv (hdd, tv[i].iv,  tv[i].ivlen);
1298       if (err)
1299         {
1300           fail ("gcry_cipher_setiv failed: %s\n", gpg_strerror (err));
1301           goto leave;
1302         }
1303
1304       /* Fill the buffer with our test pattern.  */
1305       for (j=0; j < buflen; j++)
1306         buffer[j] = ((j & 0xff) ^ ((j >> 8) & 0xff));
1307
1308       err = gcry_cipher_encrypt (hde, outbuf, buflen, buffer, buflen);
1309       if (err)
1310         {
1311           fail ("gcry_cipher_encrypt (algo %d, mode %d) failed: %s\n",
1312                 tv[i].algo, tv[i].mode, gpg_strerror (err));
1313           goto leave;
1314         }
1315
1316       gcry_md_hash_buffer (GCRY_MD_SHA1, hash, outbuf, buflen);
1317 #if 0
1318       printf ("/*[%d]*/\n", i);
1319       fputs ("      {", stdout);
1320       for (j=0; j < 20; j++)
1321         printf (" 0x%02x%c%s", hash[j], j==19? ' ':',', j == 9? "\n       ":"");
1322       puts ("}");
1323 #endif
1324
1325       if (memcmp (hash, tv[i].t1_hash, 20))
1326         fail ("encrypt mismatch (algo %d, mode %d)\n",
1327               tv[i].algo, tv[i].mode);
1328
1329       err = gcry_cipher_decrypt (hdd, outbuf, buflen, NULL, 0);
1330       if (err)
1331         {
1332           fail ("gcry_cipher_decrypt (algo %d, mode %d) failed: %s\n",
1333                 tv[i].algo, tv[i].mode, gpg_strerror (err));
1334           goto leave;
1335         }
1336
1337       if (memcmp (buffer, outbuf, buflen))
1338         fail ("decrypt mismatch (algo %d, mode %d)\n",
1339               tv[i].algo, tv[i].mode);
1340
1341       gcry_cipher_close (hde); hde = NULL;
1342       gcry_cipher_close (hdd); hdd = NULL;
1343     }
1344
1345   if (verbose)
1346     fprintf (stderr, "Completed bulk cipher checks.\n");
1347  leave:
1348   gcry_cipher_close (hde);
1349   gcry_cipher_close (hdd);
1350   gcry_free (buffer_base);
1351   gcry_free (outbuf_base);
1352 }
1353
1354
1355
1356 static void
1357 check_one_cipher (int algo, int mode, int flags)
1358 {
1359   gcry_cipher_hd_t hd;
1360   char key[32];
1361   unsigned char plain[16], in[16], out[16];
1362   int keylen;
1363   gcry_error_t err = 0;
1364
1365   memcpy (key, "0123456789abcdef.,;/[]{}-=ABCDEF", 32);
1366   memcpy (plain, "foobar42FOOBAR17", 16);
1367
1368   keylen = gcry_cipher_get_algo_keylen (algo);
1369   if (!keylen)
1370     {
1371       fail ("algo %d, mode %d, gcry_cipher_get_algo_keylen failed\n",
1372             algo, mode);
1373       return;
1374     }
1375
1376   if (keylen < 40 / 8 || keylen > 32)
1377     {
1378       fail ("algo %d, mode %d, keylength problem (%d)\n", algo, mode, keylen);
1379       return;
1380     }
1381
1382   err = gcry_cipher_open (&hd, algo, mode, flags);
1383   if (err)
1384     {
1385       fail ("algo %d, mode %d, gcry_cipher_open failed: %s\n",
1386             algo, mode, gpg_strerror (err));
1387       return;
1388     }
1389
1390   err = gcry_cipher_setkey (hd, key, keylen);
1391   if (err)
1392     {
1393       fail ("algo %d, mode %d, gcry_cipher_setkey failed: %s\n",
1394             algo, mode, gpg_strerror (err));
1395       gcry_cipher_close (hd);
1396       return;
1397     }
1398
1399   err = gcry_cipher_encrypt (hd, out, 16, plain, 16);
1400   if (err)
1401     {
1402       fail ("algo %d, mode %d, gcry_cipher_encrypt failed: %s\n",
1403             algo, mode, gpg_strerror (err));
1404       gcry_cipher_close (hd);
1405       return;
1406     }
1407
1408   gcry_cipher_reset (hd);
1409
1410   err = gcry_cipher_decrypt (hd, in, 16, out, 16);
1411   if (err)
1412     {
1413       fail ("algo %d, mode %d, gcry_cipher_decrypt failed: %s\n",
1414             algo, mode, gpg_strerror (err));
1415       gcry_cipher_close (hd);
1416       return;
1417     }
1418
1419   if (memcmp (plain, in, 16))
1420     fail ("algo %d, mode %d, encrypt-decrypt mismatch\n", algo, mode);
1421
1422   /* Again, using in-place encryption.  */
1423   gcry_cipher_reset (hd);
1424
1425   memcpy (out, plain, 16);
1426   err = gcry_cipher_encrypt (hd, out, 16, NULL, 0);
1427   if (err)
1428     {
1429       fail ("algo %d, mode %d, in-place, gcry_cipher_encrypt failed: %s\n",
1430             algo, mode, gpg_strerror (err));
1431       gcry_cipher_close (hd);
1432       return;
1433     }
1434
1435   gcry_cipher_reset (hd);
1436
1437   err = gcry_cipher_decrypt (hd, out, 16, NULL, 0);
1438   if (err)
1439     {
1440       fail ("algo %d, mode %d, in-place, gcry_cipher_decrypt failed: %s\n",
1441             algo, mode, gpg_strerror (err));
1442       gcry_cipher_close (hd);
1443       return;
1444     }
1445
1446   if (memcmp (plain, out, 16))
1447     fail ("algo %d, mode %d, in-place, encrypt-decrypt mismatch\n",algo, mode);
1448
1449
1450   gcry_cipher_close (hd);
1451
1452 }
1453
1454
1455 static void
1456 check_ciphers (void)
1457 {
1458   static int algos[] = {
1459 #if USE_BLOWFISH
1460     GCRY_CIPHER_BLOWFISH,
1461 #endif
1462 #if USE_DES
1463     GCRY_CIPHER_DES,
1464     GCRY_CIPHER_3DES,
1465 #endif
1466 #if USE_CAST5
1467     GCRY_CIPHER_CAST5,
1468 #endif
1469 #if USE_AES
1470     GCRY_CIPHER_AES,
1471     GCRY_CIPHER_AES192,
1472     GCRY_CIPHER_AES256,
1473 #endif
1474 #if USE_TWOFISH
1475     GCRY_CIPHER_TWOFISH,
1476     GCRY_CIPHER_TWOFISH128,
1477 #endif
1478 #if USE_SERPENT
1479     GCRY_CIPHER_SERPENT128,
1480     GCRY_CIPHER_SERPENT192,
1481     GCRY_CIPHER_SERPENT256,
1482 #endif
1483 #if USE_RFC2268
1484     GCRY_CIPHER_RFC2268_40,
1485 #endif
1486 #if USE_SEED
1487     GCRY_CIPHER_SEED,
1488 #endif
1489 #if USE_CAMELLIA
1490     GCRY_CIPHER_CAMELLIA128,
1491     GCRY_CIPHER_CAMELLIA192,
1492     GCRY_CIPHER_CAMELLIA256,
1493 #endif
1494     0
1495   };
1496   static int algos2[] = {
1497 #if USE_ARCFOUR
1498     GCRY_CIPHER_ARCFOUR,
1499 #endif
1500     0
1501   };
1502   int i;
1503
1504   if (verbose)
1505     fprintf (stderr, "Starting Cipher checks.\n");
1506   for (i = 0; algos[i]; i++)
1507     {
1508       if (gcry_cipher_test_algo (algos[i]) && in_fips_mode)
1509         {
1510           if (verbose)
1511             fprintf (stderr, "  algorithm %d not available in fips mode\n",
1512                      algos[i]);
1513           continue;
1514         }
1515       if (verbose)
1516         fprintf (stderr, "  checking %s [%i]\n",
1517                  gcry_cipher_algo_name (algos[i]),
1518                  gcry_cipher_map_name (gcry_cipher_algo_name (algos[i])));
1519
1520       check_one_cipher (algos[i], GCRY_CIPHER_MODE_ECB, 0);
1521       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CFB, 0);
1522       check_one_cipher (algos[i], GCRY_CIPHER_MODE_OFB, 0);
1523       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, 0);
1524       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_CTS);
1525       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CTR, 0);
1526     }
1527
1528   for (i = 0; algos2[i]; i++)
1529     {
1530       if (gcry_cipher_test_algo (algos[i]) && in_fips_mode)
1531         {
1532           if (verbose)
1533             fprintf (stderr, "  algorithm %d not available in fips mode\n",
1534                      algos[i]);
1535           continue;
1536         }
1537       if (verbose)
1538         fprintf (stderr, "  checking `%s'\n",
1539                  gcry_cipher_algo_name (algos2[i]));
1540
1541       check_one_cipher (algos2[i], GCRY_CIPHER_MODE_STREAM, 0);
1542     }
1543   /* we have now run all cipher's selftests */
1544
1545   if (verbose)
1546     fprintf (stderr, "Completed Cipher checks.\n");
1547
1548   /* TODO: add some extra encryption to test the higher level functions */
1549 }
1550
1551
1552 static void
1553 check_cipher_modes(void)
1554 {
1555   if (verbose)
1556     fprintf (stderr, "Starting Cipher Mode checks.\n");
1557
1558   check_aes128_cbc_cts_cipher ();
1559   check_cbc_mac_cipher ();
1560   check_ctr_cipher ();
1561   check_cfb_cipher ();
1562   check_ofb_cipher ();
1563
1564   if (verbose)
1565     fprintf (stderr, "Completed Cipher Mode checks.\n");
1566 }
1567
1568 static void
1569 check_one_md (int algo, const char *data, int len, const char *expect)
1570 {
1571   gcry_md_hd_t hd, hd2;
1572   unsigned char *p;
1573   int mdlen;
1574   int i;
1575   gcry_error_t err = 0;
1576
1577   err = gcry_md_open (&hd, algo, 0);
1578   if (err)
1579     {
1580       fail ("algo %d, gcry_md_open failed: %s\n", algo, gpg_strerror (err));
1581       return;
1582     }
1583
1584   mdlen = gcry_md_get_algo_dlen (algo);
1585   if (mdlen < 1 || mdlen > 500)
1586     {
1587       fail ("algo %d, gcry_md_get_algo_dlen failed: %d\n", algo, mdlen);
1588       return;
1589     }
1590
1591   if (*data == '!' && !data[1])
1592     {                           /* hash one million times a "a" */
1593       char aaa[1000];
1594
1595       /* Write in odd size chunks so that we test the buffering.  */
1596       memset (aaa, 'a', 1000);
1597       for (i = 0; i < 1000; i++)
1598         gcry_md_write (hd, aaa, 1000);
1599     }
1600   else
1601     gcry_md_write (hd, data, len);
1602
1603   err = gcry_md_copy (&hd2, hd);
1604   if (err)
1605     {
1606       fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
1607     }
1608
1609   gcry_md_close (hd);
1610
1611   p = gcry_md_read (hd2, algo);
1612
1613   if (memcmp (p, expect, mdlen))
1614     {
1615       printf ("computed: ");
1616       for (i = 0; i < mdlen; i++)
1617         printf ("%02x ", p[i] & 0xFF);
1618       printf ("\nexpected: ");
1619       for (i = 0; i < mdlen; i++)
1620         printf ("%02x ", expect[i] & 0xFF);
1621       printf ("\n");
1622
1623       fail ("algo %d, digest mismatch\n", algo);
1624     }
1625
1626   gcry_md_close (hd2);
1627 }
1628
1629
1630 static void
1631 check_digests (void)
1632 {
1633   static struct algos
1634   {
1635     int md;
1636     const char *data;
1637     const char *expect;
1638   } algos[] =
1639     {
1640       { GCRY_MD_MD4, "",
1641         "\x31\xD6\xCF\xE0\xD1\x6A\xE9\x31\xB7\x3C\x59\xD7\xE0\xC0\x89\xC0" },
1642       { GCRY_MD_MD4, "a",
1643         "\xbd\xe5\x2c\xb3\x1d\xe3\x3e\x46\x24\x5e\x05\xfb\xdb\xd6\xfb\x24" },
1644       { GCRY_MD_MD4, "message digest",
1645         "\xd9\x13\x0a\x81\x64\x54\x9f\xe8\x18\x87\x48\x06\xe1\xc7\x01\x4b" },
1646       { GCRY_MD_MD5, "",
1647         "\xD4\x1D\x8C\xD9\x8F\x00\xB2\x04\xE9\x80\x09\x98\xEC\xF8\x42\x7E" },
1648       { GCRY_MD_MD5, "a",
1649         "\x0C\xC1\x75\xB9\xC0\xF1\xB6\xA8\x31\xC3\x99\xE2\x69\x77\x26\x61" },
1650       { GCRY_MD_MD5, "abc",
1651         "\x90\x01\x50\x98\x3C\xD2\x4F\xB0\xD6\x96\x3F\x7D\x28\xE1\x7F\x72" },
1652       { GCRY_MD_MD5, "message digest",
1653         "\xF9\x6B\x69\x7D\x7C\xB7\x93\x8D\x52\x5A\x2F\x31\xAA\xF1\x61\xD0" },
1654       { GCRY_MD_SHA1, "abc",
1655         "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E"
1656         "\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" },
1657       { GCRY_MD_SHA1,
1658         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1659         "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE"
1660         "\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" },
1661       { GCRY_MD_SHA1, "!" /* kludge for "a"*1000000 */ ,
1662         "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E"
1663         "\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" },
1664       /* From RFC3874 */
1665       { GCRY_MD_SHA224, "abc",
1666         "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
1667         "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7" },
1668       { GCRY_MD_SHA224,
1669         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1670         "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01\x50"
1671         "\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25" },
1672       { GCRY_MD_SHA224, "!",
1673         "\x20\x79\x46\x55\x98\x0c\x91\xd8\xbb\xb4\xc1\xea\x97\x61\x8a\x4b"
1674         "\xf0\x3f\x42\x58\x19\x48\xb2\xee\x4e\xe7\xad\x67" },
1675       { GCRY_MD_SHA256, "abc",
1676         "\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
1677         "\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad" },
1678       { GCRY_MD_SHA256,
1679         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1680         "\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
1681         "\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1" },
1682       { GCRY_MD_SHA256, "!",
1683         "\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67"
1684         "\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0" },
1685       { GCRY_MD_SHA384, "abc",
1686         "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b\xb5\xa0\x3d\x69\x9a\xc6\x50\x07"
1687         "\x27\x2c\x32\xab\x0e\xde\xd1\x63\x1a\x8b\x60\x5a\x43\xff\x5b\xed"
1688         "\x80\x86\x07\x2b\xa1\xe7\xcc\x23\x58\xba\xec\xa1\x34\xc8\x25\xa7" },
1689       { GCRY_MD_SHA512, "abc",
1690         "\xDD\xAF\x35\xA1\x93\x61\x7A\xBA\xCC\x41\x73\x49\xAE\x20\x41\x31"
1691         "\x12\xE6\xFA\x4E\x89\xA9\x7E\xA2\x0A\x9E\xEE\xE6\x4B\x55\xD3\x9A"
1692         "\x21\x92\x99\x2A\x27\x4F\xC1\xA8\x36\xBA\x3C\x23\xA3\xFE\xEB\xBD"
1693         "\x45\x4D\x44\x23\x64\x3C\xE8\x0E\x2A\x9A\xC9\x4F\xA5\x4C\xA4\x9F" },
1694       { GCRY_MD_RMD160, "",
1695         "\x9c\x11\x85\xa5\xc5\xe9\xfc\x54\x61\x28"
1696         "\x08\x97\x7e\xe8\xf5\x48\xb2\x25\x8d\x31" },
1697       { GCRY_MD_RMD160, "a",
1698         "\x0b\xdc\x9d\x2d\x25\x6b\x3e\xe9\xda\xae"
1699         "\x34\x7b\xe6\xf4\xdc\x83\x5a\x46\x7f\xfe" },
1700       { GCRY_MD_RMD160, "abc",
1701         "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04"
1702         "\x4a\x8e\x98\xc6\xb0\x87\xf1\x5a\x0b\xfc" },
1703       { GCRY_MD_RMD160, "message digest",
1704         "\x5d\x06\x89\xef\x49\xd2\xfa\xe5\x72\xb8"
1705         "\x81\xb1\x23\xa8\x5f\xfa\x21\x59\x5f\x36" },
1706       { GCRY_MD_CRC32, "", "\x00\x00\x00\x00" },
1707       { GCRY_MD_CRC32, "foo", "\x8c\x73\x65\x21" },
1708       { GCRY_MD_CRC32_RFC1510, "", "\x00\x00\x00\x00" },
1709       { GCRY_MD_CRC32_RFC1510, "foo", "\x73\x32\xbc\x33" },
1710       { GCRY_MD_CRC32_RFC1510, "test0123456789", "\xb8\x3e\x88\xd6" },
1711       { GCRY_MD_CRC32_RFC1510, "MASSACHVSETTS INSTITVTE OF TECHNOLOGY",
1712         "\xe3\x41\x80\xf7" },
1713 #if 0
1714       { GCRY_MD_CRC32_RFC1510, "\x80\x00", "\x3b\x83\x98\x4b" },
1715       { GCRY_MD_CRC32_RFC1510, "\x00\x08", "\x0e\xdb\x88\x32" },
1716       { GCRY_MD_CRC32_RFC1510, "\x00\x80", "\xed\xb8\x83\x20" },
1717 #endif
1718       { GCRY_MD_CRC32_RFC1510, "\x80", "\xed\xb8\x83\x20" },
1719 #if 0
1720       { GCRY_MD_CRC32_RFC1510, "\x80\x00\x00\x00", "\xed\x59\xb6\x3b" },
1721       { GCRY_MD_CRC32_RFC1510, "\x00\x00\x00\x01", "\x77\x07\x30\x96" },
1722 #endif
1723       { GCRY_MD_CRC24_RFC2440, "", "\xb7\x04\xce" },
1724       { GCRY_MD_CRC24_RFC2440, "foo", "\x4f\xc2\x55" },
1725
1726       { GCRY_MD_TIGER, "",
1727         "\x24\xF0\x13\x0C\x63\xAC\x93\x32\x16\x16\x6E\x76"
1728         "\xB1\xBB\x92\x5F\xF3\x73\xDE\x2D\x49\x58\x4E\x7A" },
1729       { GCRY_MD_TIGER, "abc",
1730         "\xF2\x58\xC1\xE8\x84\x14\xAB\x2A\x52\x7A\xB5\x41"
1731         "\xFF\xC5\xB8\xBF\x93\x5F\x7B\x95\x1C\x13\x29\x51" },
1732       { GCRY_MD_TIGER, "Tiger",
1733         "\x9F\x00\xF5\x99\x07\x23\x00\xDD\x27\x6A\xBB\x38"
1734         "\xC8\xEB\x6D\xEC\x37\x79\x0C\x11\x6F\x9D\x2B\xDF" },
1735       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg"
1736         "hijklmnopqrstuvwxyz0123456789+-",
1737         "\x87\xFB\x2A\x90\x83\x85\x1C\xF7\x47\x0D\x2C\xF8"
1738         "\x10\xE6\xDF\x9E\xB5\x86\x44\x50\x34\xA5\xA3\x86" },
1739       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdef"
1740         "ghijklmnopqrstuvwxyz+0123456789",
1741         "\x46\x7D\xB8\x08\x63\xEB\xCE\x48\x8D\xF1\xCD\x12"
1742         "\x61\x65\x5D\xE9\x57\x89\x65\x65\x97\x5F\x91\x97" },
1743       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
1744         "by Ross Anderson and Eli Biham",
1745         "\x0C\x41\x0A\x04\x29\x68\x86\x8A\x16\x71\xDA\x5A"
1746         "\x3F\xD2\x9A\x72\x5E\xC1\xE4\x57\xD3\xCD\xB3\x03" },
1747       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
1748         "by Ross Anderson and Eli Biham, proceedings of Fa"
1749         "st Software Encryption 3, Cambridge.",
1750         "\xEB\xF5\x91\xD5\xAF\xA6\x55\xCE\x7F\x22\x89\x4F"
1751         "\xF8\x7F\x54\xAC\x89\xC8\x11\xB6\xB0\xDA\x31\x93" },
1752       { GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
1753         "by Ross Anderson and Eli Biham, proceedings of Fa"
1754         "st Software Encryption 3, Cambridge, 1996.",
1755         "\x3D\x9A\xEB\x03\xD1\xBD\x1A\x63\x57\xB2\x77\x4D"
1756         "\xFD\x6D\x5B\x24\xDD\x68\x15\x1D\x50\x39\x74\xFC" },
1757       { GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefgh"
1758         "ijklmnopqrstuvwxyz0123456789+-ABCDEFGHIJKLMNOPQRS"
1759         "TUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-",
1760         "\x00\xB8\x3E\xB4\xE5\x34\x40\xC5\x76\xAC\x6A\xAE"
1761         "\xE0\xA7\x48\x58\x25\xFD\x15\xE7\x0A\x59\xFF\xE4" },
1762
1763       { GCRY_MD_TIGER1, "",
1764         "\x32\x93\xAC\x63\x0C\x13\xF0\x24\x5F\x92\xBB\xB1"
1765         "\x76\x6E\x16\x16\x7A\x4E\x58\x49\x2D\xDE\x73\xF3" },
1766       { GCRY_MD_TIGER1, "a",
1767         "\x77\xBE\xFB\xEF\x2E\x7E\xF8\xAB\x2E\xC8\xF9\x3B"
1768         "\xF5\x87\xA7\xFC\x61\x3E\x24\x7F\x5F\x24\x78\x09" },
1769       { GCRY_MD_TIGER1, "abc",
1770         "\x2A\xAB\x14\x84\xE8\xC1\x58\xF2\xBF\xB8\xC5\xFF"
1771         "\x41\xB5\x7A\x52\x51\x29\x13\x1C\x95\x7B\x5F\x93" },
1772       { GCRY_MD_TIGER1, "message digest",
1773         "\xD9\x81\xF8\xCB\x78\x20\x1A\x95\x0D\xCF\x30\x48"
1774         "\x75\x1E\x44\x1C\x51\x7F\xCA\x1A\xA5\x5A\x29\xF6" },
1775       { GCRY_MD_TIGER1, "abcdefghijklmnopqrstuvwxyz",
1776         "\x17\x14\xA4\x72\xEE\xE5\x7D\x30\x04\x04\x12\xBF"
1777         "\xCC\x55\x03\x2A\x0B\x11\x60\x2F\xF3\x7B\xEE\xE9" },
1778       { GCRY_MD_TIGER1,
1779         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1780         "\x0F\x7B\xF9\xA1\x9B\x9C\x58\xF2\xB7\x61\x0D\xF7"
1781         "\xE8\x4F\x0A\xC3\xA7\x1C\x63\x1E\x7B\x53\xF7\x8E" },
1782       { GCRY_MD_TIGER1,
1783         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1784         "abcdefghijklmnopqrstuvwxyz" "0123456789",
1785         "\x8D\xCE\xA6\x80\xA1\x75\x83\xEE\x50\x2B\xA3\x8A"
1786         "\x3C\x36\x86\x51\x89\x0F\xFB\xCC\xDC\x49\xA8\xCC" },
1787       { GCRY_MD_TIGER1,
1788         "1234567890" "1234567890" "1234567890" "1234567890"
1789         "1234567890" "1234567890" "1234567890" "1234567890",
1790         "\x1C\x14\x79\x55\x29\xFD\x9F\x20\x7A\x95\x8F\x84"
1791         "\xC5\x2F\x11\xE8\x87\xFA\x0C\xAB\xDF\xD9\x1B\xFD" },
1792       { GCRY_MD_TIGER1, "!",
1793         "\x6D\xB0\xE2\x72\x9C\xBE\xAD\x93\xD7\x15\xC6\xA7"
1794         "\xD3\x63\x02\xE9\xB3\xCE\xE0\xD2\xBC\x31\x4B\x41" },
1795
1796       { GCRY_MD_TIGER2, "",
1797         "\x44\x41\xBE\x75\xF6\x01\x87\x73\xC2\x06\xC2\x27"
1798         "\x45\x37\x4B\x92\x4A\xA8\x31\x3F\xEF\x91\x9F\x41" },
1799       { GCRY_MD_TIGER2, "a",
1800         "\x67\xE6\xAE\x8E\x9E\x96\x89\x99\xF7\x0A\x23\xE7"
1801         "\x2A\xEA\xA9\x25\x1C\xBC\x7C\x78\xA7\x91\x66\x36" },
1802       { GCRY_MD_TIGER2, "abc",
1803         "\xF6\x8D\x7B\xC5\xAF\x4B\x43\xA0\x6E\x04\x8D\x78"
1804         "\x29\x56\x0D\x4A\x94\x15\x65\x8B\xB0\xB1\xF3\xBF" },
1805       { GCRY_MD_TIGER2, "message digest",
1806         "\xE2\x94\x19\xA1\xB5\xFA\x25\x9D\xE8\x00\x5E\x7D"
1807         "\xE7\x50\x78\xEA\x81\xA5\x42\xEF\x25\x52\x46\x2D" },
1808       { GCRY_MD_TIGER2, "abcdefghijklmnopqrstuvwxyz",
1809         "\xF5\xB6\xB6\xA7\x8C\x40\x5C\x85\x47\xE9\x1C\xD8"
1810         "\x62\x4C\xB8\xBE\x83\xFC\x80\x4A\x47\x44\x88\xFD" },
1811       { GCRY_MD_TIGER2,
1812         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
1813         "\xA6\x73\x7F\x39\x97\xE8\xFB\xB6\x3D\x20\xD2\xDF"
1814         "\x88\xF8\x63\x76\xB5\xFE\x2D\x5C\xE3\x66\x46\xA9" },
1815       { GCRY_MD_TIGER2,
1816         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1817         "abcdefghijklmnopqrstuvwxyz" "0123456789",
1818         "\xEA\x9A\xB6\x22\x8C\xEE\x7B\x51\xB7\x75\x44\xFC"
1819         "\xA6\x06\x6C\x8C\xBB\x5B\xBA\xE6\x31\x95\x05\xCD" },
1820       { GCRY_MD_TIGER2,
1821         "1234567890" "1234567890" "1234567890" "1234567890"
1822         "1234567890" "1234567890" "1234567890" "1234567890",
1823         "\xD8\x52\x78\x11\x53\x29\xEB\xAA\x0E\xEC\x85\xEC"
1824         "\xDC\x53\x96\xFD\xA8\xAA\x3A\x58\x20\x94\x2F\xFF" },
1825       { GCRY_MD_TIGER2, "!",
1826         "\xE0\x68\x28\x1F\x06\x0F\x55\x16\x28\xCC\x57\x15"
1827         "\xB9\xD0\x22\x67\x96\x91\x4D\x45\xF7\x71\x7C\xF4" },
1828
1829       { GCRY_MD_WHIRLPOOL, "",
1830         "\x19\xFA\x61\xD7\x55\x22\xA4\x66\x9B\x44\xE3\x9C\x1D\x2E\x17\x26"
1831         "\xC5\x30\x23\x21\x30\xD4\x07\xF8\x9A\xFE\xE0\x96\x49\x97\xF7\xA7"
1832         "\x3E\x83\xBE\x69\x8B\x28\x8F\xEB\xCF\x88\xE3\xE0\x3C\x4F\x07\x57"
1833         "\xEA\x89\x64\xE5\x9B\x63\xD9\x37\x08\xB1\x38\xCC\x42\xA6\x6E\xB3" },
1834       { GCRY_MD_WHIRLPOOL, "a",
1835         "\x8A\xCA\x26\x02\x79\x2A\xEC\x6F\x11\xA6\x72\x06\x53\x1F\xB7\xD7"
1836         "\xF0\xDF\xF5\x94\x13\x14\x5E\x69\x73\xC4\x50\x01\xD0\x08\x7B\x42"
1837         "\xD1\x1B\xC6\x45\x41\x3A\xEF\xF6\x3A\x42\x39\x1A\x39\x14\x5A\x59"
1838         "\x1A\x92\x20\x0D\x56\x01\x95\xE5\x3B\x47\x85\x84\xFD\xAE\x23\x1A" },
1839       { GCRY_MD_WHIRLPOOL, "a",
1840         "\x8A\xCA\x26\x02\x79\x2A\xEC\x6F\x11\xA6\x72\x06\x53\x1F\xB7\xD7"
1841         "\xF0\xDF\xF5\x94\x13\x14\x5E\x69\x73\xC4\x50\x01\xD0\x08\x7B\x42"
1842         "\xD1\x1B\xC6\x45\x41\x3A\xEF\xF6\x3A\x42\x39\x1A\x39\x14\x5A\x59"
1843         "\x1A\x92\x20\x0D\x56\x01\x95\xE5\x3B\x47\x85\x84\xFD\xAE\x23\x1A" },
1844       { GCRY_MD_WHIRLPOOL,
1845         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
1846         "\xDC\x37\xE0\x08\xCF\x9E\xE6\x9B\xF1\x1F\x00\xED\x9A\xBA\x26\x90"
1847         "\x1D\xD7\xC2\x8C\xDE\xC0\x66\xCC\x6A\xF4\x2E\x40\xF8\x2F\x3A\x1E"
1848         "\x08\xEB\xA2\x66\x29\x12\x9D\x8F\xB7\xCB\x57\x21\x1B\x92\x81\xA6"
1849         "\x55\x17\xCC\x87\x9D\x7B\x96\x21\x42\xC6\x5F\x5A\x7A\xF0\x14\x67" },
1850       { GCRY_MD_WHIRLPOOL,
1851         "!",
1852         "\x0C\x99\x00\x5B\xEB\x57\xEF\xF5\x0A\x7C\xF0\x05\x56\x0D\xDF\x5D"
1853         "\x29\x05\x7F\xD8\x6B\x20\xBF\xD6\x2D\xEC\xA0\xF1\xCC\xEA\x4A\xF5"
1854         "\x1F\xC1\x54\x90\xED\xDC\x47\xAF\x32\xBB\x2B\x66\xC3\x4F\xF9\xAD"
1855         "\x8C\x60\x08\xAD\x67\x7F\x77\x12\x69\x53\xB2\x26\xE4\xED\x8B\x01" },
1856       { 0 },
1857     };
1858   int i;
1859
1860   if (verbose)
1861     fprintf (stderr, "Starting hash checks.\n");
1862
1863   for (i = 0; algos[i].md; i++)
1864     {
1865       if ((gcry_md_test_algo (algos[i].md) || algos[i].md == GCRY_MD_MD5)
1866           && in_fips_mode)
1867         {
1868           if (verbose)
1869             fprintf (stderr, "  algorithm %d not available in fips mode\n",
1870                      algos[i].md);
1871           continue;
1872         }
1873       if (verbose)
1874         fprintf (stderr, "  checking %s [%i] for length %zi\n",
1875                  gcry_md_algo_name (algos[i].md),
1876                  algos[i].md,
1877                  !strcmp (algos[i].data, "!")?
1878                  1000000 : strlen(algos[i].data));
1879
1880       check_one_md (algos[i].md, algos[i].data, strlen (algos[i].data),
1881                     algos[i].expect);
1882     }
1883
1884   if (verbose)
1885     fprintf (stderr, "Completed hash checks.\n");
1886 }
1887
1888 static void
1889 check_one_hmac (int algo, const char *data, int datalen,
1890                 const char *key, int keylen, const char *expect)
1891 {
1892   gcry_md_hd_t hd, hd2;
1893   unsigned char *p;
1894   int mdlen;
1895   int i;
1896   gcry_error_t err = 0;
1897
1898   err = gcry_md_open (&hd, algo, GCRY_MD_FLAG_HMAC);
1899   if (err)
1900     {
1901       fail ("algo %d, gcry_md_open failed: %s\n", algo, gpg_strerror (err));
1902       return;
1903     }
1904
1905   mdlen = gcry_md_get_algo_dlen (algo);
1906   if (mdlen < 1 || mdlen > 500)
1907     {
1908       fail ("algo %d, gcry_md_get_algo_dlen failed: %d\n", algo, mdlen);
1909       return;
1910     }
1911
1912   gcry_md_setkey( hd, key, keylen );
1913
1914   gcry_md_write (hd, data, datalen);
1915
1916   err = gcry_md_copy (&hd2, hd);
1917   if (err)
1918     {
1919       fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
1920     }
1921
1922   gcry_md_close (hd);
1923
1924   p = gcry_md_read (hd2, algo);
1925   if (!p)
1926     fail("algo %d, hmac gcry_md_read failed\n", algo);
1927
1928   if (memcmp (p, expect, mdlen))
1929     {
1930       printf ("computed: ");
1931       for (i = 0; i < mdlen; i++)
1932         printf ("%02x ", p[i] & 0xFF);
1933       printf ("\nexpected: ");
1934       for (i = 0; i < mdlen; i++)
1935         printf ("%02x ", expect[i] & 0xFF);
1936       printf ("\n");
1937
1938       fail ("algo %d, digest mismatch\n", algo);
1939     }
1940
1941   gcry_md_close (hd2);
1942 }
1943
1944 static void
1945 check_hmac (void)
1946 {
1947   static struct algos
1948   {
1949     int md;
1950     const char *data;
1951     const char *key;
1952     const char *expect;
1953   } algos[] =
1954     {
1955       { GCRY_MD_MD5, "what do ya want for nothing?", "Jefe",
1956         "\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7\x38" },
1957       { GCRY_MD_MD5,
1958         "Hi There",
1959         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
1960         "\x92\x94\x72\x7a\x36\x38\xbb\x1c\x13\xf4\x8e\xf8\x15\x8b\xfc\x9d" },
1961       { GCRY_MD_MD5,
1962         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1963         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1964         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
1965         "\xdd\xdd\xdd\xdd\xdd",
1966         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA",
1967         "\x56\xbe\x34\x52\x1d\x14\x4c\x88\xdb\xb8\xc7\x33\xf0\xe8\xb3\xf6" },
1968       { GCRY_MD_MD5,
1969         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1970         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1971         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
1972         "\xcd\xcd\xcd\xcd\xcd",
1973         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
1974         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
1975         "\x69\x7e\xaf\x0a\xca\x3a\x3a\xea\x3a\x75\x16\x47\x46\xff\xaa\x79" },
1976       { GCRY_MD_MD5, "Test With Truncation",
1977         "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c",
1978         "\x56\x46\x1e\xf2\x34\x2e\xdc\x00\xf9\xba\xb9\x95\x69\x0e\xfd\x4c" },
1979       { GCRY_MD_MD5, "Test Using Larger Than Block-Size Key - Hash Key First",
1980         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1981         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1982         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1983         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1984         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1985         "\xaa\xaa\xaa\xaa\xaa",
1986         "\x6b\x1a\xb7\xfe\x4b\xd7\xbf\x8f\x0b\x62\xe6\xce\x61\xb9\xd0\xcd" },
1987       { GCRY_MD_MD5,
1988         "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
1989         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1990         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1991         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1992         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1993         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
1994         "\xaa\xaa\xaa\xaa\xaa",
1995         "\x6f\x63\x0f\xad\x67\xcd\xa0\xee\x1f\xb1\xf5\x62\xdb\x3a\xa5\x3e", },
1996       { GCRY_MD_SHA256, "what do ya want for nothing?", "Jefe",
1997         "\x5b\xdc\xc1\x46\xbf\x60\x75\x4e\x6a\x04\x24\x26\x08\x95\x75\xc7\x5a"
1998         "\x00\x3f\x08\x9d\x27\x39\x83\x9d\xec\x58\xb9\x64\xec\x38\x43" },
1999       { GCRY_MD_SHA256,
2000         "Hi There",
2001         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2002         "\x0b\x0b\x0b",
2003         "\xb0\x34\x4c\x61\xd8\xdb\x38\x53\x5c\xa8\xaf\xce\xaf\x0b\xf1\x2b\x88"
2004         "\x1d\xc2\x00\xc9\x83\x3d\xa7\x26\xe9\x37\x6c\x2e\x32\xcf\xf7" },
2005       { GCRY_MD_SHA256,
2006         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2007         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2008         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2009         "\xdd\xdd\xdd\xdd\xdd",
2010         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2011         "\xAA\xAA\xAA\xAA",
2012         "\x77\x3e\xa9\x1e\x36\x80\x0e\x46\x85\x4d\xb8\xeb\xd0\x91\x81\xa7"
2013         "\x29\x59\x09\x8b\x3e\xf8\xc1\x22\xd9\x63\x55\x14\xce\xd5\x65\xfe" },
2014       { GCRY_MD_SHA256,
2015         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2016         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2017         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2018         "\xcd\xcd\xcd\xcd\xcd",
2019         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2020         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2021         "\x82\x55\x8a\x38\x9a\x44\x3c\x0e\xa4\xcc\x81\x98\x99\xf2\x08"
2022         "\x3a\x85\xf0\xfa\xa3\xe5\x78\xf8\x07\x7a\x2e\x3f\xf4\x67\x29\x66\x5b" },
2023       { GCRY_MD_SHA256,
2024         "Test Using Larger Than Block-Size Key - Hash Key First",
2025         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2026         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2027         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2028         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2029         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2030         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2031         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2032         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2033         "\xaa\xaa\xaa",
2034         "\x60\xe4\x31\x59\x1e\xe0\xb6\x7f\x0d\x8a\x26\xaa\xcb\xf5\xb7\x7f"
2035         "\x8e\x0b\xc6\x21\x37\x28\xc5\x14\x05\x46\x04\x0f\x0e\xe3\x7f\x54" },
2036       { GCRY_MD_SHA256,
2037         "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
2038         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2039         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2040         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2041         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2042         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2043         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2044         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2045         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2046         "\xaa\xaa\xaa",
2047         "\x9b\x09\xff\xa7\x1b\x94\x2f\xcb\x27\x63\x5f\xbc\xd5\xb0\xe9\x44"
2048         "\xbf\xdc\x63\x64\x4f\x07\x13\x93\x8a\x7f\x51\x53\x5c\x3a\x35\xe2" },
2049       { GCRY_MD_SHA224, "what do ya want for nothing?", "Jefe",
2050         "\xa3\x0e\x01\x09\x8b\xc6\xdb\xbf\x45\x69\x0f\x3a\x7e\x9e\x6d\x0f"
2051         "\x8b\xbe\xa2\xa3\x9e\x61\x48\x00\x8f\xd0\x5e\x44" },
2052       { GCRY_MD_SHA224,
2053         "Hi There",
2054         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2055         "\x0b\x0b\x0b",
2056         "\x89\x6f\xb1\x12\x8a\xbb\xdf\x19\x68\x32\x10\x7c\xd4\x9d\xf3\x3f\x47"
2057         "\xb4\xb1\x16\x99\x12\xba\x4f\x53\x68\x4b\x22" },
2058       { GCRY_MD_SHA224,
2059         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2060         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2061         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2062         "\xdd\xdd\xdd\xdd\xdd",
2063         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2064         "\xAA\xAA\xAA\xAA",
2065         "\x7f\xb3\xcb\x35\x88\xc6\xc1\xf6\xff\xa9\x69\x4d\x7d\x6a\xd2\x64"
2066         "\x93\x65\xb0\xc1\xf6\x5d\x69\xd1\xec\x83\x33\xea" },
2067       { GCRY_MD_SHA224,
2068         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2069         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2070         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2071         "\xcd\xcd\xcd\xcd\xcd",
2072         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2073         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2074         "\x6c\x11\x50\x68\x74\x01\x3c\xac\x6a\x2a\xbc\x1b\xb3\x82\x62"
2075         "\x7c\xec\x6a\x90\xd8\x6e\xfc\x01\x2d\xe7\xaf\xec\x5a" },
2076       { GCRY_MD_SHA224,
2077         "Test Using Larger Than Block-Size Key - Hash Key First",
2078         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2079         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2080         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2081         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2082         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2083         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2084         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2085         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2086         "\xaa\xaa\xaa",
2087         "\x95\xe9\xa0\xdb\x96\x20\x95\xad\xae\xbe\x9b\x2d\x6f\x0d\xbc\xe2"
2088         "\xd4\x99\xf1\x12\xf2\xd2\xb7\x27\x3f\xa6\x87\x0e" },
2089       { GCRY_MD_SHA224,
2090         "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
2091         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2092         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2093         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2094         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2095         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2096         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2097         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2098         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2099         "\xaa\xaa\xaa",
2100         "\x3a\x85\x41\x66\xac\x5d\x9f\x02\x3f\x54\xd5\x17\xd0\xb3\x9d\xbd"
2101         "\x94\x67\x70\xdb\x9c\x2b\x95\xc9\xf6\xf5\x65\xd1" },
2102       { GCRY_MD_SHA384, "what do ya want for nothing?", "Jefe",
2103         "\xaf\x45\xd2\xe3\x76\x48\x40\x31\x61\x7f\x78\xd2\xb5\x8a\x6b\x1b"
2104         "\x9c\x7e\xf4\x64\xf5\xa0\x1b\x47\xe4\x2e\xc3\x73\x63\x22\x44\x5e"
2105         "\x8e\x22\x40\xca\x5e\x69\xe2\xc7\x8b\x32\x39\xec\xfa\xb2\x16\x49" },
2106       { GCRY_MD_SHA384,
2107         "Hi There",
2108         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2109         "\x0b\x0b\x0b",
2110         "\xaf\xd0\x39\x44\xd8\x48\x95\x62\x6b\x08\x25\xf4\xab\x46\x90\x7f\x15"
2111         "\xf9\xda\xdb\xe4\x10\x1e\xc6\x82\xaa\x03\x4c\x7c\xeb\xc5\x9c\xfa\xea"
2112         "\x9e\xa9\x07\x6e\xde\x7f\x4a\xf1\x52\xe8\xb2\xfa\x9c\xb6" },
2113       { GCRY_MD_SHA384,
2114         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2115         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2116         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2117         "\xdd\xdd\xdd\xdd\xdd",
2118         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2119         "\xAA\xAA\xAA\xAA",
2120         "\x88\x06\x26\x08\xd3\xe6\xad\x8a\x0a\xa2\xac\xe0\x14\xc8\xa8\x6f"
2121         "\x0a\xa6\x35\xd9\x47\xac\x9f\xeb\xe8\x3e\xf4\xe5\x59\x66\x14\x4b"
2122         "\x2a\x5a\xb3\x9d\xc1\x38\x14\xb9\x4e\x3a\xb6\xe1\x01\xa3\x4f\x27" },
2123       { GCRY_MD_SHA384,
2124         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2125         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2126         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2127         "\xcd\xcd\xcd\xcd\xcd",
2128         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2129         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2130         "\x3e\x8a\x69\xb7\x78\x3c\x25\x85\x19\x33\xab\x62\x90\xaf\x6c\xa7"
2131         "\x7a\x99\x81\x48\x08\x50\x00\x9c\xc5\x57\x7c\x6e\x1f\x57\x3b\x4e"
2132         "\x68\x01\xdd\x23\xc4\xa7\xd6\x79\xcc\xf8\xa3\x86\xc6\x74\xcf\xfb" },
2133       { GCRY_MD_SHA384,
2134         "Test Using Larger Than Block-Size Key - Hash Key First",
2135         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2136         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2137         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2138         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2139         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2140         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2141         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2142         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2143         "\xaa\xaa\xaa",
2144         "\x4e\xce\x08\x44\x85\x81\x3e\x90\x88\xd2\xc6\x3a\x04\x1b\xc5\xb4"
2145         "\x4f\x9e\xf1\x01\x2a\x2b\x58\x8f\x3c\xd1\x1f\x05\x03\x3a\xc4\xc6"
2146         "\x0c\x2e\xf6\xab\x40\x30\xfe\x82\x96\x24\x8d\xf1\x63\xf4\x49\x52" },
2147       { GCRY_MD_SHA384,
2148         "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
2149         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2150         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2151         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2152         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2153         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2154         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2155         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2156         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2157         "\xaa\xaa\xaa",
2158         "\x66\x17\x17\x8e\x94\x1f\x02\x0d\x35\x1e\x2f\x25\x4e\x8f\xd3\x2c"
2159         "\x60\x24\x20\xfe\xb0\xb8\xfb\x9a\xdc\xce\xbb\x82\x46\x1e\x99\xc5"
2160         "\xa6\x78\xcc\x31\xe7\x99\x17\x6d\x38\x60\xe6\x11\x0c\x46\x52\x3e" },
2161       { GCRY_MD_SHA512, "what do ya want for nothing?", "Jefe",
2162         "\x16\x4b\x7a\x7b\xfc\xf8\x19\xe2\xe3\x95\xfb\xe7\x3b\x56\xe0\xa3"
2163         "\x87\xbd\x64\x22\x2e\x83\x1f\xd6\x10\x27\x0c\xd7\xea\x25\x05\x54"
2164         "\x97\x58\xbf\x75\xc0\x5a\x99\x4a\x6d\x03\x4f\x65\xf8\xf0\xe6\xfd"
2165         "\xca\xea\xb1\xa3\x4d\x4a\x6b\x4b\x63\x6e\x07\x0a\x38\xbc\xe7\x37" },
2166       { GCRY_MD_SHA512,
2167         "Hi There",
2168         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
2169         "\x0b\x0b\x0b",
2170         "\x87\xaa\x7c\xde\xa5\xef\x61\x9d\x4f\xf0\xb4\x24\x1a\x1d\x6c\xb0"
2171         "\x23\x79\xf4\xe2\xce\x4e\xc2\x78\x7a\xd0\xb3\x05\x45\xe1\x7c\xde"
2172         "\xda\xa8\x33\xb7\xd6\xb8\xa7\x02\x03\x8b\x27\x4e\xae\xa3\xf4\xe4"
2173         "\xbe\x9d\x91\x4e\xeb\x61\xf1\x70\x2e\x69\x6c\x20\x3a\x12\x68\x54" },
2174       { GCRY_MD_SHA512,
2175         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2176         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2177         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
2178         "\xdd\xdd\xdd\xdd\xdd",
2179         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
2180         "\xAA\xAA\xAA\xAA",
2181         "\xfa\x73\xb0\x08\x9d\x56\xa2\x84\xef\xb0\xf0\x75\x6c\x89\x0b\xe9"
2182         "\xb1\xb5\xdb\xdd\x8e\xe8\x1a\x36\x55\xf8\x3e\x33\xb2\x27\x9d\x39"
2183         "\xbf\x3e\x84\x82\x79\xa7\x22\xc8\x06\xb4\x85\xa4\x7e\x67\xc8\x07"
2184         "\xb9\x46\xa3\x37\xbe\xe8\x94\x26\x74\x27\x88\x59\xe1\x32\x92\xfb"  },
2185       { GCRY_MD_SHA512,
2186         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2187         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2188         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
2189         "\xcd\xcd\xcd\xcd\xcd",
2190         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
2191         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
2192         "\xb0\xba\x46\x56\x37\x45\x8c\x69\x90\xe5\xa8\xc5\xf6\x1d\x4a\xf7"
2193         "\xe5\x76\xd9\x7f\xf9\x4b\x87\x2d\xe7\x6f\x80\x50\x36\x1e\xe3\xdb"
2194         "\xa9\x1c\xa5\xc1\x1a\xa2\x5e\xb4\xd6\x79\x27\x5c\xc5\x78\x80\x63"
2195         "\xa5\xf1\x97\x41\x12\x0c\x4f\x2d\xe2\xad\xeb\xeb\x10\xa2\x98\xdd" },
2196       { GCRY_MD_SHA512,
2197         "Test Using Larger Than Block-Size Key - Hash Key First",
2198         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2199         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2200         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2201         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2202         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2203         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2204         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2205         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2206         "\xaa\xaa\xaa",
2207         "\x80\xb2\x42\x63\xc7\xc1\xa3\xeb\xb7\x14\x93\xc1\xdd\x7b\xe8\xb4"
2208         "\x9b\x46\xd1\xf4\x1b\x4a\xee\xc1\x12\x1b\x01\x37\x83\xf8\xf3\x52"
2209         "\x6b\x56\xd0\x37\xe0\x5f\x25\x98\xbd\x0f\xd2\x21\x5d\x6a\x1e\x52"
2210         "\x95\xe6\x4f\x73\xf6\x3f\x0a\xec\x8b\x91\x5a\x98\x5d\x78\x65\x98" },
2211       { GCRY_MD_SHA512,
2212         "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
2213         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2214         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2215         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2216         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2217         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2218         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2219         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2220         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
2221         "\xaa\xaa\xaa",
2222         "\xe3\x7b\x6a\x77\x5d\xc8\x7d\xba\xa4\xdf\xa9\xf9\x6e\x5e\x3f\xfd"
2223         "\xde\xbd\x71\xf8\x86\x72\x89\x86\x5d\xf5\xa3\x2d\x20\xcd\xc9\x44"
2224         "\xb6\x02\x2c\xac\x3c\x49\x82\xb1\x0d\x5e\xeb\x55\xc3\xe4\xde\x15"
2225         "\x13\x46\x76\xfb\x6d\xe0\x44\x60\x65\xc9\x74\x40\xfa\x8c\x6a\x58" },
2226       { 0 },
2227     };
2228   int i;
2229
2230   if (verbose)
2231     fprintf (stderr, "Starting hashed MAC checks.\n");
2232
2233   for (i = 0; algos[i].md; i++)
2234     {
2235       if ((gcry_md_test_algo (algos[i].md) || algos[i].md == GCRY_MD_MD5)
2236           && in_fips_mode)
2237         {
2238           if (verbose)
2239             fprintf (stderr, "  algorithm %d not available in fips mode\n",
2240                      algos[i].md);
2241           continue;
2242         }
2243       if (verbose)
2244         fprintf (stderr,
2245                  "  checking %s [%i] for %zi byte key and %zi byte data\n",
2246                  gcry_md_algo_name (algos[i].md),
2247                  algos[i].md,
2248                  strlen(algos[i].key), strlen(algos[i].data));
2249
2250       check_one_hmac (algos[i].md, algos[i].data, strlen (algos[i].data),
2251                       algos[i].key, strlen(algos[i].key),
2252                       algos[i].expect);
2253     }
2254
2255   if (verbose)
2256     fprintf (stderr, "Completed hashed MAC checks.\n");
2257  }
2258
2259 /* Check that the signature SIG matches the hash HASH. PKEY is the
2260    public key used for the verification. BADHASH is a hasvalue which
2261    should; result in a bad signature status. */
2262 static void
2263 verify_one_signature (gcry_sexp_t pkey, gcry_sexp_t hash,
2264                       gcry_sexp_t badhash, gcry_sexp_t sig)
2265 {
2266   gcry_error_t rc;
2267
2268   rc = gcry_pk_verify (sig, hash, pkey);
2269   if (rc)
2270     fail ("gcry_pk_verify failed: %s\n", gpg_strerror (rc));
2271   rc = gcry_pk_verify (sig, badhash, pkey);
2272   if (gcry_err_code (rc) != GPG_ERR_BAD_SIGNATURE)
2273     fail ("gcry_pk_verify failed to detect a bad signature: %s\n",
2274           gpg_strerror (rc));
2275 }
2276
2277
2278 /* Test the public key sign function using the private ket SKEY. PKEY
2279    is used for verification. */
2280 static void
2281 check_pubkey_sign (int n, gcry_sexp_t skey, gcry_sexp_t pkey)
2282 {
2283   gcry_error_t rc;
2284   gcry_sexp_t sig, badhash, hash;
2285   int dataidx;
2286   static const char baddata[] =
2287     "(data\n (flags pkcs1)\n"
2288     " (hash sha1 #11223344556677889900AABBCCDDEEFF10203041#))\n";
2289   static struct
2290   {
2291     const char *data;
2292     int expected_rc;
2293   } datas[] =
2294     {
2295       { "(data\n (flags pkcs1)\n"
2296         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
2297         0 },
2298       /* This test is to see whether hash algorithms not hard wired in
2299          pubkey.c are detected:  */
2300       { "(data\n (flags pkcs1)\n"
2301         " (hash oid.1.3.14.3.2.29 "
2302         "       #11223344556677889900AABBCCDDEEFF10203040#))\n",
2303         0 },
2304       { "(data\n (flags )\n"
2305         " (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
2306         GPG_ERR_CONFLICT },
2307       { "(data\n (flags pkcs1)\n"
2308         " (hash foo #11223344556677889900AABBCCDDEEFF10203040#))\n",
2309         GPG_ERR_DIGEST_ALGO },
2310       { "(data\n (flags )\n" " (value #11223344556677889900AA#))\n",
2311         0 },
2312       { "(data\n (flags )\n" " (value #0090223344556677889900AA#))\n",
2313         0 },
2314       { "(data\n (flags raw)\n" " (value #11223344556677889900AA#))\n",
2315         0 },
2316       { "(data\n (flags pkcs1)\n"
2317         " (value #11223344556677889900AA#))\n",
2318         GPG_ERR_CONFLICT },
2319       { "(data\n (flags raw foo)\n"
2320         " (value #11223344556677889900AA#))\n",
2321         GPG_ERR_INV_FLAG },
2322       { NULL }
2323     };
2324
2325   (void)n;
2326
2327   rc = gcry_sexp_sscan (&badhash, NULL, baddata, strlen (baddata));
2328   if (rc)
2329     die ("converting data failed: %s\n", gpg_strerror (rc));
2330
2331   for (dataidx = 0; datas[dataidx].data; dataidx++)
2332     {
2333       if (verbose)
2334         fprintf (stderr, "  signature test %d\n", dataidx);
2335
2336       rc = gcry_sexp_sscan (&hash, NULL, datas[dataidx].data,
2337                             strlen (datas[dataidx].data));
2338       if (rc)
2339         die ("converting data failed: %s\n", gpg_strerror (rc));
2340
2341       rc = gcry_pk_sign (&sig, hash, skey);
2342       if (gcry_err_code (rc) != datas[dataidx].expected_rc)
2343         fail ("gcry_pk_sign failed: %s\n", gpg_strerror (rc));
2344
2345       if (!rc)
2346         verify_one_signature (pkey, hash, badhash, sig);
2347
2348       gcry_sexp_release (sig);
2349       sig = NULL;
2350       gcry_sexp_release (hash);
2351       hash = NULL;
2352     }
2353
2354   gcry_sexp_release (badhash);
2355 }
2356
2357 static void
2358 check_pubkey_grip (int n, const unsigned char *grip,
2359                    gcry_sexp_t skey, gcry_sexp_t pkey)
2360 {
2361   unsigned char sgrip[20], pgrip[20];
2362
2363   if (!gcry_pk_get_keygrip (skey, sgrip))
2364     die ("get keygrip for private RSA key failed\n");
2365   if (!gcry_pk_get_keygrip (pkey, pgrip))
2366     die ("[%i] get keygrip for public RSA key failed\n", n);
2367   if (memcmp (sgrip, pgrip, 20))
2368     fail ("[%i] keygrips don't match\n", n);
2369   if (memcmp (sgrip, grip, 20))
2370     fail ("wrong keygrip for RSA key\n");
2371 }
2372
2373 static void
2374 do_check_one_pubkey (int n, gcry_sexp_t skey, gcry_sexp_t pkey,
2375                      const unsigned char *grip, int flags)
2376 {
2377  if (flags & FLAG_SIGN)
2378     check_pubkey_sign (n, skey, pkey);
2379  if (grip && (flags & FLAG_GRIP))
2380    check_pubkey_grip (n, grip, skey, pkey);
2381 }
2382
2383 static void
2384 check_one_pubkey (int n, test_spec_pubkey_t spec)
2385 {
2386   gcry_error_t err = GPG_ERR_NO_ERROR;
2387   gcry_sexp_t skey, pkey;
2388
2389   err = gcry_sexp_sscan (&skey, NULL, spec.key.secret,
2390                          strlen (spec.key.secret));
2391   if (!err)
2392     err = gcry_sexp_sscan (&pkey, NULL, spec.key.public,
2393                            strlen (spec.key.public));
2394   if (err)
2395     die ("converting sample key failed: %s\n", gpg_strerror (err));
2396
2397   do_check_one_pubkey (n, skey, pkey,
2398                        (const unsigned char*)spec.key.grip, spec.flags);
2399
2400   gcry_sexp_release (skey);
2401   gcry_sexp_release (pkey);
2402 }
2403
2404 static void
2405 get_keys_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
2406 {
2407   gcry_sexp_t key_spec, key, pub_key, sec_key;
2408   int rc;
2409   if (verbose)
2410     fprintf (stderr, "  generating RSA key:");
2411   rc = gcry_sexp_new (&key_spec,
2412                       in_fips_mode ? "(genkey (rsa (nbits 4:1024)))"
2413                       : "(genkey (rsa (nbits 4:1024)(transient-key)))",
2414                       0, 1);
2415   if (rc)
2416     die ("error creating S-expression: %s\n", gpg_strerror (rc));
2417   rc = gcry_pk_genkey (&key, key_spec);
2418   gcry_sexp_release (key_spec);
2419   if (rc)
2420     die ("error generating RSA key: %s\n", gpg_strerror (rc));
2421
2422   pub_key = gcry_sexp_find_token (key, "public-key", 0);
2423   if (! pub_key)
2424     die ("public part missing in key\n");
2425
2426   sec_key = gcry_sexp_find_token (key, "private-key", 0);
2427   if (! sec_key)
2428     die ("private part missing in key\n");
2429
2430   gcry_sexp_release (key);
2431   *pkey = pub_key;
2432   *skey = sec_key;
2433 }
2434
2435 static void
2436 check_one_pubkey_new (int n)
2437 {
2438   gcry_sexp_t skey, pkey;
2439
2440   get_keys_new (&pkey, &skey);
2441   do_check_one_pubkey (n, skey, pkey, NULL, FLAG_SIGN | FLAG_CRYPT);
2442 }
2443
2444 /* Run all tests for the public key functions. */
2445 static void
2446 check_pubkey (void)
2447 {
2448   test_spec_pubkey_t pubkeys[] =
2449     {
2450       {
2451         GCRY_PK_RSA, FLAG_CRYPT | FLAG_SIGN,
2452
2453         { "(private-key\n"
2454           " (rsa\n"
2455           "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
2456           "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
2457           "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
2458           "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
2459           "  (e #010001#)\n"
2460           "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
2461           "      7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
2462           "      C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
2463           "      C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
2464           "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
2465           "      fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424f1#)\n"
2466           "  (q #00f7a7ca5367c661f8e62df34f0d05c10c88e5492348dd7bddc942c9a8f369f9"
2467           "      35a07785d2db805215ed786e4285df1658eed3ce84f469b81b50d358407b4ad361#)\n"
2468           "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
2469           "      ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b#)))\n",
2470
2471           "(public-key\n"
2472           " (rsa\n"
2473           "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
2474           "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
2475           "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
2476           "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
2477           "  (e #010001#)))\n",
2478
2479           "\x32\x10\x0c\x27\x17\x3e\xf6\xe9\xc4\xe9"
2480           "\xa2\x5d\x3d\x69\xf8\x6d\x37\xa4\xf9\x39"}
2481       },
2482       {
2483         GCRY_PK_DSA, FLAG_SIGN,
2484
2485         { "(private-key\n"
2486           " (DSA\n"
2487           "  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
2488           "      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
2489           "      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
2490           "      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D8777B#)\n"
2491           "  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)\n"
2492           "  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
2493           "      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
2494           "      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
2495           "      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15#)\n"
2496           "  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
2497           "      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
2498           "      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
2499           "      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB#)\n"
2500           "  (x #11D54E4ADBD3034160F2CED4B7CD292A4EBF3EC0#)))\n",
2501
2502           "(public-key\n"
2503           " (DSA\n"
2504           "  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
2505           "      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
2506           "      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
2507           "      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D8777B#)\n"
2508           "  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)\n"
2509           "  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
2510           "      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
2511           "      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
2512           "      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15#)\n"
2513           "  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
2514           "      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
2515           "      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
2516           "      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB#)))\n",
2517
2518           "\xc6\x39\x83\x1a\x43\xe5\x05\x5d\xc6\xd8"
2519           "\x4a\xa6\xf9\xeb\x23\xbf\xa9\x12\x2d\x5b" }
2520       },
2521       {
2522         GCRY_PK_ELG, FLAG_SIGN | FLAG_CRYPT,
2523
2524         { "(private-key\n"
2525           " (ELG\n"
2526           "  (p #00B93B93386375F06C2D38560F3B9C6D6D7B7506B20C1773F73F8DE56E6CD65D"
2527           "      F48DFAAA1E93F57A2789B168362A0F787320499F0B2461D3A4268757A7B27517"
2528           "      B7D203654A0CD484DEC6AF60C85FEB84AAC382EAF2047061FE5DAB81A20A0797"
2529           "      6E87359889BAE3B3600ED718BE61D4FC993CC8098A703DD0DC942E965E8F18D2A7#)\n"
2530           "  (g #05#)\n"
2531           "  (y #72DAB3E83C9F7DD9A931FDECDC6522C0D36A6F0A0FEC955C5AC3C09175BBFF2B"
2532           "      E588DB593DC2E420201BEB3AC17536918417C497AC0F8657855380C1FCF11C5B"
2533           "      D20DB4BEE9BDF916648DE6D6E419FA446C513AAB81C30CB7B34D6007637BE675"
2534           "      56CE6473E9F9EE9B9FADD275D001563336F2186F424DEC6199A0F758F6A00FF4#)\n"
2535           "  (x #03C28900087B38DABF4A0AB98ACEA39BB674D6557096C01D72E31C16BDD32214#)))\n",
2536
2537           "(public-key\n"
2538           " (ELG\n"
2539           "  (p #00B93B93386375F06C2D38560F3B9C6D6D7B7506B20C1773F73F8DE56E6CD65D"
2540           "      F48DFAAA1E93F57A2789B168362A0F787320499F0B2461D3A4268757A7B27517"
2541           "      B7D203654A0CD484DEC6AF60C85FEB84AAC382EAF2047061FE5DAB81A20A0797"
2542           "      6E87359889BAE3B3600ED718BE61D4FC993CC8098A703DD0DC942E965E8F18D2A7#)\n"
2543           "  (g #05#)\n"
2544           "  (y #72DAB3E83C9F7DD9A931FDECDC6522C0D36A6F0A0FEC955C5AC3C09175BBFF2B"
2545           "      E588DB593DC2E420201BEB3AC17536918417C497AC0F8657855380C1FCF11C5B"
2546           "      D20DB4BEE9BDF916648DE6D6E419FA446C513AAB81C30CB7B34D6007637BE675"
2547           "      56CE6473E9F9EE9B9FADD275D001563336F2186F424DEC6199A0F758F6A00FF4#)))\n",
2548
2549           "\xa7\x99\x61\xeb\x88\x83\xd2\xf4\x05\xc8"
2550           "\x4f\xba\x06\xf8\x78\x09\xbc\x1e\x20\xe5" }
2551       },
2552     };
2553   int i;
2554   if (verbose)
2555     fprintf (stderr, "Starting public key checks.\n");
2556   for (i = 0; i < sizeof (pubkeys) / sizeof (*pubkeys); i++)
2557     if (pubkeys[i].id)
2558       {
2559         if (gcry_pk_test_algo (pubkeys[i].id) && in_fips_mode)
2560           {
2561             if (verbose)
2562               fprintf (stderr, "  algorithm %d not available in fips mode\n",
2563                        pubkeys[i].id);
2564             continue;
2565           }
2566         check_one_pubkey (i, pubkeys[i]);
2567       }
2568   if (verbose)
2569     fprintf (stderr, "Completed public key checks.\n");
2570
2571   if (verbose)
2572     fprintf (stderr, "Starting additional public key checks.\n");
2573   for (i = 0; i < sizeof (pubkeys) / sizeof (*pubkeys); i++)
2574     if (pubkeys[i].id)
2575       {
2576         if (gcry_pk_test_algo (pubkeys[i].id) && in_fips_mode)
2577           {
2578             if (verbose)
2579               fprintf (stderr, "  algorithm %d not available in fips mode\n",
2580                        pubkeys[i].id);
2581             continue;
2582           }
2583         check_one_pubkey_new (i);
2584       }
2585   if (verbose)
2586     fprintf (stderr, "Completed additional public key checks.\n");
2587
2588 }
2589
2590 int
2591 main (int argc, char **argv)
2592 {
2593   gpg_error_t err;
2594   int last_argc = -1;
2595   int debug = 0;
2596   int use_fips = 0;
2597   int selftest_only = 0;
2598
2599   if (argc)
2600     { argc--; argv++; }
2601
2602   while (argc && last_argc != argc )
2603     {
2604       last_argc = argc;
2605       if (!strcmp (*argv, "--"))
2606         {
2607           argc--; argv++;
2608           break;
2609         }
2610       else if (!strcmp (*argv, "--verbose"))
2611         {
2612           verbose++;
2613           argc--; argv++;
2614         }
2615       else if (!strcmp (*argv, "--debug"))
2616         {
2617           verbose = debug = 1;
2618           argc--; argv++;
2619         }
2620       else if (!strcmp (*argv, "--fips"))
2621         {
2622           use_fips = 1;
2623           argc--; argv++;
2624         }
2625       else if (!strcmp (*argv, "--selftest"))
2626         {
2627           selftest_only = 1;
2628           verbose += 2;
2629           argc--; argv++;
2630         }
2631     }
2632
2633   gcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
2634
2635   if (use_fips)
2636     gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
2637
2638   /* Check that we test exactly our version - including the patchlevel.  */
2639   if (strcmp (GCRYPT_VERSION, gcry_check_version (NULL)))
2640     die ("version mismatch; pgm=%s, library=%s\n",
2641          GCRYPT_VERSION,gcry_check_version (NULL));
2642
2643   if ( gcry_fips_mode_active () )
2644     in_fips_mode = 1;
2645
2646   if (!in_fips_mode)
2647     gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
2648
2649   if (verbose)
2650     gcry_set_progress_handler (progress_handler, NULL);
2651
2652   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
2653   if (debug)
2654     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
2655   /* No valuable keys are create, so we can speed up our RNG. */
2656   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2657
2658   if (!selftest_only)
2659     {
2660       check_ciphers ();
2661       check_cipher_modes ();
2662       check_bulk_cipher_modes ();
2663       check_digests ();
2664       check_hmac ();
2665       check_pubkey ();
2666     }
2667
2668
2669   if (in_fips_mode && !selftest_only)
2670     {
2671       /* If we are in fips mode do some more tests. */
2672       gcry_md_hd_t md;
2673
2674       /* First trigger a self-test.  */
2675       gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
2676       if (!gcry_control (GCRYCTL_OPERATIONAL_P, 0))
2677         fail ("not in operational state after self-test\n");
2678
2679       /* Get us into the error state.  */
2680       err = gcry_md_open (&md, GCRY_MD_SHA1, 0);
2681       if (err)
2682         fail ("failed to open SHA-1 hash context: %s\n", gpg_strerror (err));
2683       else
2684         {
2685           err = gcry_md_enable (md, GCRY_MD_SHA256);
2686           if (err)
2687             fail ("failed to add SHA-256 hash context: %s\n",
2688                   gpg_strerror (err));
2689           else
2690             {
2691               /* gcry_md_get_algo is only defined for a context with
2692                  just one digest algorithm.  With our setup it should
2693                  put the oibrary intoerror state.  */
2694               fputs ("Note: Two lines with error messages follow "
2695                      "- this is expected\n", stderr);
2696               gcry_md_get_algo (md);
2697               gcry_md_close (md);
2698               if (gcry_control (GCRYCTL_OPERATIONAL_P, 0))
2699                 fail ("expected error state but still in operational state\n");
2700               else
2701                 {
2702                   /* Now run a self-test and to get back into
2703                      operational state.  */
2704                   gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
2705                   if (!gcry_control (GCRYCTL_OPERATIONAL_P, 0))
2706                     fail ("did not reach operational after error "
2707                           "and self-test\n");
2708                 }
2709             }
2710         }
2711
2712     }
2713   else
2714     {
2715       /* If in standard mode, run selftests.  */
2716       if (gcry_control (GCRYCTL_SELFTEST, 0))
2717         fail ("running self-test failed\n");
2718     }
2719
2720   if (verbose)
2721     fprintf (stderr, "\nAll tests completed. Errors: %i\n", error_count);
2722
2723   if (in_fips_mode && !gcry_fips_mode_active ())
2724     fprintf (stderr, "FIPS mode is not anymore active\n");
2725
2726   return error_count ? 1 : 0;
2727 }