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