diff --git a/tests/aeswrap.c b/tests/aeswrap.c
index dbbd7dd9..7c7e60bf 100644
--- a/tests/aeswrap.c
+++ b/tests/aeswrap.c
@@ -1,284 +1,284 @@
 /* aeswrap.c -  AESWRAP mode regression tests
  *	Copyright (C) 2009 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 
 #define PGM "aeswrap"
 #include "t-common.h"
 
 
 static void
 check_one (int algo,
            const void *kek, size_t keklen,
            const void *data, size_t datalen,
            const void *expected, size_t expectedlen,
            int inplace)
 {
   gcry_error_t err;
   gcry_cipher_hd_t hd;
   unsigned char outbuf[32+8];
   size_t outbuflen;
 
   err = gcry_cipher_open (&hd, algo, GCRY_CIPHER_MODE_AESWRAP, 0);
   if (err)
     {
       fail ("gcry_cipher_open failed: %s\n", gpg_strerror (err));
       return;
     }
 
   err = gcry_cipher_setkey (hd, kek, keklen);
   if (err)
     {
       fail ("gcry_cipher_setkey failed: %s\n", gpg_strerror (err));
       return;
     }
 
   outbuflen = datalen + 8;
   if (outbuflen > sizeof outbuf)
     {
       err = gpg_error (GPG_ERR_INTERNAL);
     }
   else if (inplace)
     {
       memcpy (outbuf, data, datalen);
       err = gcry_cipher_encrypt (hd, outbuf, outbuflen, outbuf, datalen);
     }
   else
     {
       err = gcry_cipher_encrypt (hd, outbuf, outbuflen, data, datalen);
     }
 
   if (err)
     {
       fail ("gcry_cipher_encrypt failed: %s\n", gpg_strerror (err));
       return;
     }
 
   if (outbuflen != expectedlen || memcmp (outbuf, expected, expectedlen))
     {
       const unsigned char *s;
       int i;
 
       fail ("mismatch at encryption!%s\n", inplace ? " (inplace)" : "");
       fprintf (stderr, "computed: ");
       for (i = 0; i < outbuflen; i++)
 	fprintf (stderr, "%02x ", outbuf[i]);
       fprintf (stderr, "\nexpected: ");
       for (s = expected, i = 0; i < expectedlen; s++, i++)
         fprintf (stderr, "%02x ", *s);
       putc ('\n', stderr);
     }
 
 
   outbuflen = expectedlen - 8;
   if (outbuflen > sizeof outbuf)
     {
       err = gpg_error (GPG_ERR_INTERNAL);
     }
   else if (inplace)
     {
       memcpy (outbuf, expected, expectedlen);
       err = gcry_cipher_decrypt (hd, outbuf, outbuflen, outbuf, expectedlen);
     }
   else
     {
       err = gcry_cipher_decrypt (hd, outbuf, outbuflen, expected, expectedlen);
     }
 
   if (err)
     {
       fail ("gcry_cipher_decrypt failed: %s\n", gpg_strerror (err));
       return;
     }
 
   if (outbuflen != datalen || memcmp (outbuf, data, datalen))
     {
       const unsigned char *s;
       int i;
 
       fail ("mismatch at decryption!%s\n", inplace ? " (inplace)" : "");
       fprintf (stderr, "computed: ");
       for (i = 0; i < outbuflen; i++)
 	fprintf (stderr, "%02x ", outbuf[i]);
       fprintf (stderr, "\nexpected: ");
       for (s = data, i = 0; i < datalen; s++, i++)
         fprintf (stderr, "%02x ", *s);
       putc ('\n', stderr);
     }
 
   /* Now the last step again with a key reset. */
   gcry_cipher_reset (hd);
 
   outbuflen = expectedlen - 8;
   if (outbuflen > sizeof outbuf)
     {
       err = gpg_error (GPG_ERR_INTERNAL);
     }
   else if (inplace)
     {
       memcpy (outbuf, expected, expectedlen);
       err = gcry_cipher_decrypt (hd, outbuf, outbuflen, outbuf, expectedlen);
     }
   else
     {
       err = gcry_cipher_decrypt (hd, outbuf, outbuflen, expected, expectedlen);
     }
 
   if (err)
     {
       fail ("gcry_cipher_decrypt(2) failed: %s\n", gpg_strerror (err));
       return;
     }
 
   if (outbuflen != datalen || memcmp (outbuf, data, datalen))
     fail ("mismatch at decryption(2)!%s\n", inplace ? " (inplace)" : "");
 
   /* And once more without a key reset. */
   outbuflen = expectedlen - 8;
   if (outbuflen > sizeof outbuf)
     {
       err = gpg_error (GPG_ERR_INTERNAL);
     }
   else if (inplace)
     {
       memcpy (outbuf, expected, expectedlen);
       err = gcry_cipher_decrypt (hd, outbuf, outbuflen, outbuf, expectedlen);
     }
   else
     {
       err = gcry_cipher_decrypt (hd, outbuf, outbuflen, expected, expectedlen);
     }
 
   if (err)
     {
       fail ("gcry_cipher_decrypt(3) failed: %s\n", gpg_strerror (err));
       return;
     }
 
   if (outbuflen != datalen || memcmp (outbuf, data, datalen))
     fail ("mismatch at decryption(3)!%s\n", inplace ? " (inplace)" : "");
 
   gcry_cipher_close (hd);
 }
 
 
 static void
 check (int algo,
        const void *kek, size_t keklen,
        const void *data, size_t datalen,
        const void *expected, size_t expectedlen)
 {
   check_one (algo, kek, keklen, data, datalen, expected, expectedlen, 0);
   check_one (algo, kek, keklen, data, datalen, expected, expectedlen, 1);
 }
 
 
 static void
 check_all (void)
 {
   if (verbose)
     fprintf (stderr, "4.1 Wrap 128 bits of Key Data with a 128-bit KEK\n");
   check
     (GCRY_CIPHER_AES128,
      "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F", 16,
      "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF", 16,
      "\x1F\xA6\x8B\x0A\x81\x12\xB4\x47\xAE\xF3\x4B\xD8\xFB\x5A\x7B\x82"
      "\x9D\x3E\x86\x23\x71\xD2\xCF\xE5", 24);
 
   if (verbose)
     fprintf (stderr, "4.2 Wrap 128 bits of Key Data with a 192-bit KEK\n");
   check
     (GCRY_CIPHER_AES192,
      "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
      "\x10\x11\x12\x13\x14\x15\x16\x17", 24,
      "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF", 16,
      "\x96\x77\x8B\x25\xAE\x6C\xA4\x35\xF9\x2B\x5B\x97\xC0\x50\xAE\xD2"
      "\x46\x8A\xB8\xA1\x7A\xD8\x4E\x5D", 24);
 
   if (verbose)
     fprintf (stderr, "4.3 Wrap 128 bits of Key Data with a 256-bit KEK\n");
   check
     (GCRY_CIPHER_AES256,
      "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
      "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F", 32,
      "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF", 16,
      "\x64\xE8\xC3\xF9\xCE\x0F\x5B\xA2\x63\xE9\x77\x79\x05\x81\x8A\x2A"
      "\x93\xC8\x19\x1E\x7D\x6E\x8A\xE7", 24);
 
   if (verbose)
     fprintf (stderr, "4.4 Wrap 192 bits of Key Data with a 192-bit KEK\n");
   check
     (GCRY_CIPHER_AES192,
      "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
      "\x10\x11\x12\x13\x14\x15\x16\x17", 24,
      "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"
      "\x00\x01\x02\x03\x04\x05\x06\x07", 24,
      "\x03\x1D\x33\x26\x4E\x15\xD3\x32\x68\xF2\x4E\xC2\x60\x74\x3E\xDC"
      "\xE1\xC6\xC7\xDD\xEE\x72\x5A\x93\x6B\xA8\x14\x91\x5C\x67\x62\xD2", 32);
 
   if (verbose)
     fprintf (stderr, "4.5 Wrap 192 bits of Key Data with a 256-bit KEK\n");
   check
     (GCRY_CIPHER_AES256,
      "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
      "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F", 32,
      "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"
      "\x00\x01\x02\x03\x04\x05\x06\x07", 24,
      "\xA8\xF9\xBC\x16\x12\xC6\x8B\x3F\xF6\xE6\xF4\xFB\xE3\x0E\x71\xE4"
      "\x76\x9C\x8B\x80\xA3\x2C\xB8\x95\x8C\xD5\xD1\x7D\x6B\x25\x4D\xA1", 32);
 
   if (verbose)
     fprintf (stderr, "4.6 Wrap 256 bits of Key Data with a 256-bit KEK\n");
   check
     (GCRY_CIPHER_AES,
      "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
      "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F", 32,
      "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"
      "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F", 32,
      "\x28\xC9\xF4\x04\xC4\xB8\x10\xF4\xCB\xCC\xB3\x5C\xFB\x87\xF8\x26"
      "\x3F\x57\x86\xE2\xD8\x0E\xD3\x26\xCB\xC7\xF0\xE7\x1A\x99\xF4\x3B"
      "\xFB\x98\x8B\x9B\x7A\x02\xDD\x21", 40);
 }
 
 int
 main (int argc, char **argv)
 {
   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     verbose = 1;
   else if (argc > 1 && !strcmp (argv[1], "--debug"))
     verbose = debug = 1;
 
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
   check_all ();
 
   return error_count ? 1 : 0;
 }
diff --git a/tests/basic.c b/tests/basic.c
index b0c292a0..fd074cba 100644
--- a/tests/basic.c
+++ b/tests/basic.c
@@ -1,12635 +1,12635 @@
 /* basic.c  -  basic regression tests
  * Copyright (C) 2001, 2002, 2003, 2005, 2008,
  *               2009 Free Software Foundation, Inc.
  * Copyright (C) 2013 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <assert.h>
 
 #include "../src/gcrypt-int.h"
 
 #define PGM "basic"
 #include "t-common.h"
 
 typedef struct test_spec_pubkey_key
 {
   const char *secret;
   const char *public;
   const char *grip;
 }
 test_spec_pubkey_key_t;
 
 typedef struct test_spec_pubkey
 {
   int id;
   int flags;
   test_spec_pubkey_key_t key;
 }
 test_spec_pubkey_t;
 
 #define FLAG_CRYPT (1 << 0)
 #define FLAG_SIGN  (1 << 1)
 #define FLAG_GRIP  (1 << 2)
 
 static int in_fips_mode;
 
 #define MAX_DATA_LEN 128
 
 
 static void
 mismatch (const void *expected, size_t expectedlen,
           const void *computed, size_t computedlen)
 {
   const unsigned char *p;
 
   fprintf (stderr, "expected:");
   for (p = expected; expectedlen; p++, expectedlen--)
     fprintf (stderr, " %02x", *p);
   fprintf (stderr, "\ncomputed:");
   for (p = computed; computedlen; p++, computedlen--)
     fprintf (stderr, " %02x", *p);
   fprintf (stderr, "\n");
 }
 
 
 /* Convert STRING consisting of hex characters into its binary
    representation and return it as an allocated buffer. The valid
    length of the buffer is returned at R_LENGTH.  The string is
    delimited by end of string.  The function terminates on error.  */
 static void *
 hex2buffer (const char *string, size_t *r_length)
 {
   const char *s;
   unsigned char *buffer;
   size_t length;
 
   buffer = xmalloc (strlen(string)/2+1);
   length = 0;
   for (s=string; *s; s +=2 )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         die ("invalid hex digits in \"%s\"\n", string);
       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     }
   *r_length = length;
   return buffer;
 }
 
 
 static void
 show_sexp (const char *prefix, gcry_sexp_t a)
 {
   char *buf;
   size_t size;
 
   if (prefix)
     fputs (prefix, stderr);
   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   buf = gcry_xmalloc (size);
 
   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
   fprintf (stderr, "%.*s", (int)size, buf);
   gcry_free (buf);
 }
 
 
 static void
 show_note (const char *format, ...)
 {
   va_list arg_ptr;
 
   if (!verbose && getenv ("srcdir"))
     fputs ("      ", stderr);  /* To align above "PASS: ".  */
   else
     fprintf (stderr, "%s: ", PGM);
   va_start (arg_ptr, format);
   vfprintf (stderr, format, arg_ptr);
   if (*format && format[strlen(format)-1] != '\n')
     putc ('\n', stderr);
   va_end (arg_ptr);
 }
 
 
 static void
 show_md_not_available (int algo)
 {
   static int list[100];
   static int listlen;
   int i;
 
   if (!verbose && algo == GCRY_MD_MD2)
     return;  /* Do not print the diagnostic for that one.  */
 
   for (i=0; i < listlen; i++)
     if (algo == list[i])
       return; /* Note already printed.  */
   if (listlen < DIM (list))
     list[listlen++] = algo;
   show_note ("hash algorithm %d not available - skipping tests", algo);
 }
 
 
 static void
 show_old_hmac_not_available (int algo)
 {
   static int list[100];
   static int listlen;
   int i;
 
   if (!verbose && algo == GCRY_MD_MD2)
     return;  /* Do not print the diagnostic for that one.  */
 
   for (i=0; i < listlen; i++)
     if (algo == list[i])
       return; /* Note already printed.  */
   if (listlen < DIM (list))
     list[listlen++] = algo;
   show_note ("hash algorithm %d for old HMAC API not available "
              "- skipping tests", algo);
 }
 
 
 static void
 show_mac_not_available (int algo)
 {
   static int list[100];
   static int listlen;
   int i;
 
   if (!verbose && algo == GCRY_MD_MD2)
     return;  /* Do not print the diagnostic for that one.  */
 
   for (i=0; i < listlen; i++)
     if (algo == list[i])
       return; /* Note already printed.  */
   if (listlen < DIM (list))
     list[listlen++] = algo;
   show_note ("MAC algorithm %d not available - skipping tests", algo);
 }
 
 
 
 void
 progress_handler (void *cb_data, const char *what, int printchar,
 		  int current, int total)
 {
   (void)cb_data;
   (void)what;
   (void)current;
   (void)total;
 
   if (printchar == '\n')
     fputs ( "<LF>", stdout);
   else
     putchar (printchar);
   fflush (stdout);
 }
 
 static void
 check_cbc_mac_cipher (void)
 {
   static const struct tv
   {
     int algo;
     char key[MAX_DATA_LEN];
     unsigned char plaintext[MAX_DATA_LEN];
     size_t plaintextlen;
     char mac[MAX_DATA_LEN];
   }
   tv[] =
     {
       { GCRY_CIPHER_AES,
 	"chicken teriyaki",
 	"This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
 	0, "\x23\x8f\x6d\xc7\x53\x6a\x62\x97\x11\xc4\xa5\x16\x43\xea\xb0\xb6" },
       { GCRY_CIPHER_3DES,
 	"abcdefghABCDEFGH01234567",
 	"This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
 	0, "\x5c\x11\xf0\x01\x47\xbd\x3d\x3a" },
       { GCRY_CIPHER_DES,
 	"abcdefgh",
 	"This is a sample plaintext for CBC MAC of sixtyfour bytes.......",
 	0, "\xfa\x4b\xdf\x9d\xfa\xab\x01\x70" }
     };
   gcry_cipher_hd_t hd;
   unsigned char out[MAX_DATA_LEN];
   int i, blklen, keylen;
   gcry_error_t err = 0;
 
   if (verbose)
     fprintf (stderr, "  Starting CBC MAC checks.\n");
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
                      tv[i].algo);
           continue;
         }
 
       err = gcry_cipher_open (&hd,
 			      tv[i].algo,
 			      GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_MAC);
       if (!hd)
 	{
 	  fail ("cbc-mac algo %d, gcry_cipher_open failed: %s\n",
 		tv[i].algo, gpg_strerror (err));
 	  return;
 	}
 
       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
       if (!blklen)
 	{
 	  fail ("cbc-mac algo %d, gcry_cipher_get_algo_blklen failed\n",
 		 tv[i].algo);
 	  gcry_cipher_close (hd);
 	  return;
 	}
 
       keylen = gcry_cipher_get_algo_keylen (tv[i].algo);
       if (!keylen)
 	{
 	  fail ("cbc-mac algo %d, gcry_cipher_get_algo_keylen failed\n",
 		tv[i].algo);
 	  return;
 	}
 
       err = gcry_cipher_setkey (hd, tv[i].key, keylen);
       if (err)
 	{
 	  fail ("cbc-mac algo %d, gcry_cipher_setkey failed: %s\n",
 		tv[i].algo, gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  return;
 	}
 
       err = gcry_cipher_setiv (hd, NULL, 0);
       if (err)
 	{
 	  fail ("cbc-mac algo %d, gcry_cipher_setiv failed: %s\n",
 		tv[i].algo, gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  return;
 	}
 
       if (verbose)
 	fprintf (stderr, "    checking CBC MAC for %s [%i]\n",
 		 gcry_cipher_algo_name (tv[i].algo),
 		 tv[i].algo);
       err = gcry_cipher_encrypt (hd,
 				 out, blklen,
 				 tv[i].plaintext,
 				 tv[i].plaintextlen ?
 				 tv[i].plaintextlen :
 				 strlen ((char*)tv[i].plaintext));
       if (err)
 	{
 	  fail ("cbc-mac algo %d, gcry_cipher_encrypt failed: %s\n",
 		tv[i].algo, gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  return;
 	}
 
 #if 0
       {
 	int j;
 	for (j = 0; j < gcry_cipher_get_algo_blklen (tv[i].algo); j++)
 	  printf ("\\x%02x", out[j] & 0xFF);
 	printf ("\n");
       }
 #endif
 
       if (memcmp (tv[i].mac, out, blklen))
 	fail ("cbc-mac algo %d, encrypt mismatch entry %d\n", tv[i].algo, i);
 
       gcry_cipher_close (hd);
     }
   if (verbose)
     fprintf (stderr, "  Completed CBC MAC checks.\n");
 }
 
 static void
 check_aes128_cbc_cts_cipher (void)
 {
   static const char key[128 / 8] = "chicken teriyaki";
   static const unsigned char plaintext[] =
     "I would like the General Gau's Chicken, please, and wonton soup.";
   static const struct tv
   {
     unsigned char out[MAX_DATA_LEN];
     int inlen;
   } tv[] =
     {
       { "\xc6\x35\x35\x68\xf2\xbf\x8c\xb4\xd8\xa5\x80\x36\x2d\xa7\xff\x7f"
 	"\x97",
 	17 },
       { "\xfc\x00\x78\x3e\x0e\xfd\xb2\xc1\xd4\x45\xd4\xc8\xef\xf7\xed\x22"
 	"\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5",
 	31 },
       { "\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8"
 	"\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84",
 	32 },
       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
 	"\xb3\xff\xfd\x94\x0c\x16\xa1\x8c\x1b\x55\x49\xd2\xf8\x38\x02\x9e"
 	"\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5",
 	47 },
       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
 	"\x9d\xad\x8b\xbb\x96\xc4\xcd\xc0\x3b\xc1\x03\xe1\xa1\x94\xbb\xd8"
 	"\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8",
 	48 },
       { "\x97\x68\x72\x68\xd6\xec\xcc\xc0\xc0\x7b\x25\xe2\x5e\xcf\xe5\x84"
 	"\x39\x31\x25\x23\xa7\x86\x62\xd5\xbe\x7f\xcb\xcc\x98\xeb\xf5\xa8"
 	"\x48\x07\xef\xe8\x36\xee\x89\xa5\x26\x73\x0d\xbc\x2f\x7b\xc8\x40"
 	"\x9d\xad\x8b\xbb\x96\xc4\xcd\xc0\x3b\xc1\x03\xe1\xa1\x94\xbb\xd8",
 	64 },
     };
   gcry_cipher_hd_t hd;
   unsigned char out[MAX_DATA_LEN];
   int i;
   gcry_error_t err = 0;
 
   if (verbose)
     fprintf (stderr, "  Starting AES128 CBC CTS checks.\n");
   err = gcry_cipher_open (&hd,
 			  GCRY_CIPHER_AES,
 			  GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_CTS);
   if (err)
     {
       fail ("aes-cbc-cts, gcry_cipher_open failed: %s\n", gpg_strerror (err));
       return;
     }
 
   err = gcry_cipher_setkey (hd, key, 128 / 8);
   if (err)
     {
       fail ("aes-cbc-cts, gcry_cipher_setkey failed: %s\n",
 	    gpg_strerror (err));
       gcry_cipher_close (hd);
       return;
     }
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       err = gcry_cipher_setiv (hd, NULL, 0);
       if (err)
 	{
 	  fail ("aes-cbc-cts, gcry_cipher_setiv failed: %s\n",
 		gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  return;
 	}
 
       if (verbose)
 	fprintf (stderr, "    checking encryption for length %i\n", tv[i].inlen);
       err = gcry_cipher_encrypt (hd, out, MAX_DATA_LEN,
 				 plaintext, tv[i].inlen);
       if (err)
 	{
 	  fail ("aes-cbc-cts, gcry_cipher_encrypt failed: %s\n",
 		gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  return;
 	}
 
       if (memcmp (tv[i].out, out, tv[i].inlen))
 	fail ("aes-cbc-cts, encrypt mismatch entry %d\n", i);
 
       err = gcry_cipher_setiv (hd, NULL, 0);
       if (err)
 	{
 	  fail ("aes-cbc-cts, gcry_cipher_setiv failed: %s\n",
 		gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  return;
 	}
       if (verbose)
 	fprintf (stderr, "    checking decryption for length %i\n", tv[i].inlen);
       err = gcry_cipher_decrypt (hd, out, tv[i].inlen, NULL, 0);
       if (err)
 	{
 	  fail ("aes-cbc-cts, gcry_cipher_decrypt failed: %s\n",
 		gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  return;
 	}
 
       if (memcmp (plaintext, out, tv[i].inlen))
 	fail ("aes-cbc-cts, decrypt mismatch entry %d\n", i);
     }
 
   gcry_cipher_close (hd);
   if (verbose)
     fprintf (stderr, "  Completed AES128 CBC CTS checks.\n");
 }
 
 static void
 check_ecb_cipher (void)
 {
   /* ECB cipher check. Mainly for testing underlying block cipher. */
   static const struct tv
   {
     int algo;
     const char *key;
     struct
     {
       const char *plaintext;
       int keylen;
       int inlen;
       const char *out;
     } data[MAX_DATA_LEN];
   } tv[] =
     {
       /* Test vectors from OpenSSL for key lengths of 8 to 200 bits */
       { GCRY_CIPHER_BLOWFISH,
 	"\xf0\xe1\xd2\xc3\xb4\xa5\x96\x87\x78\x69\x5a\x4b\x3c\x2d\x1e\x0f"
 	"\x00\x11\x22\x33\x44\x55\x66\x77\x88",
 	{ { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    1,
 	    8,
 	    "\xf9\xad\x59\x7c\x49\xdb\x00\x5e" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    2,
 	    8,
 	    "\xe9\x1d\x21\xc1\xd9\x61\xa6\xd6" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    3,
 	    8,
 	    "\xe9\xc2\xb7\x0a\x1b\xc6\x5c\xf3" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    4,
 	    8,
 	    "\xbe\x1e\x63\x94\x08\x64\x0f\x05" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    5,
 	    8,
 	    "\xb3\x9e\x44\x48\x1b\xdb\x1e\x6e" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    6,
 	    8,
 	    "\x94\x57\xaa\x83\xb1\x92\x8c\x0d" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    7,
 	    8,
 	    "\x8b\xb7\x70\x32\xf9\x60\x62\x9d" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    8,
 	    8,
 	    "\xe8\x7a\x24\x4e\x2c\xc8\x5e\x82" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    9,
 	    8,
 	    "\x15\x75\x0e\x7a\x4f\x4e\xc5\x77" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    10,
 	    8,
 	    "\x12\x2b\xa7\x0b\x3a\xb6\x4a\xe0" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    11,
 	    8,
 	    "\x3a\x83\x3c\x9a\xff\xc5\x37\xf6" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    12,
 	    8,
 	    "\x94\x09\xda\x87\xa9\x0f\x6b\xf2" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    13,
 	    8,
 	    "\x88\x4f\x80\x62\x50\x60\xb8\xb4" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    14,
 	    8,
 	    "\x1f\x85\x03\x1c\x19\xe1\x19\x68" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    15,
 	    8,
 	    "\x79\xd9\x37\x3a\x71\x4c\xa3\x4f" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    16,
 	    8,
 	    "\x93\x14\x28\x87\xee\x3b\xe1\x5c" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    17,
 	    8,
 	    "\x03\x42\x9e\x83\x8c\xe2\xd1\x4b" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    18,
 	    8,
 	    "\xa4\x29\x9e\x27\x46\x9f\xf6\x7b" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    19,
 	    8,
 	    "\xaf\xd5\xae\xd1\xc1\xbc\x96\xa8" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    20,
 	    8,
 	    "\x10\x85\x1c\x0e\x38\x58\xda\x9f" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    21,
 	    8,
 	    "\xe6\xf5\x1e\xd7\x9b\x9d\xb2\x1f" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    22,
 	    8,
 	    "\x64\xa6\xe1\x4a\xfd\x36\xb4\x6f" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    23,
 	    8,
 	    "\x80\xc7\xd7\xd4\x5a\x54\x79\xad" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    24,
 	    8,
 	    "\x05\x04\x4b\x62\xfa\x52\xd0\x80" },
 	  { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    0, /* test default key length of 128-bits */
 	    8,
 	    "\x93\x14\x28\x87\xee\x3b\xe1\x5c" },
 	  { }
 	}
       },
       /* Test vector from Linux kernel for key length of 448 bits */
       { GCRY_CIPHER_BLOWFISH,
 	"\xf0\xe1\xd2\xc3\xb4\xa5\x96\x87\x78\x69\x5a\x4b\x3c\x2d\x1e\x0f"
 	"\x00\x11\x22\x33\x44\x55\x66\x77\x04\x68\x91\x04\xc2\xfd\x3b\x2f"
 	"\x58\x40\x23\x64\x1a\xba\x61\x76\x1f\x1f\x1f\x1f\x0e\x0e\x0e\x0e"
 	"\xff\xff\xff\xff\xff\xff\xff\xff",
 	{ { "\xfe\xdc\xba\x98\x76\x54\x32\x10",
 	    56,
 	    8,
 	    "\xc0\x45\x04\x01\x2e\x4e\x1f\x53" },
 	  { }
 	}
       },
     };
   gcry_cipher_hd_t hde, hdd;
   unsigned char out[MAX_DATA_LEN];
   int i, j, keylen, algo;
   gcry_error_t err = 0;
   gcry_error_t err2 = 0;
 
   if (verbose)
     fprintf (stderr, "  Starting ECB checks.\n");
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       algo = tv[i].algo;
 
       if (gcry_cipher_test_algo (algo) && in_fips_mode)
 	{
 	  if (verbose)
 	    fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     algo);
 	  continue;
 	}
 
       if (verbose)
 	fprintf (stderr, "    checking ECB mode for %s [%i]\n",
 		 gcry_cipher_algo_name (algo),
 		 algo);
       err = gcry_cipher_open (&hde, algo, GCRY_CIPHER_MODE_ECB, 0);
       if (!err)
 	err2 = gcry_cipher_open (&hdd, algo, GCRY_CIPHER_MODE_ECB, 0);
       if (err || err2)
 	{
 	  fail ("ecb-algo:%d-tv:%d, gcry_cipher_open failed: %s\n", algo, i,
 		gpg_strerror (err ? err : err2));
 	  if (err2)
 	    gcry_cipher_close (hde);
 	  return;
 	}
 
       for (j = 0; tv[i].data[j].inlen; j++)
 	{
 	  keylen = tv[i].data[j].keylen;
 	  if (!keylen)
 	    {
 	      keylen = gcry_cipher_get_algo_keylen(algo);
 	      if (!keylen)
 		{
 		  fail ("ecb-algo:%d-tv:%d-data:%d, gcry_cipher_get_algo_keylen failed\n",
 			algo, i, j);
 		  gcry_cipher_close (hde);
 		  gcry_cipher_close (hdd);
 		  return;
 		}
 	    }
 
 	  err = gcry_cipher_setkey (hde, tv[i].key, keylen);
 	  if (!err)
 	    err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
 	  if (err)
 	    {
 	      fail ("ecb-algo:%d-tv:%d-data:%d, gcry_cipher_setkey failed: %s\n",
 		    algo, i, j, gpg_strerror (err));
 	      gcry_cipher_close (hde);
 	      gcry_cipher_close (hdd);
 	      return;
 	    }
 
 	  err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
 				     tv[i].data[j].plaintext,
 				     tv[i].data[j].inlen);
 	  if (err)
 	    {
 	      fail ("ecb-algo:%d-tv:%d-data:%d, gcry_cipher_encrypt failed: %s\n",
 		    algo, i, j, gpg_strerror (err));
 	      gcry_cipher_close (hde);
 	      gcry_cipher_close (hdd);
 	      return;
 	    }
 
 	  if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
 	    {
 	      fail ("ecb-algo:%d-tv:%d-data:%d, encrypt mismatch entry\n",
 		    algo, i, j);
 	    }
 
 	  err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
 	  if (err)
 	    {
 	      fail ("ecb-algo:%d-tv:%d-data:%d, gcry_cipher_decrypt failed: %s\n",
 		    algo, i, j, gpg_strerror (err));
 	      gcry_cipher_close (hde);
 	      gcry_cipher_close (hdd);
 	      return;
 	    }
 
 	  if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
 	    {
 	      fail ("ecb-algo:%d-tv:%d-data:%d, decrypt mismatch entry\n",
 		    algo, i, j);
 	    }
 	}
 
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
     }
   if (verbose)
     fprintf (stderr, "  Completed ECB checks.\n");
 }
 
 static void
 check_ctr_cipher (void)
 {
   static const struct tv
   {
     int algo;
     char key[MAX_DATA_LEN];
     char ctr[MAX_DATA_LEN];
     struct data
     {
       unsigned char plaintext[MAX_DATA_LEN];
       int inlen;
       char out[MAX_DATA_LEN];
     } data[8];
   } tv[] =
     {
       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
       {	GCRY_CIPHER_AES,
 	"\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
 	"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
 	{ { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
 	    16,
 	    "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
 	  { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
 	    16,
 	    "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd\xff" },
 	  { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
 	    16,
 	    "\x5a\xe4\xdf\x3e\xdb\xd5\xd3\x5e\x5b\x4f\x09\x02\x0d\xb0\x3e\xab" },
 	  { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
 	    16,
 	    "\x1e\x03\x1d\xda\x2f\xbe\x03\xd1\x79\x21\x70\xa0\xf3\x00\x9c\xee" },
 
           { "", 0, "" }
 	}
       },
       {	GCRY_CIPHER_AES192,
 	"\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
 	"\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
 	"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
 	{ { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
 	    16,
 	    "\x1a\xbc\x93\x24\x17\x52\x1c\xa2\x4f\x2b\x04\x59\xfe\x7e\x6e\x0b" },
 	  { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
 	    16,
 	    "\x09\x03\x39\xec\x0a\xa6\xfa\xef\xd5\xcc\xc2\xc6\xf4\xce\x8e\x94" },
 	  { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
 	    16,
 	    "\x1e\x36\xb2\x6b\xd1\xeb\xc6\x70\xd1\xbd\x1d\x66\x56\x20\xab\xf7" },
 	  { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
 	    16,
 	    "\x4f\x78\xa7\xf6\xd2\x98\x09\x58\x5a\x97\xda\xec\x58\xc6\xb0\x50" },
           { "", 0, "" }
 	}
       },
       {	GCRY_CIPHER_AES256,
 	"\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
 	"\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
 	"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
 	{ { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
 	    16,
 	    "\x60\x1e\xc3\x13\x77\x57\x89\xa5\xb7\xa7\xf5\x04\xbb\xf3\xd2\x28" },
 	  { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
 	    16,
 	    "\xf4\x43\xe3\xca\x4d\x62\xb5\x9a\xca\x84\xe9\x90\xca\xca\xf5\xc5" },
 	  { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
 	    16,
 	    "\x2b\x09\x30\xda\xa2\x3d\xe9\x4c\xe8\x70\x17\xba\x2d\x84\x98\x8d" },
 	  { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
 	    16,
 	    "\xdf\xc9\xc5\x8d\xb6\x7a\xad\xa6\x13\xc2\xdd\x08\x45\x79\x41\xa6" },
           { "", 0, "" }
 	}
       },
       /* Some truncation tests.  With a truncated second block and
          also with a single truncated block.  */
       {	GCRY_CIPHER_AES,
 	"\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
 	"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
 	{{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
           16,
           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e",
           15,
           "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd" },
          {"", 0, "" }
 	}
       },
       {	GCRY_CIPHER_AES,
 	"\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
 	"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
 	{{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
           16,
           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
          {"\xae",
           1,
           "\x98" },
          {"", 0, "" }
 	}
       },
       {	GCRY_CIPHER_AES,
 	"\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
 	"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
 	{{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17",
           15,
           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6" },
          {"", 0, "" }
 	}
       },
       {	GCRY_CIPHER_AES,
 	"\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
 	"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
 	{{"\x6b",
           1,
           "\x87" },
          {"", 0, "" }
 	}
       },
       /* Tests to see whether it works correctly as a stream cipher.  */
       {	GCRY_CIPHER_AES,
 	"\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
 	"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
 	{{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
           16,
           "\x87\x4d\x61\x91\xb6\x20\xe3\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e",
           15,
           "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd" },
          {"\x51\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
           17,
           "\xff\x5a\xe4\xdf\x3e\xdb\xd5\xd3\x5e\x5b\x4f\x09\x02\x0d\xb0\x3e\xab" },
          {"\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
           16,
           "\x1e\x03\x1d\xda\x2f\xbe\x03\xd1\x79\x21\x70\xa0\xf3\x00\x9c\xee" },
 
           { "", 0, "" }
 	}
       },
       {	GCRY_CIPHER_AES,
 	"\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
 	"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
 	{{"\x6b",
           1,
           "\x87" },
 	 {"\xc1\xbe",
           2,
           "\x4d\x61" },
 	 {"\xe2\x2e\x40",
           3,
           "\x91\xb6\x20" },
 	 {"\x9f",
           1,
           "\xe3" },
 	 {"\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
           9,
           "\x26\x1b\xef\x68\x64\x99\x0d\xb6\xce" },
          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e",
           15,
           "\x98\x06\xf6\x6b\x79\x70\xfd\xff\x86\x17\x18\x7b\xb9\xff\xfd" },
          {"\x51\x30\xc8\x1c\x46\xa3\x5c\xe4\x11",
           9,
           "\xff\x5a\xe4\xdf\x3e\xdb\xd5\xd3\x5e" },
 
           { "", 0, "" }
 	}
       },
 #if USE_CAST5
       /* A selfmade test vector using an 64 bit block cipher.  */
       {	GCRY_CIPHER_CAST5,
 	"\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
 	"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8",
         {{"\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
           16,
           "\xe8\xa7\xac\x68\xca\xca\xa0\x20\x10\xcb\x1b\xcc\x79\x2c\xc4\x48" },
          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c",
           8,
           "\x16\xe8\x72\x77\xb0\x98\x29\x68" },
          {"\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
           8,
           "\x9a\xb3\xa8\x03\x3b\xb4\x14\xba" },
          {"\xae\x2d\x8a\x57\x1e\x03\xac\x9c\xa1\x00",
           10,
           "\x31\x5e\xd3\xfb\x1b\x8d\xd1\xf9\xb0\x83" },
          { "", 0, "" }
 	}
       },
 #endif /*USE_CAST5*/
       {	0,
 	"",
 	"",
 	{
          {"", 0, "" }
 	}
       }
     };
   gcry_cipher_hd_t hde, hdd;
   unsigned char out[MAX_DATA_LEN];
   int i, j, keylen, blklen;
   gcry_error_t err = 0;
   size_t taglen2;
 
   if (verbose)
     fprintf (stderr, "  Starting CTR cipher checks.\n");
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       if (!tv[i].algo)
         continue;
 
       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     tv[i].algo);
           continue;
         }
 
       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_CTR, 0);
       if (!err)
 	err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_CTR, 0);
       if (err)
 	{
 	  fail ("aes-ctr, gcry_cipher_open failed: %s\n", gpg_strerror (err));
 	  return;
 	}
 
       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
       if (!keylen)
 	{
 	  fail ("aes-ctr, gcry_cipher_get_algo_keylen failed\n");
 	  return;
 	}
 
       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
       if (!err)
 	err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
       if (err)
 	{
 	  fail ("aes-ctr, gcry_cipher_setkey failed: %s\n",
 		gpg_strerror (err));
 	  gcry_cipher_close (hde);
 	  gcry_cipher_close (hdd);
 	  return;
 	}
 
       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
       if (!blklen)
 	{
 	  fail ("aes-ctr, gcry_cipher_get_algo_blklen failed\n");
 	  return;
 	}
 
       err = gcry_cipher_setctr (hde, tv[i].ctr, blklen);
       if (!err)
 	err = gcry_cipher_setctr (hdd, tv[i].ctr, blklen);
       if (err)
 	{
 	  fail ("aes-ctr, gcry_cipher_setctr failed: %s\n",
 		gpg_strerror (err));
 	  gcry_cipher_close (hde);
 	  gcry_cipher_close (hdd);
 	  return;
 	}
 
 
       err = gcry_cipher_info (hde, GCRYCTL_GET_TAGLEN, NULL, &taglen2);
       if (gpg_err_code (err) != GPG_ERR_INV_CIPHER_MODE)
         {
           fail ("aes-ctr, gcryctl_get_taglen failed to fail (tv %d): %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       if (verbose)
 	fprintf (stderr, "    checking CTR mode for %s [%i]\n",
 		 gcry_cipher_algo_name (tv[i].algo),
 		 tv[i].algo);
       for (j = 0; tv[i].data[j].inlen; j++)
 	{
 	  err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
 				     tv[i].data[j].plaintext,
 				     tv[i].data[j].inlen == -1 ?
 				     strlen ((char*)tv[i].data[j].plaintext) :
 				     tv[i].data[j].inlen);
 	  if (err)
 	    {
 	      fail ("aes-ctr, gcry_cipher_encrypt (%d, %d) failed: %s\n",
 		    i, j, gpg_strerror (err));
 	      gcry_cipher_close (hde);
 	      gcry_cipher_close (hdd);
 	      return;
 	    }
 
 	  if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
             {
               fail ("aes-ctr, encrypt mismatch entry %d:%d\n", i, j);
               mismatch (tv[i].data[j].out, tv[i].data[j].inlen,
                         out, tv[i].data[j].inlen);
             }
 
 	  err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
 	  if (err)
 	    {
 	      fail ("aes-ctr, gcry_cipher_decrypt (%d, %d) failed: %s\n",
 		    i, j, gpg_strerror (err));
 	      gcry_cipher_close (hde);
 	      gcry_cipher_close (hdd);
 	      return;
 	    }
 
 	  if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
             {
               fail ("aes-ctr, decrypt mismatch entry %d:%d\n", i, j);
               mismatch (tv[i].data[j].plaintext, tv[i].data[j].inlen,
                         out, tv[i].data[j].inlen);
             }
 
         }
 
       /* Now check that we get valid return codes back for good and
          bad inputs.  */
       err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
                                  "1234567890123456", 16);
       if (err)
         fail ("aes-ctr, encryption failed for valid input");
 
       err = gcry_cipher_encrypt (hde, out, 15,
                                  "1234567890123456", 16);
       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
         fail ("aes-ctr, too short output buffer returned wrong error: %s\n",
               gpg_strerror (err));
 
       err = gcry_cipher_encrypt (hde, out, 0,
                                  "1234567890123456", 16);
       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
         fail ("aes-ctr, 0 length output buffer returned wrong error: %s\n",
               gpg_strerror (err));
 
       err = gcry_cipher_encrypt (hde, out, 16,
                                  "1234567890123456", 16);
       if (err)
         fail ("aes-ctr, correct length output buffer returned error: %s\n",
               gpg_strerror (err));
 
       /* Again, now for decryption.  */
       err = gcry_cipher_decrypt (hde, out, MAX_DATA_LEN,
                                  "1234567890123456", 16);
       if (err)
         fail ("aes-ctr, decryption failed for valid input");
 
       err = gcry_cipher_decrypt (hde, out, 15,
                                  "1234567890123456", 16);
       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
         fail ("aes-ctr, too short output buffer returned wrong error: %s\n",
               gpg_strerror (err));
 
       err = gcry_cipher_decrypt (hde, out, 0,
                                  "1234567890123456", 16);
       if (gpg_err_code (err) != GPG_ERR_BUFFER_TOO_SHORT)
         fail ("aes-ctr, 0 length output buffer returned wrong error: %s\n",
               gpg_strerror (err));
 
       err = gcry_cipher_decrypt (hde, out, 16,
                                  "1234567890123456", 16);
       if (err)
         fail ("aes-ctr, correct length output buffer returned error: %s\n",
               gpg_strerror (err));
 
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
     }
   if (verbose)
     fprintf (stderr, "  Completed CTR cipher checks.\n");
 }
 
 static void
 check_cfb_cipher (void)
 {
   static const struct tv
   {
     int algo;
     int cfb8;
     char key[MAX_DATA_LEN];
     char iv[MAX_DATA_LEN];
     struct data
     {
       unsigned char plaintext[MAX_DATA_LEN];
       int inlen;
       char out[MAX_DATA_LEN];
     }
     data[MAX_DATA_LEN];
   } tv[] =
     {
       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
       { GCRY_CIPHER_AES, 0,
         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
             16,
             "\x3b\x3f\xd9\x2e\xb7\x2d\xad\x20\x33\x34\x49\xf8\xe8\x3c\xfb\x4a" },
           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
             16,
             "\xc8\xa6\x45\x37\xa0\xb3\xa9\x3f\xcd\xe3\xcd\xad\x9f\x1c\xe5\x8b"},
           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
             16,
             "\x26\x75\x1f\x67\xa3\xcb\xb1\x40\xb1\x80\x8c\xf1\x87\xa4\xf4\xdf" },
           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
             16,
             "\xc0\x4b\x05\x35\x7c\x5d\x1c\x0e\xea\xc4\xc6\x6f\x9f\xf7\xf2\xe6" },
         }
       },
       { GCRY_CIPHER_AES192, 0,
         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
             16,
             "\xcd\xc8\x0d\x6f\xdd\xf1\x8c\xab\x34\xc2\x59\x09\xc9\x9a\x41\x74" },
           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
             16,
             "\x67\xce\x7f\x7f\x81\x17\x36\x21\x96\x1a\x2b\x70\x17\x1d\x3d\x7a" },
           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
             16,
             "\x2e\x1e\x8a\x1d\xd5\x9b\x88\xb1\xc8\xe6\x0f\xed\x1e\xfa\xc4\xc9" },
           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
             16,
             "\xc0\x5f\x9f\x9c\xa9\x83\x4f\xa0\x42\xae\x8f\xba\x58\x4b\x09\xff" },
         }
       },
       { GCRY_CIPHER_AES256, 0,
         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
             16,
             "\xdc\x7e\x84\xbf\xda\x79\x16\x4b\x7e\xcd\x84\x86\x98\x5d\x38\x60" },
           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
             16,
             "\x39\xff\xed\x14\x3b\x28\xb1\xc8\x32\x11\x3c\x63\x31\xe5\x40\x7b" },
           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
             16,
             "\xdf\x10\x13\x24\x15\xe5\x4b\x92\xa1\x3e\xd0\xa8\x26\x7a\xe2\xf9" },
           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
             16,
             "\x75\xa3\x85\x74\x1a\xb9\xce\xf8\x20\x31\x62\x3d\x55\xb1\xe4\x71" }
         }
       },
       { GCRY_CIPHER_AES, 1,
 	"\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
 	"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
 	{ { "\x6b",
 	    1,
 	    "\x3b"},
 	  { "\xc1",
 	    1,
 	    "\x79"},
 	  { "\xbe",
 	    1,
 	    "\x42"},
 	  { "\xe2",
 	    1,
 	    "\x4c"},
 	}
       },
       { GCRY_CIPHER_AES192, 1,
 	"\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b\x80\x90\x79\xe5"
 	"\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
 	"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
 	{ { "\x6b",
 	    1,
 	    "\xcd"},
 	  { "\xc1",
 	    1,
 	    "\xa2"},
 	  { "\xbe",
 	    1,
 	    "\x52"},
 	  { "\xe2",
 	    1,
 	    "\x1e"},
         }
       },
       { GCRY_CIPHER_AES256, 1,
 	"\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
 	"\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
 	"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
 	{ { "\x6b",
 	    1,
 	    "\xdc"},
 	  { "\xc1",
 	    1,
 	    "\x1f"},
 	  { "\xbe",
 	    1,
 	    "\x1a"},
 	  { "\xe2",
 	    1,
 	    "\x85"},
         }
       },
       { GCRY_CIPHER_AES, 1,
 	"\x3a\x6f\x91\x59\x26\x3f\xa6\xce\xf2\xa0\x75\xca\xfa\xce\x58\x17",
 	"\x0f\xc2\x36\x62\xb7\xdb\xf7\x38\x27\xf0\xc7\xde\x32\x1c\xa3\x6e",
 	{ { "\x87\xef\xeb\x8d\x55\x9e\xd3\x36\x77\x28",
 	    10,
 	    "\x8e\x9c\x50\x42\x56\x14\xd5\x40\xce\x11"},
 	}
       },
       { GCRY_CIPHER_AES192, 1,
 	"\x53\x7e\x7b\xf6\x61\xfd\x40\x24\xa0\x24\x61\x3f\x15\xb1\x36\x90"
 	"\xf7\xd0\xc8\x47\xc1\xe1\x89\x65",
 	"\x3a\x81\xf9\xd9\xd3\xc1\x55\xb0\xca\xad\x5d\x73\x34\x94\x76\xfc",
 	{ { "\xd3\xd8\xb9\xb9\x84\xad\xc2\x42\x37\xee",
 	    10,
 	    "\x38\x79\xfe\xa7\x2a\xc9\x99\x29\xe5\x3a"},
 	}
       },
       { GCRY_CIPHER_AES256, 1,
 	"\xeb\xbb\x45\x66\xb5\xe1\x82\xe0\xf0\x72\x46\x6b\x0b\x31\x1d\xf3"
 	"\x8f\x91\x75\xbc\x02\x13\xa5\x53\x0b\xce\x2e\xc4\xd7\x4f\x40\x0d",
 	"\x09\x56\xa4\x8e\x01\x00\x2c\x9e\x16\x37\x6d\x6e\x30\x8d\xba\xd1",
 	{ { "\xb0\xfe\x25\xac\x8d\x3d\x28\xa2\xf4\x71",
 	    10,
 	    "\x63\x8c\x68\x23\xe7\x25\x6f\xb5\x62\x6e"},
 	}
       },
       { GCRY_CIPHER_3DES, 1,
 	"\xe3\x34\x7a\x6b\x0b\xc1\x15\x2c\x64\x2a\x25\xcb\xd3\xbc\x31\xab"
 	"\xfb\xa1\x62\xa8\x1f\x19\x7c\x15",
 	"\xb7\x40\xcc\x21\xe9\x25\xe3\xc8",
 	{ { "\xdb\xe9\x15\xfc\xb3\x3b\xca\x18\xef\x14",
 	    10,
 	    "\xf4\x80\x1a\x8d\x03\x9d\xb4\xca\x8f\xf6"},
 	}
       },
       { GCRY_CIPHER_3DES, 1,
 	"\x7c\xa2\x89\x38\xba\x6b\xec\x1f\xfe\xc7\x8f\x7c\xd6\x97\x61\x94"
 	"\x7c\xa2\x89\x38\xba\x6b\xec\x1f",
 	"\x95\x38\x96\x58\x6e\x49\xd3\x8f",
 	{ { "\x2e\xa9\x56\xd4\xa2\x11\xdb\x68\x59\xb7",
 	    10,
 	    "\xf2\x0e\x53\x66\x74\xa6\x6f\xa7\x38\x05"},
 	}
       },
     };
   gcry_cipher_hd_t hde, hdd;
   unsigned char out[MAX_DATA_LEN];
   int i, j, keylen, blklen, mode;
   gcry_error_t err = 0;
 
   if (verbose)
     fprintf (stderr, "  Starting CFB checks.\n");
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     tv[i].algo);
           continue;
         }
 
       mode = tv[i].cfb8? GCRY_CIPHER_MODE_CFB8 : GCRY_CIPHER_MODE_CFB;
 
       if (verbose)
         fprintf (stderr, "    checking CFB mode for %s [%i]\n",
 		 gcry_cipher_algo_name (tv[i].algo),
 		 tv[i].algo);
       err = gcry_cipher_open (&hde, tv[i].algo, mode, 0);
       if (!err)
         err = gcry_cipher_open (&hdd, tv[i].algo, mode, 0);
       if (err)
         {
           fail ("aes-cfb, gcry_cipher_open failed: %s\n", gpg_strerror (err));
           return;
         }
 
       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
       if (!keylen)
         {
           fail ("aes-cfb, gcry_cipher_get_algo_keylen failed\n");
           return;
         }
 
       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
       if (!err)
         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
       if (err)
         {
           fail ("aes-cfb, gcry_cipher_setkey failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
       if (!blklen)
         {
           fail ("aes-cfb, gcry_cipher_get_algo_blklen failed\n");
           return;
         }
 
       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
       if (!err)
         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
       if (err)
         {
           fail ("aes-cfb, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       for (j = 0; tv[i].data[j].inlen; j++)
         {
           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
                                      tv[i].data[j].plaintext,
                                      tv[i].data[j].inlen);
           if (err)
             {
               fail ("aes-cfb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
                     i, j, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen)) {
             fail ("aes-cfb, encrypt mismatch entry %d:%d\n", i, j);
 	  }
           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
           if (err)
             {
               fail ("aes-cfb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
                     i, j, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
             fail ("aes-cfb, decrypt mismatch entry %d:%d\n", i, j);
         }
 
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
     }
   if (verbose)
     fprintf (stderr, "  Completed CFB checks.\n");
 }
 
 static void
 check_ofb_cipher (void)
 {
   static const struct tv
   {
     int algo;
     char key[MAX_DATA_LEN];
     char iv[MAX_DATA_LEN];
     struct data
     {
       unsigned char plaintext[MAX_DATA_LEN];
       unsigned int inlen;
       char out[MAX_DATA_LEN];
     }
     data[MAX_DATA_LEN];
   } tv[] =
     {
       /* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf */
       { GCRY_CIPHER_AES,
         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
             16,
             "\x3b\x3f\xd9\x2e\xb7\x2d\xad\x20\x33\x34\x49\xf8\xe8\x3c\xfb\x4a" },
           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
             16,
             "\x77\x89\x50\x8d\x16\x91\x8f\x03\xf5\x3c\x52\xda\xc5\x4e\xd8\x25"},
           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
             16,
             "\x97\x40\x05\x1e\x9c\x5f\xec\xf6\x43\x44\xf7\xa8\x22\x60\xed\xcc" },
           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
             16,
             "\x30\x4c\x65\x28\xf6\x59\xc7\x78\x66\xa5\x10\xd9\xc1\xd6\xae\x5e" },
         }
       },
       { GCRY_CIPHER_AES192,
         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b"
         "\x80\x90\x79\xe5\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
             16,
             "\xcd\xc8\x0d\x6f\xdd\xf1\x8c\xab\x34\xc2\x59\x09\xc9\x9a\x41\x74" },
           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
             16,
             "\xfc\xc2\x8b\x8d\x4c\x63\x83\x7c\x09\xe8\x17\x00\xc1\x10\x04\x01" },
           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
             16,
             "\x8d\x9a\x9a\xea\xc0\xf6\x59\x6f\x55\x9c\x6d\x4d\xaf\x59\xa5\xf2" },
           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
             16,
             "\x6d\x9f\x20\x08\x57\xca\x6c\x3e\x9c\xac\x52\x4b\xd9\xac\xc9\x2a" },
         }
       },
       { GCRY_CIPHER_AES256,
         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
         { { "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
             16,
             "\xdc\x7e\x84\xbf\xda\x79\x16\x4b\x7e\xcd\x84\x86\x98\x5d\x38\x60" },
           { "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
             16,
             "\x4f\xeb\xdc\x67\x40\xd2\x0b\x3a\xc8\x8f\x6a\xd8\x2a\x4f\xb0\x8d" },
           { "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef",
             16,
             "\x71\xab\x47\xa0\x86\xe8\x6e\xed\xf3\x9d\x1c\x5b\xba\x97\xc4\x08" },
           { "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
             16,
             "\x01\x26\x14\x1d\x67\xf3\x7b\xe8\x53\x8f\x5a\x8b\xe7\x40\xe4\x84" }
         }
       }
     };
   gcry_cipher_hd_t hde, hdd;
   unsigned char out[MAX_DATA_LEN];
   int i, j, keylen, blklen;
   gcry_error_t err = 0;
 
   if (verbose)
     fprintf (stderr, "  Starting OFB checks.\n");
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     tv[i].algo);
           continue;
         }
 
       if (verbose)
         fprintf (stderr, "    checking OFB mode for %s [%i]\n",
 		 gcry_cipher_algo_name (tv[i].algo),
 		 tv[i].algo);
       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_OFB, 0);
       if (!err)
         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_OFB, 0);
       if (err)
         {
           fail ("aes-ofb, gcry_cipher_open failed: %s\n", gpg_strerror (err));
           return;
         }
 
       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
       if (!keylen)
         {
           fail ("aes-ofb, gcry_cipher_get_algo_keylen failed\n");
           return;
         }
 
       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
       if (!err)
         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
       if (err)
         {
           fail ("aes-ofb, gcry_cipher_setkey failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
       if (!blklen)
         {
           fail ("aes-ofb, gcry_cipher_get_algo_blklen failed\n");
           return;
         }
 
       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
       if (!err)
         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
       if (err)
         {
           fail ("aes-ofb, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       for (j = 0; tv[i].data[j].inlen; j++)
         {
           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
                                      tv[i].data[j].plaintext,
                                      tv[i].data[j].inlen);
           if (err)
             {
               fail ("aes-ofb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
                     i, j, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
             fail ("aes-ofb, encrypt mismatch entry %d:%d\n", i, j);
 
           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
           if (err)
             {
               fail ("aes-ofb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
                     i, j, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
             fail ("aes-ofb, decrypt mismatch entry %d:%d\n", i, j);
         }
 
       err = gcry_cipher_reset(hde);
       if (!err)
 	err = gcry_cipher_reset(hdd);
       if (err)
 	{
 	  fail ("aes-ofb, gcry_cipher_reset (%d, %d) failed: %s\n",
 		i, j, gpg_strerror (err));
 	  gcry_cipher_close (hde);
 	  gcry_cipher_close (hdd);
 	  return;
 	}
 
       /* gcry_cipher_reset clears the IV */
       err = gcry_cipher_setiv (hde, tv[i].iv, blklen);
       if (!err)
         err = gcry_cipher_setiv (hdd, tv[i].iv, blklen);
       if (err)
         {
           fail ("aes-ofb, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       /* this time we encrypt and decrypt one byte at a time */
       for (j = 0; tv[i].data[j].inlen; j++)
         {
 	  int byteNum;
 	  for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
 	    {
 	      err = gcry_cipher_encrypt (hde, out+byteNum, 1,
 					 (tv[i].data[j].plaintext) + byteNum,
 					 1);
 	      if (err)
 		{
 		  fail ("aes-ofb, gcry_cipher_encrypt (%d, %d) failed: %s\n",
 			i, j, gpg_strerror (err));
 		  gcry_cipher_close (hde);
 		  gcry_cipher_close (hdd);
 		  return;
 		}
 	    }
 
           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
             fail ("aes-ofb, encrypt mismatch entry %d:%d\n", i, j);
 
 	  for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
 	    {
 	      err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
 	      if (err)
 		{
 		  fail ("aes-ofb, gcry_cipher_decrypt (%d, %d) failed: %s\n",
 			i, j, gpg_strerror (err));
 		  gcry_cipher_close (hde);
 		  gcry_cipher_close (hdd);
 		  return;
 		}
 	    }
 
           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
             fail ("aes-ofb, decrypt mismatch entry %d:%d\n", i, j);
         }
 
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
     }
   if (verbose)
     fprintf (stderr, "  Completed OFB checks.\n");
 }
 
 static void
 _check_gcm_cipher (unsigned int step)
 {
 #define MAX_GCM_DATA_LEN (256 + 32)
   static const struct tv
   {
     int algo;
     char key[MAX_DATA_LEN];
     char iv[MAX_DATA_LEN];
     int ivlen;
     unsigned char aad[MAX_DATA_LEN];
     int aadlen;
     unsigned char plaintext[MAX_GCM_DATA_LEN];
     int inlen;
     char out[MAX_GCM_DATA_LEN];
     char tag[MAX_DATA_LEN];
     int taglen;
     int should_fail;
   } tv[] =
     {
       /* http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/gcm/gcm-revised-spec.pdf */
       { GCRY_CIPHER_AES,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
         "", 0,
         "",
         0,
         "",
         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57\xa4\xe7\x45\x5a" },
       { GCRY_CIPHER_AES,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
         "", 0,
         "",
         0,
         "",
         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57\xa4\xe7\x45",
         15 },
       { GCRY_CIPHER_AES,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
         "", 0,
         "",
         0,
         "",
         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57\xa4\xe7",
         14 },
       { GCRY_CIPHER_AES,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
         "", 0,
         "",
         0,
         "",
         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57\xa4",
         13 },
       { GCRY_CIPHER_AES,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
         "", 0,
         "",
         0,
         "",
         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d\x57",
         12 },
       { GCRY_CIPHER_AES,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
         "", 0,
         "",
         0,
         "",
         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61\x36\x7f\x1d",
         11, 1 },
       { GCRY_CIPHER_AES,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
         "", 0,
         "",
         0,
         "",
         "\x58\xe2\xfc\xce\xfa\x7e\x30\x61",
         8 },
       { GCRY_CIPHER_AES,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
         "", 0,
         "",
         0,
         "",
         "\x58\xe2\xfc\xce",
         4 },
       { GCRY_CIPHER_AES,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
         "", 0,
         "",
         0,
         "",
         "\x58",
         1, 1 },
       { GCRY_CIPHER_AES,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         16,
         "\x03\x88\xda\xce\x60\xb6\xa3\x92\xf3\x28\xc2\xb9\x71\xb2\xfe\x78",
         "\xab\x6e\x47\xd4\x2c\xec\x13\xbd\xf5\x3a\x67\xb2\x12\x57\xbd\xdf" },
       { GCRY_CIPHER_AES,
         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08",
         "\xca\xfe\xba\xbe\xfa\xce\xdb\xad\xde\xca\xf8\x88", 12,
         "", 0,
         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39\x1a\xaf\xd2\x55",
         64,
         "\x42\x83\x1e\xc2\x21\x77\x74\x24\x4b\x72\x21\xb7\x84\xd0\xd4\x9c"
         "\xe3\xaa\x21\x2f\x2c\x02\xa4\xe0\x35\xc1\x7e\x23\x29\xac\xa1\x2e"
         "\x21\xd5\x14\xb2\x54\x66\x93\x1c\x7d\x8f\x6a\x5a\xac\x84\xaa\x05"
         "\x1b\xa3\x0b\x39\x6a\x0a\xac\x97\x3d\x58\xe0\x91\x47\x3f\x59\x85",
         "\x4d\x5c\x2a\xf3\x27\xcd\x64\xa6\x2c\xf3\x5a\xbd\x2b\xa6\xfa\xb4" },
       { GCRY_CIPHER_AES,
         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08",
         "\xca\xfe\xba\xbe\xfa\xce\xdb\xad\xde\xca\xf8\x88", 12,
         "\xfe\xed\xfa\xce\xde\xad\xbe\xef\xfe\xed\xfa\xce\xde\xad\xbe\xef"
         "\xab\xad\xda\xd2", 20,
         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39",
         60,
         "\x42\x83\x1e\xc2\x21\x77\x74\x24\x4b\x72\x21\xb7\x84\xd0\xd4\x9c"
         "\xe3\xaa\x21\x2f\x2c\x02\xa4\xe0\x35\xc1\x7e\x23\x29\xac\xa1\x2e"
         "\x21\xd5\x14\xb2\x54\x66\x93\x1c\x7d\x8f\x6a\x5a\xac\x84\xaa\x05"
         "\x1b\xa3\x0b\x39\x6a\x0a\xac\x97\x3d\x58\xe0\x91\x47\x3f\x59\x85",
         "\x5b\xc9\x4f\xbc\x32\x21\xa5\xdb\x94\xfa\xe9\x5a\xe7\x12\x1a\x47" },
       { GCRY_CIPHER_AES,
         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08",
         "\xca\xfe\xba\xbe\xfa\xce\xdb\xad", 8,
         "\xfe\xed\xfa\xce\xde\xad\xbe\xef\xfe\xed\xfa\xce\xde\xad\xbe\xef"
         "\xab\xad\xda\xd2", 20,
         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39",
         60,
         "\x61\x35\x3b\x4c\x28\x06\x93\x4a\x77\x7f\xf5\x1f\xa2\x2a\x47\x55"
         "\x69\x9b\x2a\x71\x4f\xcd\xc6\xf8\x37\x66\xe5\xf9\x7b\x6c\x74\x23"
         "\x73\x80\x69\x00\xe4\x9f\x24\xb2\x2b\x09\x75\x44\xd4\x89\x6b\x42"
         "\x49\x89\xb5\xe1\xeb\xac\x0f\x07\xc2\x3f\x45\x98",
         "\x36\x12\xd2\xe7\x9e\x3b\x07\x85\x56\x1b\xe1\x4a\xac\xa2\xfc\xcb" },
       { GCRY_CIPHER_AES,
         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08",
         "\x93\x13\x22\x5d\xf8\x84\x06\xe5\x55\x90\x9c\x5a\xff\x52\x69\xaa"
         "\x6a\x7a\x95\x38\x53\x4f\x7d\xa1\xe4\xc3\x03\xd2\xa3\x18\xa7\x28"
         "\xc3\xc0\xc9\x51\x56\x80\x95\x39\xfc\xf0\xe2\x42\x9a\x6b\x52\x54"
         "\x16\xae\xdb\xf5\xa0\xde\x6a\x57\xa6\x37\xb3\x9b", 60,
         "\xfe\xed\xfa\xce\xde\xad\xbe\xef\xfe\xed\xfa\xce\xde\xad\xbe\xef"
         "\xab\xad\xda\xd2", 20,
         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39",
         60,
         "\x8c\xe2\x49\x98\x62\x56\x15\xb6\x03\xa0\x33\xac\xa1\x3f\xb8\x94"
         "\xbe\x91\x12\xa5\xc3\xa2\x11\xa8\xba\x26\x2a\x3c\xca\x7e\x2c\xa7"
         "\x01\xe4\xa9\xa4\xfb\xa4\x3c\x90\xcc\xdc\xb2\x81\xd4\x8c\x7c\x6f"
         "\xd6\x28\x75\xd2\xac\xa4\x17\x03\x4c\x34\xae\xe5",
         "\x61\x9c\xc5\xae\xff\xfe\x0b\xfa\x46\x2a\xf4\x3c\x16\x99\xd0\x50" },
       { GCRY_CIPHER_AES192,
         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08"
         "\xfe\xff\xe9\x92\x86\x65\x73\x1c",
         "\x93\x13\x22\x5d\xf8\x84\x06\xe5\x55\x90\x9c\x5a\xff\x52\x69\xaa"
         "\x6a\x7a\x95\x38\x53\x4f\x7d\xa1\xe4\xc3\x03\xd2\xa3\x18\xa7\x28"
         "\xc3\xc0\xc9\x51\x56\x80\x95\x39\xfc\xf0\xe2\x42\x9a\x6b\x52\x54"
         "\x16\xae\xdb\xf5\xa0\xde\x6a\x57\xa6\x37\xb3\x9b", 60,
         "\xfe\xed\xfa\xce\xde\xad\xbe\xef\xfe\xed\xfa\xce\xde\xad\xbe\xef"
         "\xab\xad\xda\xd2", 20,
         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39",
         60,
         "\xd2\x7e\x88\x68\x1c\xe3\x24\x3c\x48\x30\x16\x5a\x8f\xdc\xf9\xff"
         "\x1d\xe9\xa1\xd8\xe6\xb4\x47\xef\x6e\xf7\xb7\x98\x28\x66\x6e\x45"
         "\x81\xe7\x90\x12\xaf\x34\xdd\xd9\xe2\xf0\x37\x58\x9b\x29\x2d\xb3"
         "\xe6\x7c\x03\x67\x45\xfa\x22\xe7\xe9\xb7\x37\x3b",
         "\xdc\xf5\x66\xff\x29\x1c\x25\xbb\xb8\x56\x8f\xc3\xd3\x76\xa6\xd9" },
       { GCRY_CIPHER_AES256,
         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08"
         "\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08",
         "\x93\x13\x22\x5d\xf8\x84\x06\xe5\x55\x90\x9c\x5a\xff\x52\x69\xaa"
         "\x6a\x7a\x95\x38\x53\x4f\x7d\xa1\xe4\xc3\x03\xd2\xa3\x18\xa7\x28"
         "\xc3\xc0\xc9\x51\x56\x80\x95\x39\xfc\xf0\xe2\x42\x9a\x6b\x52\x54"
         "\x16\xae\xdb\xf5\xa0\xde\x6a\x57\xa6\x37\xb3\x9b", 60,
         "\xfe\xed\xfa\xce\xde\xad\xbe\xef\xfe\xed\xfa\xce\xde\xad\xbe\xef"
         "\xab\xad\xda\xd2", 20,
         "\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a"
         "\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72"
         "\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25"
         "\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39",
         60,
         "\x5a\x8d\xef\x2f\x0c\x9e\x53\xf1\xf7\x5d\x78\x53\x65\x9e\x2a\x20"
         "\xee\xb2\xb2\x2a\xaf\xde\x64\x19\xa0\x58\xab\x4f\x6f\x74\x6b\xf4"
         "\x0f\xc0\xc3\xb7\x80\xf2\x44\x45\x2d\xa3\xeb\xf1\xc5\xd8\x2c\xde"
         "\xa2\x41\x89\x97\x20\x0e\xf8\x2e\x44\xae\x7e\x3f",
         "\xa4\x4a\x82\x66\xee\x1c\x8e\xb0\xc8\xb5\xd4\xcf\x5a\xe9\xf1\x9a" },
       /* Test vectors for overflowing CTR. */
       /* After setiv, ctr_low: 0xffffffff */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\xdd\x40\xe7",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\x7d\x6e\x38\xfd\xd0\x04\x9d\x28\xdf\x4a\x10\x3f\xa3\x9e\xf8\xf8"
         "\x6c\x2c\x10\xa7\x91\xab\xc0\x86\xd4\x6d\x69\xea\x58\xc4\xf9\xc0"
         "\xd4\xee\xc2\xb0\x9d\x36\xae\xe7\xc9\xa9\x1f\x71\xa8\xee\xa2\x1d"
         "\x20\xfd\x79\xc7\xd9\xc4\x90\x51\x38\x97\xb6\x9f\x55\xea\xf3\xf0"
         "\x78\xb4\xd3\x8c\xa9\x9b\x32\x7d\x19\x36\x96\xbc\x8e\xab\x80\x9f"
         "\x61\x56\xcc\xbd\x3a\x80\xc6\x69\x37\x0a\x89\x89\x21\x82\xb7\x79"
         "\x6d\xe9\xb4\x34\xc4\x31\xe0\xbe\x71\xad\xf3\x50\x05\xb2\x61\xab"
         "\xb3\x1a\x80\x57\xcf\xe1\x11\x26\xcb\xa9\xd1\xf6\x58\x46\xf1\x69"
         "\xa2\xb8\x42\x3c\xe8\x28\x13\xca\x58\xd9\x28\x99\xf8\xc8\x17\x32"
         "\x4a\xf9\xb3\x4c\x7a\x47\xad\xe4\x77\x64\xec\x70\xa1\x01\x0b\x88"
         "\xe7\x30\x0b\xbd\x66\x25\x39\x1e\x51\x67\xee\xec\xdf\xb8\x24\x5d"
         "\x7f\xcb\xee\x7a\x4e\xa9\x93\xf0\xa1\x84\x7b\xfe\x5a\xe3\x86\xb2"
         "\xfb\xcd\x39\xe7\x1e\x5e\x48\x65\x4b\x50\x2b\x4a\x99\x46\x3f\x6f"
         "\xdb\xd9\x97\xdb\xe5\x6d\xa4\xdd\x6c\x18\x64\x5e\xae\x7e\x2c\xd3"
         "\xb4\xf3\x57\x5c\xb5\xf8\x7f\xe5\x87\xb5\x35\xdb\x80\x38\x6e\x2c"
         "\x5c\xdd\xeb\x7c\x63\xac\xe4\xb5\x5a\x6a\x40\x6d\x72\x69\x9a\xa9"
         "\x8f\x5e\x93\x91\x4d\xce\xeb\x87\xf5\x25\xed\x75\x6b\x3b\x1a\xf2"
         "\x0c\xd2\xa4\x10\x45\xd2\x87\xae\x29\x6d\xeb\xea\x66\x5f\xa0\xc2",
         "\x8c\x22\xe3\xda\x9d\x94\x8a\xbe\x8a\xbc\x55\x2c\x94\x63\x44\x40" },
       /* After setiv, ctr_low: 0xfffffffe */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\xd1\xc1\xdf",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\xac\x6a\x10\x3f\xe2\x8d\xed\x27\x55\x14\xca\x1f\x03\x67\x0a\xa8"
         "\xa1\x07\xbf\x00\x73\x5b\x64\xef\xac\x30\x83\x81\x48\x4c\xaa\xd5"
         "\xff\xca\xef\x2f\x77\xbe\xfe\x1b\x20\x5c\x86\x19\xc7\xf9\x11\x99"
         "\x27\xc5\x57\xa7\x0a\xc2\xa8\x05\xd9\x07\x2b\xb9\x38\xa4\xef\x58"
         "\x92\x74\xcf\x89\xc7\xba\xfc\xb9\x70\xac\x86\xe2\x31\xba\x7c\xf9"
         "\xc4\xe2\xe0\x4c\x1b\xe4\x3f\x75\x83\x5c\x40\x0e\xa4\x13\x8b\x04"
         "\x60\x78\x57\x29\xbb\xe6\x61\x93\xe3\x16\xf9\x58\x07\x75\xd0\x96"
         "\xfb\x8f\x6d\x1e\x49\x0f\xd5\x31\x9e\xee\x31\xe6\x0a\x85\x93\x49"
         "\x22\xcf\xd6\x1b\x40\x44\x63\x9c\x95\xaf\xf0\x44\x23\x51\x37\x92"
         "\x0d\xa0\x22\x37\xb9\x6d\x13\xf9\x78\xba\x27\x27\xed\x08\x7e\x35"
         "\xe4\xe2\x28\xeb\x0e\xbe\x3d\xce\x89\x93\x35\x84\x0f\xa0\xf9\x8d"
         "\x94\xe9\x5a\xec\xd4\x0d\x1f\x5c\xbe\x6f\x8e\x6a\x4d\x10\x65\xbb"
         "\xc7\x0b\xa0\xd5\x5c\x20\x80\x0b\x4a\x43\xa6\xe1\xb0\xe0\x56\x6a"
         "\xde\x90\xe0\x6a\x45\xe7\xc2\xd2\x69\x9b\xc6\x62\x11\xe3\x2b\xa5"
         "\x45\x98\xb0\x80\xd3\x57\x4d\x1f\x09\x83\x58\xd4\x4d\xa6\xc5\x95"
         "\x87\x59\xb0\x58\x6c\x81\x49\xc5\x95\x18\x23\x1b\x6f\x10\x86\xa2"
         "\xd9\x56\x19\x30\xec\xd3\x4a\x4b\xe8\x1c\x11\x37\xfb\x31\x60\x4d"
         "\x4f\x9b\xc4\x95\xba\xda\x49\x43\x6c\xc7\x3d\x5b\x13\xf9\x91\xf8",
         "\xcd\x2b\x83\xd5\x5b\x5a\x8e\x0b\x2e\x77\x0d\x97\xbf\xf7\xaa\xab" },
       /* After setiv, ctr_low: 0xfffffffd */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x8c\x18\x92",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\x3d\x6f\x4e\xf6\xd2\x6f\x4e\xce\xa6\xb4\x4a\x9e\xcb\x57\x13\x90"
         "\x51\x3b\xf6\xb2\x40\x55\x0c\x2c\xa2\x85\x44\x72\xf2\x90\xaf\x6b"
         "\x86\x8c\x75\x2a\x9c\xd6\x52\x50\xee\xc6\x5f\x59\xbc\x8d\x18\xd7"
         "\x87\xa5\x7f\xa0\x13\xd1\x5d\x54\x77\x30\xe2\x5d\x1b\x4f\x87\x9f"
         "\x3a\x41\xcb\x6a\xdf\x44\x4f\xa2\x1a\xbc\xfb\x4b\x16\x67\xed\x59"
         "\x65\xf0\x77\x48\xca\xfd\xf0\xb6\x90\x65\xca\x23\x09\xca\x83\x43"
         "\x8f\xf0\x78\xb4\x5f\x96\x2a\xfd\x29\xae\xda\x62\x85\xc5\x87\x4b"
         "\x2a\x3f\xba\xbe\x15\x5e\xb0\x4e\x8e\xe7\x66\xae\xb4\x80\x66\x90"
         "\x10\x9d\x81\xb9\x64\xd3\x36\x00\xb2\x95\xa8\x7d\xaf\x54\xf8\xbd"
         "\x8f\x7a\xb1\xa1\xde\x09\x0d\x10\xc8\x8e\x1e\x18\x2c\x1e\x73\x71"
         "\x2f\x1e\xfd\x16\x6e\xbe\xe1\x3e\xe5\xb4\xb5\xbf\x03\x63\xf4\x5a"
         "\x0d\xeb\xff\xe0\x61\x80\x67\x51\xb4\xa3\x1f\x18\xa5\xa9\xf1\x9a"
         "\xeb\x2a\x7f\x56\xb6\x01\x88\x82\x78\xdb\xec\xb7\x92\xfd\xef\x56"
         "\x55\xd3\x72\x35\xcd\xa4\x0d\x19\x6a\xb6\x79\x91\xd5\xcb\x0e\x3b"
         "\xfb\xea\xa3\x55\x9f\x77\xfb\x75\xc2\x3e\x09\x02\x73\x7a\xff\x0e"
         "\xa5\xf0\x83\x11\xeb\xe7\xff\x3b\xd0\xfd\x7a\x07\x53\x63\x43\x89"
         "\xf5\x7b\xc4\x7d\x3b\x2c\x9b\xca\x1c\xf6\xb2\xab\x13\xf5\xc4\x2a"
         "\xbf\x46\x77\x3b\x09\xdd\xd1\x80\xef\x55\x11\x3e\xd8\xe4\x42\x22",
         "\xa3\x86\xa1\x5f\xe3\x4f\x3b\xed\x12\x23\xeb\x5c\xb8\x0c\xad\x4a" },
       /* After setiv, ctr_low: 0xfffffffc */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\xc8\xc3\xaf",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\x33\x5f\xdc\x8d\x5d\x77\x7b\x78\xc1\x5b\x7b\xb3\xd9\x08\x9a\x0c"
         "\xce\x63\x4e\xef\x19\xf8\x8c\x7a\xcb\x31\x39\x93\x69\x7a\x2c\x97"
         "\x3a\xb4\x52\x45\x9e\x7b\x78\xbc\xa9\xad\x54\x7f\x88\xa6\xae\xd5"
         "\xc0\x8b\x7a\xe4\x23\x6b\xb2\x29\x98\xea\x25\x7a\xae\x11\x0c\xc9"
         "\xf3\x77\xa1\x74\x82\xde\x0c\xec\x68\xce\x94\xfd\xb0\xa0\xc5\x32"
         "\xd6\xbb\xc3\xe7\xed\x3c\x6f\x0b\x53\x9d\xf3\xc8\xeb\x4e\xee\x99"
         "\x19\xc7\x16\xd1\xa5\x59\x1d\xa9\xd3\xe6\x43\x52\x74\x61\x28\xe6"
         "\xac\xd8\x47\x63\xc2\xb7\x53\x39\xc1\x9a\xb0\xa3\xa4\x26\x14\xd0"
         "\x88\xa9\x8c\xc5\x6d\xe9\x21\x7c\xb9\xa5\xab\x67\xe3\x8d\xe9\x1d"
         "\xe3\x1c\x7b\xcd\xa4\x12\x0c\xd7\xa6\x5d\x41\xcf\xdd\x3d\xfc\xbc"
         "\x2a\xbb\xa2\x7a\x9c\x4b\x3a\x42\x6c\x98\x1d\x50\x99\x9c\xfb\xda"
         "\x21\x09\x2a\x31\xff\x05\xeb\xa5\xf1\xba\x65\x78\xbe\x15\x8e\x84"
         "\x35\xdd\x45\x29\xcc\xcd\x32\x2d\x27\xe9\xa8\x94\x4b\x16\x16\xcc"
         "\xab\xf2\xec\xfb\xa0\xb5\x9d\x39\x81\x3e\xec\x5e\x3d\x13\xd1\x83"
         "\x04\x79\x2d\xbb\x2c\x76\x76\x93\x28\x77\x27\x13\xdd\x1d\x3e\x89"
         "\x3e\x37\x46\x4c\xb8\x34\xbe\xbf\x9f\x4f\x9f\x37\xff\x0c\xe6\x14"
         "\x14\x66\x52\x41\x18\xa9\x39\x2b\x0c\xe5\x44\x04\xb0\x93\x06\x64"
         "\x67\xf7\xa0\x19\xa7\x61\xcf\x03\x7b\xcb\xc8\xb3\x88\x28\xe4\xe7",
         "\xe6\xe8\x0a\xe3\x72\xfc\xe0\x07\x69\x09\xf2\xeb\xbc\xc8\x6a\xf0" },
       /* After setiv, ctr_low: 0xfffffffb */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x95\x1a\xe2",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\xd8\x32\x5a\xe3\x55\x8e\xb3\xc2\x51\x84\x2b\x09\x01\x5e\x6c\xfb"
         "\x4a\xc4\x88\xa0\x33\xe7\x3e\xbf\xe5\x7c\xd2\x00\x4c\x1a\x85\x32"
         "\x34\xec\x38\x9d\x18\x5f\xf1\x50\x61\x82\xee\xf3\x84\x5a\x84\x4e"
         "\xeb\x29\x08\x4c\x7b\xb5\x27\xec\x7d\x79\x77\xd7\xa1\x68\x91\x32"
         "\x2d\xf3\x38\xa9\xd6\x27\x16\xfb\x7d\x8b\x09\x5e\xcf\x1b\x74\x6d"
         "\xcf\x51\x91\x91\xa1\xe7\x40\x19\x43\x7b\x0d\xa5\xa9\xa5\xf4\x2e"
         "\x7f\x1c\xc7\xba\xa2\xea\x00\xdd\x24\x01\xa8\x66\x1e\x88\xf1\xf6"
         "\x0c\x9a\xd6\x2b\xda\x3f\x3e\xb2\x98\xea\x89\xc7\xc6\x63\x27\xb7"
         "\x6a\x48\x9a\xee\x1e\x70\xa0\xc8\xec\x3d\xc3\x3e\xb5\xf0\xc2\xb1"
         "\xb9\x71\x1a\x69\x9d\xdd\x72\x1e\xfe\x72\xa0\x21\xb8\x9f\x18\x96"
         "\x26\xcf\x89\x2e\x92\xf1\x02\x65\xa5\xb4\x2e\xb7\x4e\x12\xbd\xa0"
         "\x48\xbe\xf6\x5c\xef\x7e\xf3\x0a\xcf\x9d\x1f\x1e\x14\x70\x3e\xa0"
         "\x01\x0f\x14\xbf\x38\x10\x3a\x3f\x3f\xc2\x76\xe0\xb0\xe0\x7c\xc6"
         "\x77\x6d\x7f\x69\x8e\xa0\x4b\x00\xc3\x9d\xf9\x0b\x7f\x8a\x8e\xd3"
         "\x17\x58\x40\xfe\xaf\xf4\x16\x3a\x65\xff\xce\x85\xbb\x80\xfa\xb8"
         "\x34\xc9\xef\x3a\xdd\x04\x46\xca\x8f\x70\x48\xbc\x1c\x71\x4d\x6a"
         "\x17\x30\x32\x87\x2e\x2e\x54\x9e\x3f\x15\xed\x17\xd7\xa1\xcf\x6c"
         "\x5d\x0f\x3c\xee\xf5\x96\xf1\x8f\x68\x1c\xbc\x27\xdc\x10\x3c\x3c",
         "\x8c\x31\x06\xbb\xf8\x18\x2d\x9d\xd1\x0d\x03\x56\x2b\x28\x25\x9b" },
       /* After setiv, ctr_low: 0xfffffffa */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x99\x9b\xda",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\x7a\x74\x57\xe7\xc1\xb8\x7e\xcf\x91\x98\xf4\x1a\xa4\xdb\x4d\x2c"
         "\x6e\xdc\x05\x0b\xd1\x16\xdf\x25\xa8\x1e\x42\xa6\xf9\x09\x36\xfb"
         "\x02\x8a\x10\x7d\xa1\x07\x88\x40\xb7\x41\xfd\x64\xf6\xe3\x92\x20"
         "\xfd\xc9\xde\xbd\x88\x46\xd3\x1f\x20\x14\x73\x86\x09\xb6\x68\x61"
         "\x64\x90\xda\x24\xa8\x0f\x6a\x10\xc5\x01\xbf\x52\x8a\xee\x23\x44"
         "\xd5\xb0\xd8\x68\x5e\x77\xc3\x62\xed\xcb\x3c\x1b\x0c\x1f\x13\x92"
         "\x2c\x74\x6d\xee\x40\x1b\x6b\xfe\xbe\x3c\xb8\x02\xdd\x24\x9d\xd3"
         "\x3d\x4e\xd3\x9b\x18\xfd\xd6\x8f\x95\xef\xa3\xbf\xa9\x2f\x33\xa8"
         "\xc2\x37\x69\x58\x92\x42\x3a\x30\x46\x12\x1b\x2c\x04\xf0\xbf\xa9"
         "\x79\x55\xcd\xac\x45\x36\x79\xc0\xb4\xb2\x5f\x82\x88\x49\xe8\xa3"
         "\xbf\x33\x41\x7a\xcb\xc4\x11\x0e\xcc\x61\xed\xd1\x6b\x59\x5f\x9d"
         "\x20\x6f\x85\x01\xd0\x16\x2a\x51\x1b\x79\x35\x42\x5e\x49\xdf\x6f"
         "\x64\x68\x31\xac\x49\x34\xfb\x2b\xbd\xb1\xd9\x12\x4e\x4b\x16\xc5"
         "\xa6\xfe\x15\xd3\xaf\xac\x51\x08\x95\x1f\x8c\xd2\x52\x37\x8b\x88"
         "\xf3\x20\xe2\xf7\x09\x55\x82\x83\x1c\x38\x5f\x17\xfc\x37\x26\x21"
         "\xb8\xf1\xfe\xa9\xac\x54\x1e\x53\x83\x53\x3f\x43\xe4\x67\x22\xd5"
         "\x86\xec\xf2\xb6\x4a\x8b\x8a\x66\xea\xe0\x92\x50\x3b\x51\xe4\x00"
         "\x25\x2a\x7a\x64\x14\xd6\x09\xe1\x6c\x75\x32\x28\x53\x5e\xb3\xab",
         "\x5d\x4b\xb2\x8f\xfe\xa5\x7f\x01\x6d\x78\x6c\x13\x58\x08\xe4\x94" },
       /* After setiv, ctr_low: 0xfffffff9 */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\xc4\x42\x97",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\xf5\xc1\xed\xb8\x7f\x55\x7b\xb5\x47\xed\xaa\x42\xd2\xda\x33\x41"
         "\x4a\xe0\x36\x6d\x51\x28\x40\x9c\x35\xfb\x11\x65\x18\x83\x9c\xb5"
         "\x02\xb2\xa7\xe5\x52\x27\xa4\xe8\x57\x3d\xb3\xf5\xea\xcb\x21\x07"
         "\x67\xbe\xbe\x0f\xf6\xaa\x32\xa1\x4b\x5e\x79\x4f\x50\x67\xcd\x80"
         "\xfc\xf1\x65\xf2\x6c\xd0\xdb\x17\xcc\xf9\x52\x93\xfd\x5e\xa6\xb9"
         "\x5c\x9f\xa8\xc6\x36\xb7\x80\x80\x6a\xea\x62\xdc\x61\x13\x45\xbe"
         "\xab\x8f\xd8\x99\x17\x51\x9b\x29\x04\x6e\xdb\x3e\x9f\x83\xc6\x35"
         "\xb3\x90\xce\xcc\x74\xec\xcb\x04\x41\xac\xb1\x92\xde\x20\xb1\x67"
         "\xb0\x38\x14\xaa\x7d\xee\x3c\xb2\xd3\xbb\x2f\x88\x0b\x73\xcf\x7b"
         "\x69\xc1\x55\x5b\x2b\xf2\xd4\x38\x2b\x3c\xef\x04\xc9\x14\x7c\x31"
         "\xd6\x61\x88\xa8\xb3\x8c\x69\xb4\xbc\xaa\x0d\x15\xd2\xd5\x27\x63"
         "\xc4\xa4\x80\xe9\x2b\xe9\xd2\x34\xc9\x0e\x3f\x7b\xd3\x43\x0d\x47"
         "\x5d\x37\x8e\x42\xa4\x4e\xef\xcd\xbb\x3a\x5b\xa4\xe1\xb0\x8d\x64"
         "\xb7\x0b\x58\x52\xec\x55\xd0\xef\x23\xfe\xf2\x8d\xe0\xd1\x6a\x2c"
         "\xaa\x1c\x03\xc7\x3e\x58\x4c\x61\x72\x07\xc6\xfd\x0e\xbc\xd4\x6b"
         "\x99\x4f\x91\xda\xff\x6f\xea\x81\x0c\x76\x85\x5d\x0c\x7f\x1c\xb8"
         "\x84\x8c\x2f\xe1\x36\x3e\x68\xa0\x57\xf5\xdf\x13\x0a\xd6\xe1\xcd"
         "\xae\x23\x99\x4e\xed\x7a\x72\x1b\x7c\xe5\x65\xd1\xb7\xcf\x2f\x73",
         "\x1e\x2f\xcf\x3c\x95\x9a\x29\xec\xd3\x37\x90\x8c\x84\x8a\xfb\x95" },
       /* After setiv, ctr_low: 0xfffffff8 */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\xfa\xc7\x4f",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\x14\x33\xc6\x9d\x04\xd3\x48\x29\x0c\x6a\x24\x27\xdf\x5f\x0a\xd2"
         "\x71\xd6\xd0\x18\x04\xc0\x9f\x72\x0a\x60\xb7\x10\x52\x56\xf7\xae"
         "\x64\xb0\x28\xd4\xfd\x25\x93\x8e\x67\x7e\xac\xc2\x93\xc7\x54\x2e"
         "\x82\x93\x88\x6a\xb9\x8b\x73\xbc\x88\xec\x27\xdd\x4f\x9b\x21\x9e"
         "\x77\x98\x70\x0b\xf4\xd8\x55\xfe\xf4\xc3\x3a\xcb\xca\x3a\xfb\xd4"
         "\x52\x72\x2f\xf8\xac\xa9\x6a\xf5\x13\xab\x7a\x2e\x9f\x52\x41\xbd"
         "\x87\x90\x68\xad\x17\xbd\x5a\xff\xc3\xc6\x10\x4d\xc1\xfe\xfc\x72"
         "\x21\xb5\x53\x4a\x3f\xe0\x15\x9f\x29\x36\x23\xc0\x9a\x31\xb2\x0f"
         "\xcd\x2f\xa6\xd0\xfc\xe6\x4d\xed\x68\xb3\x3d\x26\x67\xab\x40\xf0"
         "\xab\xcf\x72\xc0\x50\xb1\x1e\x86\x38\xe2\xe0\x46\x3a\x2e\x3e\x1d"
         "\x07\xd6\x9d\xe8\xfc\xa3\xe7\xac\xc9\xa0\xb3\x22\x05\xbc\xbf\xd2"
         "\x63\x44\x66\xfc\xb4\x7b\xb4\x70\x7e\x96\xa9\x16\x1b\xb2\x7d\x93"
         "\x44\x92\x5e\xbd\x16\x34\xa7\x11\xd0\xdf\x52\xad\x6f\xbd\x23\x3c"
         "\x3d\x58\x16\xaf\x99\x8b\xbb\xa0\xdc\x3a\xff\x17\xda\x56\xba\x77"
         "\xae\xc4\xb1\x51\xe2\x61\x4f\xf0\x66\x1b\x4c\xac\x79\x34\x1c\xfd"
         "\x6c\x5f\x9a\x2c\x60\xfc\x47\x00\x5f\x2d\x81\xcc\xa9\xdd\x2b\xf4"
         "\x5b\x53\x44\x61\xd4\x13\x5a\xf3\x93\xf0\xc9\x24\xd4\xe6\x60\x6f"
         "\x78\x02\x0c\x75\x9d\x0d\x23\x97\x35\xe2\x06\x8a\x49\x5e\xe5\xbe",
         "\x23\xc0\x4a\x2f\x98\x93\xca\xbd\x2e\x44\xde\x05\xcc\xe7\xf1\xf5" },
       /* After setiv, ctr_low: 0xfffffff7 */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\xa7\x1e\x02",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\x51\x51\x64\x89\xeb\x9f\xf9\xd6\xb1\xa6\x73\x5f\xf1\x62\xb5\xe4"
         "\x00\x80\xdb\x4c\x1c\xce\xe5\x00\xeb\xea\x6c\x57\xe4\x27\xfc\x71"
         "\x08\x8c\xa1\xfc\x59\x1d\x07\x45\x3c\xc9\x4e\x0f\xb6\xea\x96\x90"
         "\xae\xf7\x81\x1e\x7e\x6c\x5e\x50\xaf\x34\x3e\xa0\x55\x59\x8e\xe7"
         "\xc1\xba\x48\xfa\x9e\x07\xf6\x6a\x24\x54\x3e\x9b\xa5\xfe\x31\x16"
         "\x3d\x4d\x9c\xc4\xe1\xec\x26\xa0\x8b\x59\xa6\xf3\x94\xf8\x88\xda"
         "\x1f\x88\x23\x5f\xfb\xfd\x79\xa2\xd3\x62\x30\x66\x69\xd9\x0d\x05"
         "\xc0\x75\x4c\xb8\x48\x34\x1d\x97\xcf\x29\x6a\x12\x1c\x26\x54\x1d"
         "\x80\xa9\x06\x74\x86\xff\xc6\xb4\x72\xee\x34\xe2\x56\x06\x6c\xf5"
         "\x11\xe7\x26\x71\x47\x6b\x05\xbd\xe4\x0b\x40\x78\x84\x3c\xf9\xf2"
         "\x78\x34\x2b\x3c\x5f\x0e\x4c\xfb\x17\x39\xdc\x59\x6b\xd1\x56\xac"
         "\xe4\x1f\xb9\x19\xbc\xec\xb1\xd0\x6d\x47\x3b\x37\x4d\x0d\x6b\x65"
         "\x7c\x70\xe9\xec\x58\xcc\x09\xd4\xd9\xbf\x9f\xe0\x6c\x7f\x60\x28"
         "\xd8\xdf\x8e\xd1\x6a\x73\x42\xf3\x50\x01\x79\x68\x41\xc3\xba\x19"
         "\x1e\x2d\x30\xc2\x81\x2c\x9f\x11\x8b\xd0\xdc\x31\x3b\x01\xfe\x53"
         "\xa5\x11\x13\x22\x89\x40\xb9\x1b\x12\x89\xef\x9a\xcb\xa8\x03\x4f"
         "\x54\x1a\x15\x6d\x11\xba\x05\x09\xd3\xdb\xbf\x05\x42\x3a\x5a\x27"
         "\x3b\x34\x5c\x58\x8a\x5c\xa4\xc2\x28\xdc\xb2\x3a\xe9\x99\x01\xd6",
         "\x30\xb2\xb5\x11\x8a\x3a\x8d\x70\x67\x71\x14\xde\xed\xa7\x43\xb5" },
       /* After setiv, ctr_low: 0xfffffff6 */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\xab\x9f\x3a",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\x05\x72\x44\xa0\x99\x11\x1d\x2c\x4b\x03\x4f\x20\x92\x88\xbe\x55"
         "\xee\x31\x2c\xd9\xc0\xc1\x64\x77\x79\xd7\x3e\xfa\x5a\x7d\xf0\x48"
         "\xf8\xc8\xfe\x81\x8f\x89\x92\xa6\xc2\x07\xdc\x9f\x3f\xb2\xc8\xf2"
         "\xf3\xe9\xe1\xd3\xed\x55\xb4\xab\xc3\x22\xed\x8f\x00\xde\x32\x95"
         "\x91\xc0\xc5\xf3\xd3\x93\xf0\xee\x56\x14\x8f\x96\xff\xd0\x6a\xbd"
         "\xfc\x57\xc2\xc3\x7b\xc1\x1d\x56\x48\x3f\xa6\xc7\x92\x47\xf7\x2f"
         "\x0b\x85\x1c\xff\x87\x29\xe1\xbb\x9b\x14\x6c\xac\x51\x0a\xc0\x7b"
         "\x22\x25\xb0\x48\x92\xad\x09\x09\x6e\x39\x8e\x96\x13\x05\x55\x92"
         "\xbd\xd7\x5d\x95\x35\xdd\x8a\x9d\x05\x59\x60\xae\xbb\xc0\x85\x92"
         "\x4c\x8b\xa0\x3f\xa2\x4a\xe5\x2e\xde\x85\x1a\x39\x10\x22\x11\x1b"
         "\xdd\xcc\x96\xf4\x93\x97\xf5\x81\x85\xf3\x33\xda\xa1\x9a\xba\xfd"
         "\xb8\xaf\x60\x81\x37\xf1\x02\x88\x54\x15\xeb\x21\xd1\x19\x1a\x1f"
         "\x28\x9f\x02\x27\xca\xce\x97\xda\xdc\xd2\x0f\xc5\x0e\x2e\xdd\x4f"
         "\x1d\x24\x62\xe4\x6e\x4a\xbe\x96\x95\x38\x0c\xe9\x26\x14\xf3\xf0"
         "\x92\xbc\x97\xdc\x38\xeb\x64\xc3\x04\xc1\xa2\x6c\xad\xbd\xf8\x03"
         "\xa0\xa4\x68\xaa\x9d\x1f\x09\xe6\x62\x95\xa2\x1c\x32\xef\x62\x28"
         "\x7e\x54\x6d\x4b\x6a\xcc\x4a\xd0\x82\x47\x46\x0d\x45\x3c\x36\x03"
         "\x86\x90\x44\x65\x18\xac\x19\x75\xe6\xba\xb1\x9a\xb4\x5d\x84\x9b",
         "\x31\x22\x2b\x11\x6e\x2b\x94\x56\x37\x9d\xc3\xa5\xde\xe7\x6e\xc9" },
       /* After setiv, ctr_low: 0xfffffff5 */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\xf6\x46\x77",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\x6e\x32\xdb\x04\x32\x57\x15\x78\x0e\x4c\x70\x66\x5c\x91\x43\x0c"
         "\x63\x73\xb8\x86\xad\xb0\xf1\x34\x0f\x0c\x7e\xd3\x4e\xcb\xc9\xea"
         "\x19\x3c\xb8\x14\xd0\xab\x9e\x9b\x22\xda\x7a\x96\xa7\xf5\xa2\x99"
         "\x58\xe3\xd6\x72\x0f\xf5\xdf\x88\xd1\x33\xb1\xe5\x03\x72\x62\x1c"
         "\xa7\xf2\x67\x50\x0e\x70\xc3\x7a\x6c\x4a\x90\xba\x78\x9e\xd2\x0b"
         "\x29\xd4\xc8\xa7\x57\x06\xf2\xf4\x01\x4b\x30\x53\xea\xf7\xde\xbf"
         "\x1c\x12\x03\xcf\x9f\xcf\x80\x8b\x77\xfd\x73\x48\x79\x19\xbe\x38"
         "\x75\x0b\x6d\x78\x7d\x79\x05\x98\x65\x3b\x35\x8f\x68\xff\x30\x7a"
         "\x6e\xf7\x10\x9e\x11\x25\xc4\x95\x97\x7d\x92\x0f\xbf\x38\x95\xbd"
         "\x5d\x2a\xf2\x06\x2c\xd9\x5a\x80\x91\x4e\x22\x7d\x5f\x69\x85\x03"
         "\xa7\x5d\xda\x22\x09\x2b\x8d\x29\x67\x7c\x8c\xf6\xb6\x49\x20\x63"
         "\xb9\xb6\x4d\xb6\x37\xa3\x7b\x19\xa4\x28\x90\x83\x55\x3d\x4e\x18"
         "\xc8\x65\xbc\xd1\xe7\xb5\xcf\x65\x28\xea\x19\x11\x5c\xea\x83\x8c"
         "\x44\x1f\xac\xc5\xf5\x3a\x4b\x1c\x2b\xbf\x76\xd8\x98\xdb\x50\xeb"
         "\x64\x45\xae\xa5\x39\xb7\xc8\xdf\x5a\x73\x6d\x2d\x0f\x4a\x5a\x17"
         "\x37\x66\x1c\x3d\x27\xd5\xd6\x7d\xe1\x08\x7f\xba\x4d\x43\xc2\x29"
         "\xf7\xbe\x83\xec\xd0\x3b\x2e\x19\x9e\xf7\xbf\x1b\x16\x34\xd8\xfa"
         "\x32\x17\x2a\x90\x55\x93\xd5\x3e\x14\x8d\xd6\xa1\x40\x45\x09\x52",
         "\x89\xf2\xae\x78\x38\x8e\xf2\xd2\x52\xa8\xba\xb6\xf2\x5d\x7c\xfc" },
       /* After setiv, ctr_low: 0xfffffff4 */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\xb2\x9d\x4a",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\x1d\xb8\x77\xcd\xcd\xfe\xde\x07\x97\xcb\x97\x3a\x4f\xa0\xd0\xe6"
         "\xcc\xcf\x8b\x71\xd5\x65\x3d\xc4\x17\x52\xe7\x1d\x6a\x68\x4a\x77"
         "\xca\x04\x4a\xef\x8e\x7e\xce\x79\xa1\x80\x0d\x9e\xd5\xf4\xce\x66"
         "\x4d\x54\xb1\x09\xd1\xb6\xb0\x43\x28\xe8\x53\xe2\x24\x9c\x76\xc5"
         "\x4d\x22\xf3\x6e\x13\xf3\xd7\xe0\x85\xb8\x9e\x0b\x17\x22\xc0\x79"
         "\x2b\x72\x57\xaa\xbd\x43\xc3\xf7\xde\xce\x22\x41\x3c\x7e\x37\x1a"
         "\x55\x2e\x36\x0e\x7e\xdc\xb3\xde\xd7\x33\x36\xc9\xc8\x56\x93\x51"
         "\x68\x77\x9a\xb0\x08\x5c\x22\x35\xef\x5c\x9b\xbf\x3e\x20\x8a\x84"
         "\x3d\xb3\x60\x10\xe1\x97\x30\xd7\xb3\x6f\x40\x5a\x2c\xe0\xe5\x52"
         "\x19\xb6\x2b\xed\x6e\x8e\x18\xb4\x8d\x78\xbd\xc4\x9f\x4f\xbd\x82"
         "\x98\xd6\x71\x3d\x71\x5b\x78\x73\xee\x8e\x4b\x37\x88\x9e\x21\xca"
         "\x00\x6c\xc2\x96\x8d\xf0\xcd\x09\x58\x54\x5a\x58\x59\x8e\x9b\xf8"
         "\x72\x93\xd7\xa0\xf9\xc4\xdc\x48\x89\xaa\x31\x95\xda\x4e\x2f\x79"
         "\x1e\x37\x49\x92\x2e\x32\x2e\x76\x54\x2a\x64\xa8\x96\x67\xe9\x75"
         "\x10\xa6\xeb\xad\xc6\xa8\xec\xb7\x18\x0a\x32\x26\x8d\x6e\x03\x74"
         "\x0e\x1f\xfc\xde\x76\xff\x6e\x96\x42\x2d\x80\x0a\xc6\x78\x70\xc4"
         "\xd8\x56\x7b\xa6\x38\x2f\xf6\xc0\x9b\xd7\x21\x6e\x88\x5d\xc8\xe5"
         "\x02\x6a\x09\x1e\xb3\x46\x44\x80\x82\x5b\xd1\x66\x06\x61\x4f\xb8",
         "\x16\x0e\x73\xa3\x14\x43\xdb\x15\x9c\xb0\x0d\x30\x6d\x9b\xe1\xb1" },
       /* After setiv, ctr_low: 0xfffffff3 */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\xef\x44\x07",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\x42\x71\x54\xe2\xdb\x50\x5d\x3c\x10\xbd\xf8\x60\xbd\xdb\x26\x14"
         "\x7d\x13\x59\x98\x28\xfb\x43\x42\xca\x72\xe6\xd8\x58\x00\xa2\x1b"
         "\x6a\x61\xb4\x3a\x80\x6b\x9e\x14\xbd\x11\x33\xab\xe9\xb9\x91\x95"
         "\xd7\x5d\xc3\x98\x1f\x7f\xcb\xa8\xf0\xec\x31\x26\x51\xea\x2e\xdf"
         "\xd9\xde\x70\xf5\x84\x27\x3a\xac\x22\x05\xb9\xce\x2a\xfb\x2a\x83"
         "\x1e\xce\x0e\xb2\x31\x35\xc6\xe6\xc0\xd7\xb0\x5f\xf5\xca\xdb\x13"
         "\xa7\xfe\x4f\x85\xa3\x4f\x94\x5c\xc1\x04\x12\xde\x6f\xa1\xdb\x41"
         "\x59\x82\x22\x22\x65\x97\x6d\xc8\x67\xab\xf3\x90\xeb\xa4\x00\xb3"
         "\x7d\x94\x3d\x7b\x2a\xe2\x85\x36\x87\x16\xb8\x19\x92\x02\xe0\x43"
         "\x42\x85\xa1\xe6\xb8\x11\x30\xcc\x2c\xd8\x63\x09\x0e\x53\x5f\xa3"
         "\xe0\xd4\xee\x0e\x04\xee\x65\x61\x96\x84\x42\x0c\x68\x8d\xb7\x48"
         "\xa3\x02\xb4\x82\x69\xf2\x35\xe4\xce\x3b\xe3\x44\xce\xad\x49\x32"
         "\xab\xda\x04\xea\x06\x60\xa6\x2a\x7d\xee\x0f\xb8\x95\x90\x22\x62"
         "\x9c\x78\x59\xd3\x7b\x61\x02\x65\x63\x96\x9f\x67\x50\xa0\x61\x43"
         "\x53\xb2\x3f\x22\xed\x8c\x42\x39\x97\xd9\xbc\x6e\x81\xb9\x21\x97"
         "\xc6\x5b\x68\xd7\x7f\xd0\xc5\x4a\xfb\x74\xc4\xfd\x9a\x2a\xb8\x9b"
         "\x48\xe0\x00\xea\x6d\xf5\x30\x26\x61\x8f\xa5\x45\x70\xc9\x3a\xea"
         "\x6d\x19\x11\x57\x0f\x21\xe6\x0a\x53\x94\xe3\x0c\x99\xb0\x2f\xc5",
         "\x92\x92\x89\xcd\x4f\x3c\x6d\xbc\xe8\xb3\x70\x14\x5b\x3c\x12\xe4" },
       /* After setiv, ctr_low: 0xfffffff2 */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\xe3\xc5\x3f",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\x41\xc3\xcb\xd7\x6e\xde\x2a\xc6\x15\x05\xc6\xba\x27\xae\xcd\x37"
         "\xc0\xe5\xbf\xb9\x5c\xdc\xd6\xad\x1a\xe1\x35\x7c\xc0\x85\x85\x51"
         "\x8c\x98\x06\xc0\x72\x43\x71\x7a\x2d\x7c\x81\x3c\xe7\xd6\x32\x8e"
         "\x22\x2b\x46\x95\x6a\xde\x45\x40\x56\xe9\x63\x32\x68\xbf\xb6\x78"
         "\xb7\x86\x00\x9d\x2c\x9e\xed\x67\xc1\x9b\x09\x9e\xd9\x0a\x56\xcb"
         "\x57\xc9\x48\x14\x23\x4e\x97\x04\xb5\x85\x25\x1d\xcb\x1a\x79\x9b"
         "\x54\x06\x95\xad\x16\x81\x84\x3a\x38\xec\x41\x90\x2a\xfa\x50\xe0"
         "\xb9\x20\xa6\xeb\xfe\x2e\x5c\xa1\xf6\x3c\x69\x4c\xce\xf8\x30\xe0"
         "\x87\x68\xa2\x3a\x9d\xad\x75\xd4\xa5\x6b\x0a\x90\x65\xa2\x27\x64"
         "\x9d\xf5\xa0\x6f\xd0\xd3\x62\xa5\x2d\xae\x02\x89\xb4\x1a\xfa\x32"
         "\x9b\xa0\x44\xdd\x50\xde\xaf\x41\xa9\x89\x1e\xb0\x41\xbc\x9c\x41"
         "\xb0\x35\x5e\xf1\x9a\xd9\xab\x57\x53\x21\xca\x39\xfc\x8b\xb4\xd4"
         "\xb2\x19\x8a\xe9\xb2\x24\x1e\xce\x2e\x19\xb0\xd2\x93\x30\xc4\x70"
         "\xe2\xf8\x6a\x8a\x99\x3b\xed\x71\x7e\x9e\x98\x99\x2a\xc6\xdd\xcf"
         "\x43\x32\xdb\xfb\x27\x22\x89\xa4\xc5\xe0\xa2\x94\xe9\xcf\x9d\x48"
         "\xab\x3f\xfa\x4f\x75\x63\x46\xdd\xfe\xfa\xf0\xbf\x6e\xa1\xf9\xca"
         "\xb1\x77\x79\x35\x6c\x33\xe1\x57\x68\x50\xe9\x78\x4e\xe4\xe2\xf0"
         "\xcf\xe4\x23\xde\xf4\xa7\x34\xb3\x44\x97\x38\xd2\xbd\x27\x44\x0e",
         "\x75\x0a\x41\x3b\x87\xe3\xc7\xf6\xd6\xe3\xab\xfa\x4b\xbe\x2e\x56" },
       /* After setiv, ctr_low: 0xfffffff1 */
       { GCRY_CIPHER_AES256,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\xbe\x1c\x72",
         16,
         "", 0,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         288,
         "\xf1\x3c\x7a\xa4\xa9\xaf\xe7\x49\x19\x7d\xad\x50\xc1\x6a\x84\x87"
         "\xf5\x69\xe4\xe5\xc2\x0a\x90\x33\xc3\xeb\x76\x63\x5f\x9b\x1d\xf9"
         "\x53\x4a\x2a\x6d\x6b\x61\xe0\x5d\xed\xcb\x98\x0d\xf2\x57\x33\x12"
         "\xd1\x44\xaa\x7a\x7e\x4e\x41\x0e\xe6\xa7\x9f\x17\x92\x28\x91\xad"
         "\xca\xce\xf2\xa8\x73\x4a\xad\x89\x62\x73\x0b\x9a\x68\x91\xa8\x11"
         "\x44\x01\xfd\x57\xe4\xf8\x84\x55\x2b\x66\xdb\xb9\xd6\xee\x83\xe5"
         "\x57\xea\x5c\x6a\x23\x87\xdd\x0a\x45\x63\xb4\x0c\x8f\xc5\x9f\x22"
         "\xf3\x4f\x4e\x6f\x7b\x14\x62\xf7\x80\x59\x4a\xc5\xc8\xae\x8a\x6f"
         "\x5e\xe3\x1e\xe6\xae\xec\x99\x77\x6b\x88\x14\xe3\x58\x88\x61\x74"
         "\x38\x91\xa1\x32\xb8\xd2\x39\x6b\xe2\xcb\x8e\x77\xde\x92\x36\x78"
         "\xad\x50\xcf\x08\xb8\xfa\x29\x59\xb4\x68\x1b\x23\x10\x57\x32\x92"
         "\xf8\xec\xe1\x97\xdb\x30\x85\x22\xb5\x68\x2f\xf2\x98\xda\x06\xee"
         "\x65\x02\xe7\xf9\xc8\xc1\xca\x8f\xd3\xed\x4a\x3c\x09\xdd\xde\x64"
         "\xd9\x85\x17\x2c\x62\x41\x35\x24\xed\x6b\x87\x78\x1e\xb5\x7a\x9b"
         "\xa3\x90\xa3\x99\xc7\x39\x51\x10\xb7\x6a\x12\x3b\x64\xfe\x32\x3c"
         "\xb6\x84\x9a\x3f\x95\xd3\xcb\x22\x69\x9c\xf9\xb7\xc2\x8b\xf4\x55"
         "\x68\x60\x11\x20\xc5\x3e\x0a\xc0\xba\x00\x0e\x88\x96\x66\xfa\xf0"
         "\x75\xbc\x2b\x9c\xff\xc5\x33\x7b\xaf\xb2\xa6\x34\x78\x44\x9c\xa7",
         "\x01\x24\x0e\x17\x17\xe5\xfc\x90\x07\xfa\x78\xd5\x5d\x66\xa3\xf5" },
     };
 
   gcry_cipher_hd_t hde, hdd;
   unsigned char out[MAX_GCM_DATA_LEN];
   unsigned char tag[GCRY_GCM_BLOCK_LEN];
   int i, keylen;
   gcry_error_t err = 0;
   size_t pos, poslen, taglen2;
   int byteNum;
 
   if (verbose)
     fprintf (stderr, "  Starting GCM checks.\n");
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     tv[i].algo);
           continue;
         }
 
       if (verbose)
         fprintf (stderr, "    checking GCM mode for %s [%i]\n",
                  gcry_cipher_algo_name (tv[i].algo),
                  tv[i].algo);
       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_GCM, 0);
       if (!err)
         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_GCM, 0);
       if (err)
         {
           fail ("aes-gcm, gcry_cipher_open failed: %s\n", gpg_strerror (err));
           return;
         }
 
       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
       if (!keylen)
         {
           fail ("aes-gcm, gcry_cipher_get_algo_keylen failed\n");
           return;
         }
 
       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
       if (!err)
         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
       if (err)
         {
           fail ("aes-gcm, gcry_cipher_setkey failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
       if (!err)
         err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
       if (err)
         {
           fail ("aes-gcm, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_info (hde, GCRYCTL_GET_TAGLEN, NULL, &taglen2);
       if (err)
         {
           fail ("cipher-gcm, gcryctl_get_taglen failed (tv %d): %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
       if (taglen2 != GCRY_GCM_BLOCK_LEN)
         {
           fail ("cipher-gcm, gcryctl_get_taglen returned bad length"
                 " (tv %d): got=%zu want=%d\n",
                 i, taglen2, GCRY_GCM_BLOCK_LEN);
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       for (pos = 0; pos < tv[i].aadlen; pos += step)
         {
           poslen = (pos + step < tv[i].aadlen) ? step : tv[i].aadlen - pos;
 
           err = gcry_cipher_authenticate(hde, tv[i].aad + pos, poslen);
           if (err)
             {
               fail ("aes-gcm, gcry_cipher_authenticate (%d) (%lu:%d) failed: "
                     "%s\n", i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
           err = gcry_cipher_authenticate(hdd, tv[i].aad + pos, poslen);
           if (err)
             {
               fail ("aes-gcm, de gcry_cipher_authenticate (%d) (%lu:%d) failed: "
 	            "%s\n", i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       for (pos = 0; pos < tv[i].inlen; pos += step)
         {
           poslen = (pos + step < tv[i].inlen) ? step : tv[i].inlen - pos;
 
           err = gcry_cipher_encrypt (hde, out + pos, poslen,
                                      tv[i].plaintext + pos, poslen);
           if (err)
             {
               fail ("aes-gcm, gcry_cipher_encrypt (%d) (%lu:%d) failed: %s\n",
                     i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].out, out, tv[i].inlen))
         fail ("aes-gcm, encrypt mismatch entry %d (step %d)\n", i, step);
 
       for (pos = 0; pos < tv[i].inlen; pos += step)
         {
           poslen = (pos + step < tv[i].inlen) ? step : tv[i].inlen - pos;
 
           err = gcry_cipher_decrypt (hdd, out + pos, poslen, NULL, 0);
           if (err)
             {
               fail ("aes-gcm, gcry_cipher_decrypt (%d) (%lu:%d) failed: %s\n",
                     i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].plaintext, out, tv[i].inlen))
         fail ("aes-gcm, decrypt mismatch entry %d (step %d)\n", i, step);
 
       taglen2 = tv[i].taglen ? tv[i].taglen : GCRY_GCM_BLOCK_LEN;
 
       err = gcry_cipher_gettag (hde, out, taglen2);
       if (err)
         {
           if (tv[i].should_fail)
             goto next_tv;
 
           fail ("aes-gcm, gcry_cipher_gettag(%d) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       if (memcmp (tv[i].tag, out, taglen2))
         fail ("aes-gcm, encrypt tag mismatch entry %d\n", i);
 
       err = gcry_cipher_checktag (hdd, out, taglen2);
       if (err)
         {
           fail ("aes-gcm, gcry_cipher_checktag(%d) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_reset(hde);
       if (!err)
         err = gcry_cipher_reset(hdd);
       if (err)
         {
           fail ("aes-gcm, gcry_cipher_reset (%d) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       /* gcry_cipher_reset clears the IV */
       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
       if (!err)
         err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
       if (err)
         {
           fail ("aes-gcm, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       /* this time we authenticate, encrypt and decrypt one byte at a time */
       for (byteNum = 0; byteNum < tv[i].aadlen; ++byteNum)
         {
           err = gcry_cipher_authenticate(hde, tv[i].aad + byteNum, 1);
           if (err)
             {
               fail ("aes-gcm, gcry_cipher_authenticate (%d) (byte-buf) failed: "
                     "%s\n", i, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
           err = gcry_cipher_authenticate(hdd, tv[i].aad + byteNum, 1);
           if (err)
             {
               fail ("aes-gcm, de gcry_cipher_authenticate (%d) (byte-buf) "
 	            "failed: %s\n", i, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       for (byteNum = 0; byteNum < tv[i].inlen; ++byteNum)
         {
           err = gcry_cipher_encrypt (hde, out+byteNum, 1,
                                      (tv[i].plaintext) + byteNum,
                                      1);
           if (err)
             {
               fail ("aes-gcm, gcry_cipher_encrypt (%d) (byte-buf) failed: %s\n",
                     i,  gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].out, out, tv[i].inlen))
         fail ("aes-gcm, encrypt mismatch entry %d, (byte-buf)\n", i);
 
       /* Test output to larger than 16-byte buffer. */
       taglen2 = tv[i].taglen ? tv[i].taglen : GCRY_GCM_BLOCK_LEN + 1;
 
       err = gcry_cipher_gettag (hde, tag, taglen2);
       if (err)
         {
           if (tv[i].should_fail)
             goto next_tv;
 
           fail ("aes-gcm, gcry_cipher_gettag(%d, %lu) (byte-buf) failed: %s\n",
                 i, (unsigned long) taglen2, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       taglen2 = tv[i].taglen ? tv[i].taglen : GCRY_GCM_BLOCK_LEN;
 
       if (memcmp (tv[i].tag, tag, taglen2))
         fail ("aes-gcm, encrypt tag mismatch entry %d, (byte-buf)\n", i);
 
       for (byteNum = 0; byteNum < tv[i].inlen; ++byteNum)
         {
           err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
           if (err)
             {
               fail ("aes-gcm, gcry_cipher_decrypt (%d) (byte-buf) failed: %s\n",
                     i, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].plaintext, out, tv[i].inlen))
         fail ("aes-gcm, decrypt mismatch entry %d\n", i);
 
       err = gcry_cipher_checktag (hdd, tag, taglen2);
       if (err)
         {
           fail ("aes-gcm, gcry_cipher_checktag(%d) (byte-buf) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_checktag (hdd, tag, 1);
       if (!err)
         {
           fail ("aes-gcm, gcry_cipher_checktag(%d) did not fail for invalid "
 	        " tag length of '%d'\n", i, 1);
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
       err = gcry_cipher_checktag (hdd, tag, 17);
       if (!err)
         {
           fail ("aes-gcm, gcry_cipher_checktag(%d) did not fail for invalid "
 	        " tag length of '%d'\n", i, 17);
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       if (tv[i].should_fail)
         {
           fail ("aes-gcm, negative test succeeded %d\n", i);
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
     next_tv:
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
     }
   if (verbose)
     fprintf (stderr, "  Completed GCM checks.\n");
 }
 
 
 static void
 check_gcm_cipher (void)
 {
   /* Large buffers, no splitting. */
   _check_gcm_cipher(0xffffffff);
   /* Split input to one byte buffers. */
   _check_gcm_cipher(1);
   /* Split input to 7 byte buffers. */
   _check_gcm_cipher(7);
   /* Split input to 15 byte buffers. */
   _check_gcm_cipher(15);
   /* Split input to 16 byte buffers. */
   _check_gcm_cipher(16);
   /* Split input to 17 byte buffers. */
   _check_gcm_cipher(17);
 }
 
 
 static void
 _check_eax_cipher (unsigned int step)
 {
   static const struct tv
   {
     int algo;
     char key[MAX_DATA_LEN];
     char nonce[MAX_DATA_LEN];
     int noncelen;
     unsigned char header[MAX_DATA_LEN];
     int headerlen;
     unsigned char plaintext[MAX_DATA_LEN];
     int inlen;
     char out[MAX_DATA_LEN];
     char tag[MAX_DATA_LEN];
     int taglen;
     int should_fail;
   } tv[] =
     {
       /* Test vectors from http://www.cs.ucdavis.edu/~rogaway/papers/eax.pdf */
       { GCRY_CIPHER_AES,
         "\x23\x39\x52\xDE\xE4\xD5\xED\x5F\x9B\x9C\x6D\x6F\xF8\x0F\xF4\x78",
         "\x62\xEC\x67\xF9\xC3\xA4\xA4\x07\xFC\xB2\xA8\xC4\x90\x31\xA8\xB3", 16,
         "\x6B\xFB\x91\x4F\xD0\x7E\xAE\x6B", 8,
         "",
         0,
         "",
         "\xE0\x37\x83\x0E\x83\x89\xF2\x7B\x02\x5A\x2D\x65\x27\xE7\x9D\x01", 16,
         0
       },
       { GCRY_CIPHER_AES,
         "\x91\x94\x5D\x3F\x4D\xCB\xEE\x0B\xF4\x5E\xF5\x22\x55\xF0\x95\xA4",
         "\xBE\xCA\xF0\x43\xB0\xA2\x3D\x84\x31\x94\xBA\x97\x2C\x66\xDE\xBD", 16,
         "\xFA\x3B\xFD\x48\x06\xEB\x53\xFA", 8,
         "\xF7\xFB",
         2,
         "\x19\xDD",
         "\x5C\x4C\x93\x31\x04\x9D\x0B\xDA\xB0\x27\x74\x08\xF6\x79\x67\xE5", 16,
         0
       },
       { GCRY_CIPHER_AES,
         "\x01\xF7\x4A\xD6\x40\x77\xF2\xE7\x04\xC0\xF6\x0A\xDA\x3D\xD5\x23",
         "\x70\xC3\xDB\x4F\x0D\x26\x36\x84\x00\xA1\x0E\xD0\x5D\x2B\xFF\x5E", 16,
         "\x23\x4A\x34\x63\xC1\x26\x4A\xC6", 8,
         "\x1A\x47\xCB\x49\x33",
         5,
         "\xD8\x51\xD5\xBA\xE0",
         "\x3A\x59\xF2\x38\xA2\x3E\x39\x19\x9D\xC9\x26\x66\x26\xC4\x0F\x80", 16,
         0
       },
       { GCRY_CIPHER_AES,
         "\xD0\x7C\xF6\xCB\xB7\xF3\x13\xBD\xDE\x66\xB7\x27\xAF\xD3\xC5\xE8",
         "\x84\x08\xDF\xFF\x3C\x1A\x2B\x12\x92\xDC\x19\x9E\x46\xB7\xD6\x17", 16,
         "\x33\xCC\xE2\xEA\xBF\xF5\xA7\x9D", 8,
         "\x48\x1C\x9E\x39\xB1",
         5,
         "\x63\x2A\x9D\x13\x1A",
         "\xD4\xC1\x68\xA4\x22\x5D\x8E\x1F\xF7\x55\x93\x99\x74\xA7\xBE\xDE", 16,
         0
       },
       { GCRY_CIPHER_AES,
         "\x35\xB6\xD0\x58\x00\x05\xBB\xC1\x2B\x05\x87\x12\x45\x57\xD2\xC2",
         "\xFD\xB6\xB0\x66\x76\xEE\xDC\x5C\x61\xD7\x42\x76\xE1\xF8\xE8\x16", 16,
         "\xAE\xB9\x6E\xAE\xBE\x29\x70\xE9", 8,
         "\x40\xD0\xC0\x7D\xA5\xE4",
         6,
         "\x07\x1D\xFE\x16\xC6\x75",
         "\xCB\x06\x77\xE5\x36\xF7\x3A\xFE\x6A\x14\xB7\x4E\xE4\x98\x44\xDD", 16,
         0
       },
       { GCRY_CIPHER_AES,
         "\xBD\x8E\x6E\x11\x47\x5E\x60\xB2\x68\x78\x4C\x38\xC6\x2F\xEB\x22",
         "\x6E\xAC\x5C\x93\x07\x2D\x8E\x85\x13\xF7\x50\x93\x5E\x46\xDA\x1B", 16,
         "\xD4\x48\x2D\x1C\xA7\x8D\xCE\x0F", 8,
         "\x4D\xE3\xB3\x5C\x3F\xC0\x39\x24\x5B\xD1\xFB\x7D",
         12,
         "\x83\x5B\xB4\xF1\x5D\x74\x3E\x35\x0E\x72\x84\x14",
         "\xAB\xB8\x64\x4F\xD6\xCC\xB8\x69\x47\xC5\xE1\x05\x90\x21\x0A\x4F", 16,
         0
       },
       { GCRY_CIPHER_AES,
         "\x7C\x77\xD6\xE8\x13\xBE\xD5\xAC\x98\xBA\xA4\x17\x47\x7A\x2E\x7D",
         "\x1A\x8C\x98\xDC\xD7\x3D\x38\x39\x3B\x2B\xF1\x56\x9D\xEE\xFC\x19", 16,
         "\x65\xD2\x01\x79\x90\xD6\x25\x28", 8,
         "\x8B\x0A\x79\x30\x6C\x9C\xE7\xED\x99\xDA\xE4\xF8\x7F\x8D\xD6\x16\x36",
         17,
         "\x02\x08\x3E\x39\x79\xDA\x01\x48\x12\xF5\x9F\x11\xD5\x26\x30\xDA\x30",
         "\x13\x73\x27\xD1\x06\x49\xB0\xAA\x6E\x1C\x18\x1D\xB6\x17\xD7\xF2", 16,
         0
       },
       { GCRY_CIPHER_AES,
         "\x5F\xFF\x20\xCA\xFA\xB1\x19\xCA\x2F\xC7\x35\x49\xE2\x0F\x5B\x0D",
         "\xDD\xE5\x9B\x97\xD7\x22\x15\x6D\x4D\x9A\xFF\x2B\xC7\x55\x98\x26", 16,
         "\x54\xB9\xF0\x4E\x6A\x09\x18\x9A", 8,
         "\x1B\xDA\x12\x2B\xCE\x8A\x8D\xBA\xF1\x87\x7D\x96\x2B\x85\x92\xDD"
         "\x2D\x56",
         18,
         "\x2E\xC4\x7B\x2C\x49\x54\xA4\x89\xAF\xC7\xBA\x48\x97\xED\xCD\xAE"
         "\x8C\xC3",
         "\x3B\x60\x45\x05\x99\xBD\x02\xC9\x63\x82\x90\x2A\xEF\x7F\x83\x2A", 16,
         0
       },
       { GCRY_CIPHER_AES,
         "\xA4\xA4\x78\x2B\xCF\xFD\x3E\xC5\xE7\xEF\x6D\x8C\x34\xA5\x61\x23",
         "\xB7\x81\xFC\xF2\xF7\x5F\xA5\xA8\xDE\x97\xA9\xCA\x48\xE5\x22\xEC", 16,
         "\x89\x9A\x17\x58\x97\x56\x1D\x7E", 8,
         "\x6C\xF3\x67\x20\x87\x2B\x85\x13\xF6\xEA\xB1\xA8\xA4\x44\x38\xD5"
         "\xEF\x11",
         18,
         "\x0D\xE1\x8F\xD0\xFD\xD9\x1E\x7A\xF1\x9F\x1D\x8E\xE8\x73\x39\x38"
         "\xB1\xE8",
         "\xE7\xF6\xD2\x23\x16\x18\x10\x2F\xDB\x7F\xE5\x5F\xF1\x99\x17\x00", 16,
         0
       },
       { GCRY_CIPHER_AES,
         "\x83\x95\xFC\xF1\xE9\x5B\xEB\xD6\x97\xBD\x01\x0B\xC7\x66\xAA\xC3",
         "\x22\xE7\xAD\xD9\x3C\xFC\x63\x93\xC5\x7E\xC0\xB3\xC1\x7D\x6B\x44", 16,
         "\x12\x67\x35\xFC\xC3\x20\xD2\x5A", 8,
         "\xCA\x40\xD7\x44\x6E\x54\x5F\xFA\xED\x3B\xD1\x2A\x74\x0A\x65\x9F"
         "\xFB\xBB\x3C\xEA\xB7",
         21,
         "\xCB\x89\x20\xF8\x7A\x6C\x75\xCF\xF3\x96\x27\xB5\x6E\x3E\xD1\x97"
         "\xC5\x52\xD2\x95\xA7",
         "\xCF\xC4\x6A\xFC\x25\x3B\x46\x52\xB1\xAF\x37\x95\xB1\x24\xAB\x6E", 16,
         0
       },
       /* Negative test for bad tag. */
       { GCRY_CIPHER_AES,
         "\x23\x39\x52\xDE\xE4\xD5\xED\x5F\x9B\x9C\x6D\x6F\xF8\x0F\xF4\x78",
         "\x62\xEC\x67\xF9\xC3\xA4\xA4\x07\xFC\xB2\xA8\xC4\x90\x31\xA8\xB3", 16,
         "\x6B\xFB\x91\x4F\xD0\x7E\xAE\x6B", 8,
         "",
         0,
         "",
         "\x00\x37\x83\x0E\x83\x89\xF2\x7B\x02\x5A\x2D\x65\x27\xE7\x9D\x01", 16,
         1
       },
       /* Test vectors from libtomcrypt. */
       {
         GCRY_CIPHER_AES,
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
         "", 0,
         "", 0,
         "",
         0,
         "",
         "\x9a\xd0\x7e\x7d\xbf\xf3\x01\xf5\x05\xde\x59\x6b\x96\x15\xdf\xff", 16,
         0
       },
       {
         GCRY_CIPHER_AES,
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 16,
         "", 0,
         "",
         0,
         "",
         "\x1c\xe1\x0d\x3e\xff\xd4\xca\xdb\xe2\xe4\x4b\x58\xd6\x0a\xb9\xec", 16,
         0
       },
       {
         GCRY_CIPHER_AES,
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
         "", 0,
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 16,
         "",
         0,
         "",
         "\x3a\x69\x8f\x7a\x27\x0e\x51\xb0\xf6\x5b\x3d\x3e\x47\x19\x3c\xff", 16,
         0
       },
       {
         GCRY_CIPHER_AES,
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 16,
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 16,
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",
         32,
         "\x29\xd8\x78\xd1\xa3\xbe\x85\x7b\x6f\xb8\xc8\xea\x59\x50\xa7\x78"
         "\x33\x1f\xbf\x2c\xcf\x33\x98\x6f\x35\xe8\xcf\x12\x1d\xcb\x30\xbc",
         "\x4f\xbe\x03\x38\xbe\x1c\x8c\x7e\x1d\x7a\xe7\xe4\x5b\x92\xc5\x87", 16,
         0
       },
       {
         GCRY_CIPHER_AES,
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e", 15,
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d", 14,
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c",
         29,
         "\xdd\x25\xc7\x54\xc5\xb1\x7c\x59\x28\xb6\x9b\x73\x15\x5f\x7b\xb8"
         "\x88\x8f\xaf\x37\x09\x1a\xd9\x2c\x8a\x24\xdb\x86\x8b",
         "\x0d\x1a\x14\xe5\x22\x24\xff\xd2\x3a\x05\xfa\x02\xcd\xef\x52\xda", 16,
         0
       },
     };
 
   gcry_cipher_hd_t hde, hdd;
   unsigned char out[MAX_DATA_LEN];
   unsigned char tag[16];
   int i, keylen;
   gcry_error_t err = 0;
   size_t pos, poslen, taglen2;
   int byteNum;
 
   if (verbose)
     fprintf (stderr, "  Starting EAX checks.\n");
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     tv[i].algo);
           continue;
         }
 
       if (verbose)
         fprintf (stderr, "    checking EAX mode for %s [%i]\n",
                  gcry_cipher_algo_name (tv[i].algo),
                  tv[i].algo);
       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_EAX, 0);
       if (!err)
         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_EAX, 0);
       if (err)
         {
           fail ("aes-eax, gcry_cipher_open failed: %s\n", gpg_strerror (err));
           return;
         }
 
       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
       if (!keylen)
         {
           fail ("aes-eax, gcry_cipher_get_algo_keylen failed\n");
           return;
         }
 
       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
       if (!err)
         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
       if (err)
         {
           fail ("aes-eax, gcry_cipher_setkey failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_setiv (hde, tv[i].nonce, tv[i].noncelen);
       if (!err)
         err = gcry_cipher_setiv (hdd, tv[i].nonce, tv[i].noncelen);
       if (err)
         {
           fail ("aes-eax, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_info (hde, GCRYCTL_GET_TAGLEN, NULL, &taglen2);
       if (err)
         {
           fail ("cipher-eax, gcryctl_get_taglen failed (tv %d): %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
       if (taglen2 != 16)
         {
           fail ("cipher-eax, gcryctl_get_taglen returned bad length"
                 " (tv %d): got=%zu want=%d\n",
                 i, taglen2, 16);
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       for (pos = 0; pos < tv[i].headerlen; pos += step)
         {
           poslen = (pos + step < tv[i].headerlen) ?
                     step : tv[i].headerlen - pos;
 
           err = gcry_cipher_authenticate(hde, tv[i].header + pos, poslen);
           if (err)
             {
               fail ("aes-eax, gcry_cipher_authenticate (%d) (%lu:%d) failed: "
                     "%s\n", i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
           err = gcry_cipher_authenticate(hdd, tv[i].header + pos, poslen);
           if (err)
             {
               fail ("aes-eax, de gcry_cipher_authenticate (%d) (%lu:%d) failed: "
 	            "%s\n", i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       for (pos = 0; pos < tv[i].inlen; pos += step)
         {
           poslen = (pos + step < tv[i].inlen) ? step : tv[i].inlen - pos;
 
           err = gcry_cipher_encrypt (hde, out + pos, poslen,
                                      tv[i].plaintext + pos, poslen);
           if (err)
             {
               fail ("aes-eax, gcry_cipher_encrypt (%d) (%lu:%d) failed: %s\n",
                     i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].out, out, tv[i].inlen))
         fail ("aes-eax, encrypt mismatch entry %d (step %d)\n", i, step);
 
       for (pos = 0; pos < tv[i].inlen; pos += step)
         {
           poslen = (pos + step < tv[i].inlen) ? step : tv[i].inlen - pos;
 
           err = gcry_cipher_decrypt (hdd, out + pos, poslen, NULL, 0);
           if (err)
             {
               fail ("aes-eax, gcry_cipher_decrypt (%d) (%lu:%d) failed: %s\n",
                     i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].plaintext, out, tv[i].inlen))
         fail ("aes-eax, decrypt mismatch entry %d (step %d)\n", i, step);
 
       taglen2 = tv[i].taglen ? tv[i].taglen : 16;
 
       err = gcry_cipher_gettag (hde, out, taglen2);
       if (err)
         {
           if (tv[i].should_fail)
             goto next_tv;
 
           fail ("aes-eax, gcry_cipher_gettag(%d) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       if ((memcmp (tv[i].tag, out, taglen2) != 0) ^ tv[i].should_fail)
         fail ("aes-eax, encrypt tag mismatch entry %d\n", i);
 
       err = gcry_cipher_checktag (hdd, tv[i].tag, taglen2);
       if (err)
         {
           if (tv[i].should_fail)
             goto next_tv;
 
           fail ("aes-eax, gcry_cipher_checktag(%d) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_reset(hde);
       if (!err)
         err = gcry_cipher_reset(hdd);
       if (err)
         {
           fail ("aes-eax, gcry_cipher_reset (%d) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       /* gcry_cipher_reset clears the IV */
       err = gcry_cipher_setiv (hde, tv[i].nonce, tv[i].noncelen);
       if (!err)
         err = gcry_cipher_setiv (hdd, tv[i].nonce, tv[i].noncelen);
       if (err)
         {
           fail ("aes-eax, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       /* this time we authenticate, encrypt and decrypt one byte at a time */
       for (byteNum = 0; byteNum < tv[i].headerlen; ++byteNum)
         {
           err = gcry_cipher_authenticate(hde, tv[i].header + byteNum, 1);
           if (err)
             {
               fail ("aes-eax, gcry_cipher_authenticate (%d) (byte-buf) failed: "
                     "%s\n", i, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
           err = gcry_cipher_authenticate(hdd, tv[i].header + byteNum, 1);
           if (err)
             {
               fail ("aes-eax, de gcry_cipher_authenticate (%d) (byte-buf) "
 	            "failed: %s\n", i, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       for (byteNum = 0; byteNum < tv[i].inlen; ++byteNum)
         {
           err = gcry_cipher_encrypt (hde, out+byteNum, 1,
                                      (tv[i].plaintext) + byteNum,
                                      1);
           if (err)
             {
               fail ("aes-eax, gcry_cipher_encrypt (%d) (byte-buf) failed: %s\n",
                     i,  gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].out, out, tv[i].inlen))
         fail ("aes-eax, encrypt mismatch entry %d, (byte-buf)\n", i);
 
       /* Test output to larger than 16-byte buffer. */
       taglen2 = tv[i].taglen ? tv[i].taglen : 16 + 1;
 
       err = gcry_cipher_gettag (hde, tag, taglen2);
       if (err)
         {
           if (tv[i].should_fail)
             goto next_tv;
 
           fail ("aes-eax, gcry_cipher_gettag(%d, %lu) (byte-buf) failed: %s\n",
                 i, (unsigned long) taglen2, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       taglen2 = tv[i].taglen ? tv[i].taglen : 16;
 
       if ((memcmp (tv[i].tag, tag, taglen2) != 0) ^ tv[i].should_fail)
         fail ("aes-eax, encrypt tag mismatch entry %d, (byte-buf)\n", i);
 
       for (byteNum = 0; byteNum < tv[i].inlen; ++byteNum)
         {
           err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
           if (err)
             {
               fail ("aes-eax, gcry_cipher_decrypt (%d) (byte-buf) failed: %s\n",
                     i, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].plaintext, out, tv[i].inlen))
         fail ("aes-eax, decrypt mismatch entry %d\n", i);
 
       err = gcry_cipher_checktag (hdd, tv[i].tag, taglen2);
       if (err)
         {
           if (tv[i].should_fail)
             goto next_tv;
 
           fail ("aes-eax, gcry_cipher_checktag(%d) (byte-buf) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_checktag (hdd, tag, 17);
       if (!err)
         {
           fail ("aes-eax, gcry_cipher_checktag(%d) did not fail for invalid "
 	        " tag length of '%d'\n", i, 17);
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       if (tv[i].should_fail)
         {
           fail ("aes-eax, negative test succeeded %d\n", i);
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
     next_tv:
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
     }
   if (verbose)
     fprintf (stderr, "  Completed EAX checks.\n");
 }
 
 
 static void
 check_eax_cipher (void)
 {
   /* Large buffers, no splitting. */
   _check_eax_cipher(0xffffffff);
   /* Split input to one byte buffers. */
   _check_eax_cipher(1);
   /* Split input to 7 byte buffers. */
   _check_eax_cipher(7);
   /* Split input to 16 byte buffers. */
   _check_eax_cipher(16);
 }
 
 
 static void
 _check_poly1305_cipher (unsigned int step)
 {
   static const struct tv
   {
     int algo;
     const char *key;
     const char *iv;
     int ivlen;
     const char *aad;
     int aadlen;
     const char *plaintext;
     int inlen;
     const char *out;
     const char *tag;
   } tv[] =
     {
       /* draft-irtf-cfrg-chacha20-poly1305-03 */
       { GCRY_CIPHER_CHACHA20,
 	"\x1c\x92\x40\xa5\xeb\x55\xd3\x8a\xf3\x33\x88\x86\x04\xf6\xb5\xf0"
 	"\x47\x39\x17\xc1\x40\x2b\x80\x09\x9d\xca\x5c\xbc\x20\x70\x75\xc0",
 	"\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08", 12,
 	"\xf3\x33\x88\x86\x00\x00\x00\x00\x00\x00\x4e\x91", 12,
 	"\x49\x6e\x74\x65\x72\x6e\x65\x74\x2d\x44\x72\x61\x66\x74\x73\x20"
 	"\x61\x72\x65\x20\x64\x72\x61\x66\x74\x20\x64\x6f\x63\x75\x6d\x65"
 	"\x6e\x74\x73\x20\x76\x61\x6c\x69\x64\x20\x66\x6f\x72\x20\x61\x20"
 	"\x6d\x61\x78\x69\x6d\x75\x6d\x20\x6f\x66\x20\x73\x69\x78\x20\x6d"
 	"\x6f\x6e\x74\x68\x73\x20\x61\x6e\x64\x20\x6d\x61\x79\x20\x62\x65"
 	"\x20\x75\x70\x64\x61\x74\x65\x64\x2c\x20\x72\x65\x70\x6c\x61\x63"
 	"\x65\x64\x2c\x20\x6f\x72\x20\x6f\x62\x73\x6f\x6c\x65\x74\x65\x64"
 	"\x20\x62\x79\x20\x6f\x74\x68\x65\x72\x20\x64\x6f\x63\x75\x6d\x65"
 	"\x6e\x74\x73\x20\x61\x74\x20\x61\x6e\x79\x20\x74\x69\x6d\x65\x2e"
 	"\x20\x49\x74\x20\x69\x73\x20\x69\x6e\x61\x70\x70\x72\x6f\x70\x72"
 	"\x69\x61\x74\x65\x20\x74\x6f\x20\x75\x73\x65\x20\x49\x6e\x74\x65"
 	"\x72\x6e\x65\x74\x2d\x44\x72\x61\x66\x74\x73\x20\x61\x73\x20\x72"
 	"\x65\x66\x65\x72\x65\x6e\x63\x65\x20\x6d\x61\x74\x65\x72\x69\x61"
 	"\x6c\x20\x6f\x72\x20\x74\x6f\x20\x63\x69\x74\x65\x20\x74\x68\x65"
 	"\x6d\x20\x6f\x74\x68\x65\x72\x20\x74\x68\x61\x6e\x20\x61\x73\x20"
 	"\x2f\xe2\x80\x9c\x77\x6f\x72\x6b\x20\x69\x6e\x20\x70\x72\x6f\x67"
 	"\x72\x65\x73\x73\x2e\x2f\xe2\x80\x9d", 265,
 	"\x64\xa0\x86\x15\x75\x86\x1a\xf4\x60\xf0\x62\xc7\x9b\xe6\x43\xbd"
 	"\x5e\x80\x5c\xfd\x34\x5c\xf3\x89\xf1\x08\x67\x0a\xc7\x6c\x8c\xb2"
 	"\x4c\x6c\xfc\x18\x75\x5d\x43\xee\xa0\x9e\xe9\x4e\x38\x2d\x26\xb0"
 	"\xbd\xb7\xb7\x3c\x32\x1b\x01\x00\xd4\xf0\x3b\x7f\x35\x58\x94\xcf"
 	"\x33\x2f\x83\x0e\x71\x0b\x97\xce\x98\xc8\xa8\x4a\xbd\x0b\x94\x81"
 	"\x14\xad\x17\x6e\x00\x8d\x33\xbd\x60\xf9\x82\xb1\xff\x37\xc8\x55"
 	"\x97\x97\xa0\x6e\xf4\xf0\xef\x61\xc1\x86\x32\x4e\x2b\x35\x06\x38"
 	"\x36\x06\x90\x7b\x6a\x7c\x02\xb0\xf9\xf6\x15\x7b\x53\xc8\x67\xe4"
 	"\xb9\x16\x6c\x76\x7b\x80\x4d\x46\xa5\x9b\x52\x16\xcd\xe7\xa4\xe9"
 	"\x90\x40\xc5\xa4\x04\x33\x22\x5e\xe2\x82\xa1\xb0\xa0\x6c\x52\x3e"
 	"\xaf\x45\x34\xd7\xf8\x3f\xa1\x15\x5b\x00\x47\x71\x8c\xbc\x54\x6a"
 	"\x0d\x07\x2b\x04\xb3\x56\x4e\xea\x1b\x42\x22\x73\xf5\x48\x27\x1a"
 	"\x0b\xb2\x31\x60\x53\xfa\x76\x99\x19\x55\xeb\xd6\x31\x59\x43\x4e"
 	"\xce\xbb\x4e\x46\x6d\xae\x5a\x10\x73\xa6\x72\x76\x27\x09\x7a\x10"
 	"\x49\xe6\x17\xd9\x1d\x36\x10\x94\xfa\x68\xf0\xff\x77\x98\x71\x30"
 	"\x30\x5b\xea\xba\x2e\xda\x04\xdf\x99\x7b\x71\x4d\x6c\x6f\x2c\x29"
 	"\xa6\xad\x5c\xb4\x02\x2b\x02\x70\x9b",
 	"\xee\xad\x9d\x67\x89\x0c\xbb\x22\x39\x23\x36\xfe\xa1\x85\x1f\x38" },
       /* draft-irtf-cfrg-chacha20-poly1305-03 */
       { GCRY_CIPHER_CHACHA20,
 	"\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
 	"\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f",
 	"\x07\x00\x00\x00\x40\x41\x42\x43\x44\x45\x46\x47", 12,
 	"\x50\x51\x52\x53\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7", 12,
 	"Ladies and Gentlemen of the class of '99: If I could offer you "
 	"only one tip for the future, sunscreen would be it.", 114,
 	"\xd3\x1a\x8d\x34\x64\x8e\x60\xdb\x7b\x86\xaf\xbc\x53\xef\x7e\xc2"
 	"\xa4\xad\xed\x51\x29\x6e\x08\xfe\xa9\xe2\xb5\xa7\x36\xee\x62\xd6"
 	"\x3d\xbe\xa4\x5e\x8c\xa9\x67\x12\x82\xfa\xfb\x69\xda\x92\x72\x8b"
 	"\x1a\x71\xde\x0a\x9e\x06\x0b\x29\x05\xd6\xa5\xb6\x7e\xcd\x3b\x36"
 	"\x92\xdd\xbd\x7f\x2d\x77\x8b\x8c\x98\x03\xae\xe3\x28\x09\x1b\x58"
 	"\xfa\xb3\x24\xe4\xfa\xd6\x75\x94\x55\x85\x80\x8b\x48\x31\xd7\xbc"
 	"\x3f\xf4\xde\xf0\x8e\x4b\x7a\x9d\xe5\x76\xd2\x65\x86\xce\xc6\x4b"
 	"\x61\x16",
 	"\x1a\xe1\x0b\x59\x4f\x09\xe2\x6a\x7e\x90\x2e\xcb\xd0\x60\x06\x91" },
     };
 
   gcry_cipher_hd_t hde, hdd;
   unsigned char out[1024];
   unsigned char tag[16];
   int i, keylen;
   gcry_error_t err = 0;
   size_t pos, poslen, taglen2;
   int byteNum;
 
   if (verbose)
     fprintf (stderr, "  Starting POLY1305 checks.\n");
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       if (verbose)
         fprintf (stderr, "    checking POLY1305 mode for %s [%i]\n",
                  gcry_cipher_algo_name (tv[i].algo),
                  tv[i].algo);
       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_POLY1305, 0);
       if (!err)
         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_POLY1305, 0);
       if (err)
         {
           fail ("poly1305, gcry_cipher_open failed: %s\n", gpg_strerror (err));
           return;
         }
 
       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
       if (!keylen)
         {
           fail ("poly1305, gcry_cipher_get_algo_keylen failed\n");
           return;
         }
 
       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
       if (!err)
         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
       if (err)
         {
           fail ("poly1305, gcry_cipher_setkey failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
       if (!err)
         err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
       if (err)
         {
           fail ("poly1305, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_info (hde, GCRYCTL_GET_TAGLEN, NULL, &taglen2);
       if (err)
         {
           fail ("cipher-poly1305, gcryctl_get_taglen failed (tv %d): %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
       if (taglen2 != 16)
         {
           fail ("cipher-poly1305, gcryctl_get_taglen returned bad length"
                 " (tv %d): got=%zu want=%d\n",
                 i, taglen2, 16);
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       for (pos = 0; pos < tv[i].aadlen; pos += step)
         {
           poslen = (pos + step < tv[i].aadlen) ? step : tv[i].aadlen - pos;
 
           err = gcry_cipher_authenticate(hde, tv[i].aad + pos, poslen);
           if (err)
             {
               fail ("poly1305, gcry_cipher_authenticate (%d) (%lu:%d) failed: "
                     "%s\n", i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
           err = gcry_cipher_authenticate(hdd, tv[i].aad + pos, poslen);
           if (err)
             {
               fail ("poly1305, de gcry_cipher_authenticate (%d) (%lu:%d) failed: "
 	            "%s\n", i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       for (pos = 0; pos < tv[i].inlen; pos += step)
         {
           poslen = (pos + step < tv[i].inlen) ? step : tv[i].inlen - pos;
 
           err = gcry_cipher_encrypt (hde, out + pos, poslen,
                                      tv[i].plaintext + pos, poslen);
           if (err)
             {
               fail ("poly1305, gcry_cipher_encrypt (%d) (%lu:%d) failed: %s\n",
                     i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].out, out, tv[i].inlen))
         fail ("poly1305, encrypt mismatch entry %d (step %d)\n", i, step);
 
       for (pos = 0; pos < tv[i].inlen; pos += step)
         {
           poslen = (pos + step < tv[i].inlen) ? step : tv[i].inlen - pos;
 
           err = gcry_cipher_decrypt (hdd, out + pos, poslen, NULL, 0);
           if (err)
             {
               fail ("poly1305, gcry_cipher_decrypt (%d) (%lu:%d) failed: %s\n",
                     i, (unsigned long) pos, step, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].plaintext, out, tv[i].inlen))
         fail ("poly1305, decrypt mismatch entry %d (step %d)\n", i, step);
 
       err = gcry_cipher_gettag (hde, out, 16);
       if (err)
         {
           fail ("poly1305, gcry_cipher_gettag(%d) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       if (memcmp (tv[i].tag, out, 16))
         fail ("poly1305, encrypt tag mismatch entry %d\n", i);
 
 
       err = gcry_cipher_checktag (hdd, out, 16);
       if (err)
         {
           fail ("poly1305, gcry_cipher_checktag(%d) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_reset(hde);
       if (!err)
         err = gcry_cipher_reset(hdd);
       if (err)
         {
           fail ("poly1305, gcry_cipher_reset (%d) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       /* gcry_cipher_reset clears the IV */
       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
       if (!err)
         err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
       if (err)
         {
           fail ("poly1305, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       /* this time we authenticate, encrypt and decrypt one byte at a time */
       for (byteNum = 0; byteNum < tv[i].aadlen; ++byteNum)
         {
           err = gcry_cipher_authenticate(hde, tv[i].aad + byteNum, 1);
           if (err)
             {
               fail ("poly1305, gcry_cipher_authenticate (%d) (byte-buf) failed: "
                     "%s\n", i, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
           err = gcry_cipher_authenticate(hdd, tv[i].aad + byteNum, 1);
           if (err)
             {
               fail ("poly1305, de gcry_cipher_authenticate (%d) (byte-buf) "
 	            "failed: %s\n", i, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       for (byteNum = 0; byteNum < tv[i].inlen; ++byteNum)
         {
           err = gcry_cipher_encrypt (hde, out+byteNum, 1,
                                      (tv[i].plaintext) + byteNum,
                                      1);
           if (err)
             {
               fail ("poly1305, gcry_cipher_encrypt (%d) (byte-buf) failed: %s\n",
                     i,  gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].out, out, tv[i].inlen))
         fail ("poly1305, encrypt mismatch entry %d, (byte-buf)\n", i);
 
       err = gcry_cipher_gettag (hde, tag, 16);
       if (err)
         {
           fail ("poly1305, gcry_cipher_gettag(%d) (byte-buf) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       if (memcmp (tv[i].tag, tag, 16))
         fail ("poly1305, encrypt tag mismatch entry %d, (byte-buf)\n", i);
 
       for (byteNum = 0; byteNum < tv[i].inlen; ++byteNum)
         {
           err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
           if (err)
             {
               fail ("poly1305, gcry_cipher_decrypt (%d) (byte-buf) failed: %s\n",
                     i, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
 
       if (memcmp (tv[i].plaintext, out, tv[i].inlen))
         fail ("poly1305, decrypt mismatch entry %d\n", i);
 
       err = gcry_cipher_checktag (hdd, tag, 16);
       if (err)
         {
           fail ("poly1305, gcry_cipher_checktag(%d) (byte-buf) failed: %s\n",
                 i, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
     }
   if (verbose)
     fprintf (stderr, "  Completed POLY1305 checks.\n");
 }
 
 
 static void
 check_poly1305_cipher (void)
 {
   /* Large buffers, no splitting. */
   _check_poly1305_cipher(0xffffffff);
   /* Split input to one byte buffers. */
   _check_poly1305_cipher(1);
   /* Split input to 7 byte buffers. */
   _check_poly1305_cipher(7);
   /* Split input to 16 byte buffers. */
   _check_poly1305_cipher(16);
 }
 
 
 static void
 check_ccm_cipher (void)
 {
   static const struct tv
   {
     int algo;
     int keylen;
     const char *key;
     int noncelen;
     const char *nonce;
     int aadlen;
     const char *aad;
     int plainlen;
     const char *plaintext;
     int cipherlen;
     const char *ciphertext;
   } tv[] =
     {
       /* RFC 3610 */
       { GCRY_CIPHER_AES, /* Packet Vector #1 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x03\x02\x01\x00\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           23,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
           31,
           "\x58\x8C\x97\x9A\x61\xC6\x63\xD2\xF0\x66\xD0\xC2\xC0\xF9\x89\x80\x6D\x5F\x6B\x61\xDA\xC3\x84\x17\xE8\xD1\x2C\xFD\xF9\x26\xE0"},
       { GCRY_CIPHER_AES, /* Packet Vector #2 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x04\x03\x02\x01\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           24,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
           32,
           "\x72\xC9\x1A\x36\xE1\x35\xF8\xCF\x29\x1C\xA8\x94\x08\x5C\x87\xE3\xCC\x15\xC4\x39\xC9\xE4\x3A\x3B\xA0\x91\xD5\x6E\x10\x40\x09\x16"},
       { GCRY_CIPHER_AES, /* Packet Vector #3 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x05\x04\x03\x02\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           25,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
           33,
           "\x51\xB1\xE5\xF4\x4A\x19\x7D\x1D\xA4\x6B\x0F\x8E\x2D\x28\x2A\xE8\x71\xE8\x38\xBB\x64\xDA\x85\x96\x57\x4A\xDA\xA7\x6F\xBD\x9F\xB0\xC5"},
       { GCRY_CIPHER_AES, /* Packet Vector #4 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x06\x05\x04\x03\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           19,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
           27,
           "\xA2\x8C\x68\x65\x93\x9A\x9A\x79\xFA\xAA\x5C\x4C\x2A\x9D\x4A\x91\xCD\xAC\x8C\x96\xC8\x61\xB9\xC9\xE6\x1E\xF1"},
       { GCRY_CIPHER_AES, /* Packet Vector #5 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x07\x06\x05\x04\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           20,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
           28,
           "\xDC\xF1\xFB\x7B\x5D\x9E\x23\xFB\x9D\x4E\x13\x12\x53\x65\x8A\xD8\x6E\xBD\xCA\x3E\x51\xE8\x3F\x07\x7D\x9C\x2D\x93"},
       { GCRY_CIPHER_AES, /* Packet Vector #6 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x08\x07\x06\x05\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           21,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
           29,
           "\x6F\xC1\xB0\x11\xF0\x06\x56\x8B\x51\x71\xA4\x2D\x95\x3D\x46\x9B\x25\x70\xA4\xBD\x87\x40\x5A\x04\x43\xAC\x91\xCB\x94"},
       { GCRY_CIPHER_AES, /* Packet Vector #7 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x09\x08\x07\x06\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           23,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
           33,
           "\x01\x35\xD1\xB2\xC9\x5F\x41\xD5\xD1\xD4\xFE\xC1\x85\xD1\x66\xB8\x09\x4E\x99\x9D\xFE\xD9\x6C\x04\x8C\x56\x60\x2C\x97\xAC\xBB\x74\x90"},
       { GCRY_CIPHER_AES, /* Packet Vector #8 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x0A\x09\x08\x07\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           24,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
           34,
           "\x7B\x75\x39\x9A\xC0\x83\x1D\xD2\xF0\xBB\xD7\x58\x79\xA2\xFD\x8F\x6C\xAE\x6B\x6C\xD9\xB7\xDB\x24\xC1\x7B\x44\x33\xF4\x34\x96\x3F\x34\xB4"},
       { GCRY_CIPHER_AES, /* Packet Vector #9 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x0B\x0A\x09\x08\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           25,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
           35,
           "\x82\x53\x1A\x60\xCC\x24\x94\x5A\x4B\x82\x79\x18\x1A\xB5\xC8\x4D\xF2\x1C\xE7\xF9\xB7\x3F\x42\xE1\x97\xEA\x9C\x07\xE5\x6B\x5E\xB1\x7E\x5F\x4E"},
       { GCRY_CIPHER_AES, /* Packet Vector #10 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x0C\x0B\x0A\x09\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           19,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
           29,
           "\x07\x34\x25\x94\x15\x77\x85\x15\x2B\x07\x40\x98\x33\x0A\xBB\x14\x1B\x94\x7B\x56\x6A\xA9\x40\x6B\x4D\x99\x99\x88\xDD"},
       { GCRY_CIPHER_AES, /* Packet Vector #11 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x0D\x0C\x0B\x0A\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           20,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
           30,
           "\x67\x6B\xB2\x03\x80\xB0\xE3\x01\xE8\xAB\x79\x59\x0A\x39\x6D\xA7\x8B\x83\x49\x34\xF5\x3A\xA2\xE9\x10\x7A\x8B\x6C\x02\x2C"},
       { GCRY_CIPHER_AES, /* Packet Vector #12 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x0E\x0D\x0C\x0B\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           21,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
           31,
           "\xC0\xFF\xA0\xD6\xF0\x5B\xDB\x67\xF2\x4D\x43\xA4\x33\x8D\x2A\xA4\xBE\xD7\xB2\x0E\x43\xCD\x1A\xA3\x16\x62\xE7\xAD\x65\xD6\xDB"},
       { GCRY_CIPHER_AES, /* Packet Vector #13 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\x41\x2B\x4E\xA9\xCD\xBE\x3C\x96\x96\x76\x6C\xFA",
           8, "\x0B\xE1\xA8\x8B\xAC\xE0\x18\xB1",
           23,
           "\x08\xE8\xCF\x97\xD8\x20\xEA\x25\x84\x60\xE9\x6A\xD9\xCF\x52\x89\x05\x4D\x89\x5C\xEA\xC4\x7C",
           31,
           "\x4C\xB9\x7F\x86\xA2\xA4\x68\x9A\x87\x79\x47\xAB\x80\x91\xEF\x53\x86\xA6\xFF\xBD\xD0\x80\xF8\xE7\x8C\xF7\xCB\x0C\xDD\xD7\xB3"},
       { GCRY_CIPHER_AES, /* Packet Vector #14 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\x33\x56\x8E\xF7\xB2\x63\x3C\x96\x96\x76\x6C\xFA",
           8, "\x63\x01\x8F\x76\xDC\x8A\x1B\xCB",
           24,
           "\x90\x20\xEA\x6F\x91\xBD\xD8\x5A\xFA\x00\x39\xBA\x4B\xAF\xF9\xBF\xB7\x9C\x70\x28\x94\x9C\xD0\xEC",
           32,
           "\x4C\xCB\x1E\x7C\xA9\x81\xBE\xFA\xA0\x72\x6C\x55\xD3\x78\x06\x12\x98\xC8\x5C\x92\x81\x4A\xBC\x33\xC5\x2E\xE8\x1D\x7D\x77\xC0\x8A"},
       { GCRY_CIPHER_AES, /* Packet Vector #15 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\x10\x3F\xE4\x13\x36\x71\x3C\x96\x96\x76\x6C\xFA",
           8, "\xAA\x6C\xFA\x36\xCA\xE8\x6B\x40",
           25,
           "\xB9\x16\xE0\xEA\xCC\x1C\x00\xD7\xDC\xEC\x68\xEC\x0B\x3B\xBB\x1A\x02\xDE\x8A\x2D\x1A\xA3\x46\x13\x2E",
           33,
           "\xB1\xD2\x3A\x22\x20\xDD\xC0\xAC\x90\x0D\x9A\xA0\x3C\x61\xFC\xF4\xA5\x59\xA4\x41\x77\x67\x08\x97\x08\xA7\x76\x79\x6E\xDB\x72\x35\x06"},
       { GCRY_CIPHER_AES, /* Packet Vector #16 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\x76\x4C\x63\xB8\x05\x8E\x3C\x96\x96\x76\x6C\xFA",
           12, "\xD0\xD0\x73\x5C\x53\x1E\x1B\xEC\xF0\x49\xC2\x44",
           19,
           "\x12\xDA\xAC\x56\x30\xEF\xA5\x39\x6F\x77\x0C\xE1\xA6\x6B\x21\xF7\xB2\x10\x1C",
           27,
           "\x14\xD2\x53\xC3\x96\x7B\x70\x60\x9B\x7C\xBB\x7C\x49\x91\x60\x28\x32\x45\x26\x9A\x6F\x49\x97\x5B\xCA\xDE\xAF"},
       { GCRY_CIPHER_AES, /* Packet Vector #17 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\xF8\xB6\x78\x09\x4E\x3B\x3C\x96\x96\x76\x6C\xFA",
           12, "\x77\xB6\x0F\x01\x1C\x03\xE1\x52\x58\x99\xBC\xAE",
           20,
           "\xE8\x8B\x6A\x46\xC7\x8D\x63\xE5\x2E\xB8\xC5\x46\xEF\xB5\xDE\x6F\x75\xE9\xCC\x0D",
           28,
           "\x55\x45\xFF\x1A\x08\x5E\xE2\xEF\xBF\x52\xB2\xE0\x4B\xEE\x1E\x23\x36\xC7\x3E\x3F\x76\x2C\x0C\x77\x44\xFE\x7E\x3C"},
       { GCRY_CIPHER_AES, /* Packet Vector #18 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\xD5\x60\x91\x2D\x3F\x70\x3C\x96\x96\x76\x6C\xFA",
           12, "\xCD\x90\x44\xD2\xB7\x1F\xDB\x81\x20\xEA\x60\xC0",
           21,
           "\x64\x35\xAC\xBA\xFB\x11\xA8\x2E\x2F\x07\x1D\x7C\xA4\xA5\xEB\xD9\x3A\x80\x3B\xA8\x7F",
           29,
           "\x00\x97\x69\xEC\xAB\xDF\x48\x62\x55\x94\xC5\x92\x51\xE6\x03\x57\x22\x67\x5E\x04\xC8\x47\x09\x9E\x5A\xE0\x70\x45\x51"},
       { GCRY_CIPHER_AES, /* Packet Vector #19 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\x42\xFF\xF8\xF1\x95\x1C\x3C\x96\x96\x76\x6C\xFA",
           8, "\xD8\x5B\xC7\xE6\x9F\x94\x4F\xB8",
           23,
           "\x8A\x19\xB9\x50\xBC\xF7\x1A\x01\x8E\x5E\x67\x01\xC9\x17\x87\x65\x98\x09\xD6\x7D\xBE\xDD\x18",
           33,
           "\xBC\x21\x8D\xAA\x94\x74\x27\xB6\xDB\x38\x6A\x99\xAC\x1A\xEF\x23\xAD\xE0\xB5\x29\x39\xCB\x6A\x63\x7C\xF9\xBE\xC2\x40\x88\x97\xC6\xBA"},
       { GCRY_CIPHER_AES, /* Packet Vector #20 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\x92\x0F\x40\xE5\x6C\xDC\x3C\x96\x96\x76\x6C\xFA",
           8, "\x74\xA0\xEB\xC9\x06\x9F\x5B\x37",
           24,
           "\x17\x61\x43\x3C\x37\xC5\xA3\x5F\xC1\xF3\x9F\x40\x63\x02\xEB\x90\x7C\x61\x63\xBE\x38\xC9\x84\x37",
           34,
           "\x58\x10\xE6\xFD\x25\x87\x40\x22\xE8\x03\x61\xA4\x78\xE3\xE9\xCF\x48\x4A\xB0\x4F\x44\x7E\xFF\xF6\xF0\xA4\x77\xCC\x2F\xC9\xBF\x54\x89\x44"},
       { GCRY_CIPHER_AES, /* Packet Vector #21 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\x27\xCA\x0C\x71\x20\xBC\x3C\x96\x96\x76\x6C\xFA",
           8, "\x44\xA3\xAA\x3A\xAE\x64\x75\xCA",
           25,
           "\xA4\x34\xA8\xE5\x85\x00\xC6\xE4\x15\x30\x53\x88\x62\xD6\x86\xEA\x9E\x81\x30\x1B\x5A\xE4\x22\x6B\xFA",
           35,
           "\xF2\xBE\xED\x7B\xC5\x09\x8E\x83\xFE\xB5\xB3\x16\x08\xF8\xE2\x9C\x38\x81\x9A\x89\xC8\xE7\x76\xF1\x54\x4D\x41\x51\xA4\xED\x3A\x8B\x87\xB9\xCE"},
       { GCRY_CIPHER_AES, /* Packet Vector #22 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\x5B\x8C\xCB\xCD\x9A\xF8\x3C\x96\x96\x76\x6C\xFA",
           12, "\xEC\x46\xBB\x63\xB0\x25\x20\xC3\x3C\x49\xFD\x70",
           19,
           "\xB9\x6B\x49\xE2\x1D\x62\x17\x41\x63\x28\x75\xDB\x7F\x6C\x92\x43\xD2\xD7\xC2",
           29,
           "\x31\xD7\x50\xA0\x9D\xA3\xED\x7F\xDD\xD4\x9A\x20\x32\xAA\xBF\x17\xEC\x8E\xBF\x7D\x22\xC8\x08\x8C\x66\x6B\xE5\xC1\x97"},
       { GCRY_CIPHER_AES, /* Packet Vector #23 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\x3E\xBE\x94\x04\x4B\x9A\x3C\x96\x96\x76\x6C\xFA",
           12, "\x47\xA6\x5A\xC7\x8B\x3D\x59\x42\x27\xE8\x5E\x71",
           20,
           "\xE2\xFC\xFB\xB8\x80\x44\x2C\x73\x1B\xF9\x51\x67\xC8\xFF\xD7\x89\x5E\x33\x70\x76",
           30,
           "\xE8\x82\xF1\xDB\xD3\x8C\xE3\xED\xA7\xC2\x3F\x04\xDD\x65\x07\x1E\xB4\x13\x42\xAC\xDF\x7E\x00\xDC\xCE\xC7\xAE\x52\x98\x7D"},
       { GCRY_CIPHER_AES, /* Packet Vector #24 */
           16, "\xD7\x82\x8D\x13\xB2\xB0\xBD\xC3\x25\xA7\x62\x36\xDF\x93\xCC\x6B",
           13, "\x00\x8D\x49\x3B\x30\xAE\x8B\x3C\x96\x96\x76\x6C\xFA",
           12, "\x6E\x37\xA6\xEF\x54\x6D\x95\x5D\x34\xAB\x60\x59",
           21,
           "\xAB\xF2\x1C\x0B\x02\xFE\xB8\x8F\x85\x6D\xF4\xA3\x73\x81\xBC\xE3\xCC\x12\x85\x17\xD4",
           31,
           "\xF3\x29\x05\xB8\x8A\x64\x1B\x04\xB9\xC9\xFF\xB5\x8C\xC3\x90\x90\x0F\x3D\xA1\x2A\xB1\x6D\xCE\x9E\x82\xEF\xA1\x6D\xA6\x20\x59"},
       /* RFC 5528 */
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #1 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x03\x02\x01\x00\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           23,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
           31,
           "\xBA\x73\x71\x85\xE7\x19\x31\x04\x92\xF3\x8A\x5F\x12\x51\xDA\x55\xFA\xFB\xC9\x49\x84\x8A\x0D\xFC\xAE\xCE\x74\x6B\x3D\xB9\xAD"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #2 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x04\x03\x02\x01\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           24,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
           32,
           "\x5D\x25\x64\xBF\x8E\xAF\xE1\xD9\x95\x26\xEC\x01\x6D\x1B\xF0\x42\x4C\xFB\xD2\xCD\x62\x84\x8F\x33\x60\xB2\x29\x5D\xF2\x42\x83\xE8"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #3 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x05\x04\x03\x02\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           25,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
           33,
           "\x81\xF6\x63\xD6\xC7\x78\x78\x17\xF9\x20\x36\x08\xB9\x82\xAD\x15\xDC\x2B\xBD\x87\xD7\x56\xF7\x92\x04\xF5\x51\xD6\x68\x2F\x23\xAA\x46"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #4 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x06\x05\x04\x03\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           19,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
           27,
           "\xCA\xEF\x1E\x82\x72\x11\xB0\x8F\x7B\xD9\x0F\x08\xC7\x72\x88\xC0\x70\xA4\xA0\x8B\x3A\x93\x3A\x63\xE4\x97\xA0"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #5 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x07\x06\x05\x04\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           20,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
           28,
           "\x2A\xD3\xBA\xD9\x4F\xC5\x2E\x92\xBE\x43\x8E\x82\x7C\x10\x23\xB9\x6A\x8A\x77\x25\x8F\xA1\x7B\xA7\xF3\x31\xDB\x09"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #6 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x08\x07\x06\x05\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           21,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
           29,
           "\xFE\xA5\x48\x0B\xA5\x3F\xA8\xD3\xC3\x44\x22\xAA\xCE\x4D\xE6\x7F\xFA\x3B\xB7\x3B\xAB\xAB\x36\xA1\xEE\x4F\xE0\xFE\x28"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #7 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x09\x08\x07\x06\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           23,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
           33,
           "\x54\x53\x20\x26\xE5\x4C\x11\x9A\x8D\x36\xD9\xEC\x6E\x1E\xD9\x74\x16\xC8\x70\x8C\x4B\x5C\x2C\xAC\xAF\xA3\xBC\xCF\x7A\x4E\xBF\x95\x73"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #8 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x0A\x09\x08\x07\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           24,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
           34,
           "\x8A\xD1\x9B\x00\x1A\x87\xD1\x48\xF4\xD9\x2B\xEF\x34\x52\x5C\xCC\xE3\xA6\x3C\x65\x12\xA6\xF5\x75\x73\x88\xE4\x91\x3E\xF1\x47\x01\xF4\x41"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #9 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x0B\x0A\x09\x08\xA0\xA1\xA2\xA3\xA4\xA5",
           8, "\x00\x01\x02\x03\x04\x05\x06\x07",
           25,
           "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
           35,
           "\x5D\xB0\x8D\x62\x40\x7E\x6E\x31\xD6\x0F\x9C\xA2\xC6\x04\x74\x21\x9A\xC0\xBE\x50\xC0\xD4\xA5\x77\x87\x94\xD6\xE2\x30\xCD\x25\xC9\xFE\xBF\x87"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #10 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x0C\x0B\x0A\x09\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           19,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E",
           29,
           "\xDB\x11\x8C\xCE\xC1\xB8\x76\x1C\x87\x7C\xD8\x96\x3A\x67\xD6\xF3\xBB\xBC\x5C\xD0\x92\x99\xEB\x11\xF3\x12\xF2\x32\x37"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #11 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x0D\x0C\x0B\x0A\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           20,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
           30,
           "\x7C\xC8\x3D\x8D\xC4\x91\x03\x52\x5B\x48\x3D\xC5\xCA\x7E\xA9\xAB\x81\x2B\x70\x56\x07\x9D\xAF\xFA\xDA\x16\xCC\xCF\x2C\x4E"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #12 */
           16, "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF",
           13, "\x00\x00\x00\x0E\x0D\x0C\x0B\xA0\xA1\xA2\xA3\xA4\xA5",
           12, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B",
           21,
           "\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20",
           31,
           "\x2C\xD3\x5B\x88\x20\xD2\x3E\x7A\xA3\x51\xB0\xE9\x2F\xC7\x93\x67\x23\x8B\x2C\xC7\x48\xCB\xB9\x4C\x29\x47\x79\x3D\x64\xAF\x75"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #13 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\xA9\x70\x11\x0E\x19\x27\xB1\x60\xB6\xA3\x1C\x1C",
           8, "\x6B\x7F\x46\x45\x07\xFA\xE4\x96",
           23,
           "\xC6\xB5\xF3\xE6\xCA\x23\x11\xAE\xF7\x47\x2B\x20\x3E\x73\x5E\xA5\x61\xAD\xB1\x7D\x56\xC5\xA3",
           31,
           "\xA4\x35\xD7\x27\x34\x8D\xDD\x22\x90\x7F\x7E\xB8\xF5\xFD\xBB\x4D\x93\x9D\xA6\x52\x4D\xB4\xF6\x45\x58\xC0\x2D\x25\xB1\x27\xEE"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #14 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\x83\xCD\x8C\xE0\xCB\x42\xB1\x60\xB6\xA3\x1C\x1C",
           8, "\x98\x66\x05\xB4\x3D\xF1\x5D\xE7",
           24,
           "\x01\xF6\xCE\x67\x64\xC5\x74\x48\x3B\xB0\x2E\x6B\xBF\x1E\x0A\xBD\x26\xA2\x25\x72\xB4\xD8\x0E\xE7",
           32,
           "\x8A\xE0\x52\x50\x8F\xBE\xCA\x93\x2E\x34\x6F\x05\xE0\xDC\x0D\xFB\xCF\x93\x9E\xAF\xFA\x3E\x58\x7C\x86\x7D\x6E\x1C\x48\x70\x38\x06"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #15 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\x5F\x54\x95\x0B\x18\xF2\xB1\x60\xB6\xA3\x1C\x1C",
           8, "\x48\xF2\xE7\xE1\xA7\x67\x1A\x51",
           25,
           "\xCD\xF1\xD8\x40\x6F\xC2\xE9\x01\x49\x53\x89\x70\x05\xFB\xFB\x8B\xA5\x72\x76\xF9\x24\x04\x60\x8E\x08",
           33,
           "\x08\xB6\x7E\xE2\x1C\x8B\xF2\x6E\x47\x3E\x40\x85\x99\xE9\xC0\x83\x6D\x6A\xF0\xBB\x18\xDF\x55\x46\x6C\xA8\x08\x78\xA7\x90\x47\x6D\xE5"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #16 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\xEC\x60\x08\x63\x31\x9A\xB1\x60\xB6\xA3\x1C\x1C",
           12, "\xDE\x97\xDF\x3B\x8C\xBD\x6D\x8E\x50\x30\xDA\x4C",
           19,
           "\xB0\x05\xDC\xFA\x0B\x59\x18\x14\x26\xA9\x61\x68\x5A\x99\x3D\x8C\x43\x18\x5B",
           27,
           "\x63\xB7\x8B\x49\x67\xB1\x9E\xDB\xB7\x33\xCD\x11\x14\xF6\x4E\xB2\x26\x08\x93\x68\xC3\x54\x82\x8D\x95\x0C\xC5"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #17 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\x60\xCF\xF1\xA3\x1E\xA1\xB1\x60\xB6\xA3\x1C\x1C",
           12, "\xA5\xEE\x93\xE4\x57\xDF\x05\x46\x6E\x78\x2D\xCF",
           20,
           "\x2E\x20\x21\x12\x98\x10\x5F\x12\x9D\x5E\xD9\x5B\x93\xF7\x2D\x30\xB2\xFA\xCC\xD7",
           28,
           "\x0B\xC6\xBB\xE2\xA8\xB9\x09\xF4\x62\x9E\xE6\xDC\x14\x8D\xA4\x44\x10\xE1\x8A\xF4\x31\x47\x38\x32\x76\xF6\x6A\x9F"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #18 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\x0F\x85\xCD\x99\x5C\x97\xB1\x60\xB6\xA3\x1C\x1C",
           12, "\x24\xAA\x1B\xF9\xA5\xCD\x87\x61\x82\xA2\x50\x74",
           21,
           "\x26\x45\x94\x1E\x75\x63\x2D\x34\x91\xAF\x0F\xC0\xC9\x87\x6C\x3B\xE4\xAA\x74\x68\xC9",
           29,
           "\x22\x2A\xD6\x32\xFA\x31\xD6\xAF\x97\x0C\x34\x5F\x7E\x77\xCA\x3B\xD0\xDC\x25\xB3\x40\xA1\xA3\xD3\x1F\x8D\x4B\x44\xB7"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #19 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\xC2\x9B\x2C\xAA\xC4\xCD\xB1\x60\xB6\xA3\x1C\x1C",
           8, "\x69\x19\x46\xB9\xCA\x07\xBE\x87",
           23,
           "\x07\x01\x35\xA6\x43\x7C\x9D\xB1\x20\xCD\x61\xD8\xF6\xC3\x9C\x3E\xA1\x25\xFD\x95\xA0\xD2\x3D",
           33,
           "\x05\xB8\xE1\xB9\xC4\x9C\xFD\x56\xCF\x13\x0A\xA6\x25\x1D\xC2\xEC\xC0\x6C\xCC\x50\x8F\xE6\x97\xA0\x06\x6D\x57\xC8\x4B\xEC\x18\x27\x68"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #20 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\x2C\x6B\x75\x95\xEE\x62\xB1\x60\xB6\xA3\x1C\x1C",
           8, "\xD0\xC5\x4E\xCB\x84\x62\x7D\xC4",
           24,
           "\xC8\xC0\x88\x0E\x6C\x63\x6E\x20\x09\x3D\xD6\x59\x42\x17\xD2\xE1\x88\x77\xDB\x26\x4E\x71\xA5\xCC",
           34,
           "\x54\xCE\xB9\x68\xDE\xE2\x36\x11\x57\x5E\xC0\x03\xDF\xAA\x1C\xD4\x88\x49\xBD\xF5\xAE\x2E\xDB\x6B\x7F\xA7\x75\xB1\x50\xED\x43\x83\xC5\xA9"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #21 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\xC5\x3C\xD4\xC2\xAA\x24\xB1\x60\xB6\xA3\x1C\x1C",
           8, "\xE2\x85\xE0\xE4\x80\x8C\xDA\x3D",
           25,
           "\xF7\x5D\xAA\x07\x10\xC4\xE6\x42\x97\x79\x4D\xC2\xB7\xD2\xA2\x07\x57\xB1\xAA\x4E\x44\x80\x02\xFF\xAB",
           35,
           "\xB1\x40\x45\x46\xBF\x66\x72\x10\xCA\x28\xE3\x09\xB3\x9B\xD6\xCA\x7E\x9F\xC8\x28\x5F\xE6\x98\xD4\x3C\xD2\x0A\x02\xE0\xBD\xCA\xED\x20\x10\xD3"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #22 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\xBE\xE9\x26\x7F\xBA\xDC\xB1\x60\xB6\xA3\x1C\x1C",
           12, "\x6C\xAE\xF9\x94\x11\x41\x57\x0D\x7C\x81\x34\x05",
           19,
           "\xC2\x38\x82\x2F\xAC\x5F\x98\xFF\x92\x94\x05\xB0\xAD\x12\x7A\x4E\x41\x85\x4E",
           29,
           "\x94\xC8\x95\x9C\x11\x56\x9A\x29\x78\x31\xA7\x21\x00\x58\x57\xAB\x61\xB8\x7A\x2D\xEA\x09\x36\xB6\xEB\x5F\x62\x5F\x5D"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #23 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\xDF\xA8\xB1\x24\x50\x07\xB1\x60\xB6\xA3\x1C\x1C",
           12, "\x36\xA5\x2C\xF1\x6B\x19\xA2\x03\x7A\xB7\x01\x1E",
           20,
           "\x4D\xBF\x3E\x77\x4A\xD2\x45\xE5\xD5\x89\x1F\x9D\x1C\x32\xA0\xAE\x02\x2C\x85\xD7",
           30,
           "\x58\x69\xE3\xAA\xD2\x44\x7C\x74\xE0\xFC\x05\xF9\xA4\xEA\x74\x57\x7F\x4D\xE8\xCA\x89\x24\x76\x42\x96\xAD\x04\x11\x9C\xE7"},
       { GCRY_CIPHER_CAMELLIA128, /* Packet Vector #24 */
           16, "\xD7\x5C\x27\x78\x07\x8C\xA9\x3D\x97\x1F\x96\xFD\xE7\x20\xF4\xCD",
           13, "\x00\x3B\x8F\xD8\xD3\xA9\x37\xB1\x60\xB6\xA3\x1C\x1C",
           12, "\xA4\xD4\x99\xF7\x84\x19\x72\x8C\x19\x17\x8B\x0C",
           21,
           "\x9D\xC9\xED\xAE\x2F\xF5\xDF\x86\x36\xE8\xC6\xDE\x0E\xED\x55\xF7\x86\x7E\x33\x33\x7D",
           31,
           "\x4B\x19\x81\x56\x39\x3B\x0F\x77\x96\x08\x6A\xAF\xB4\x54\xF8\xC3\xF0\x34\xCC\xA9\x66\x94\x5F\x1F\xCE\xA7\xE1\x1B\xEE\x6A\x2F"}
     };
   static const int cut[] = { 0, 1, 8, 10, 16, 19, -1 };
   gcry_cipher_hd_t hde, hdd;
   unsigned char out[MAX_DATA_LEN];
   u64 ctl_params[3];
   int split, aadsplit;
   size_t j, i, keylen, blklen, authlen, taglen2;
   gcry_error_t err = 0;
 
   if (verbose)
     fprintf (stderr, "  Starting CCM checks.\n");
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     tv[i].algo);
           continue;
         }
 
       if (verbose)
         fprintf (stderr, "    checking CCM mode for %s [%i]\n",
                  gcry_cipher_algo_name (tv[i].algo),
                  tv[i].algo);
 
       for (j = 0; j < sizeof (cut) / sizeof (cut[0]); j++)
         {
           split = cut[j] < 0 ? tv[i].plainlen : cut[j];
           if (tv[i].plainlen < split)
             continue;
 
           err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_CCM, 0);
           if (!err)
             err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_CCM, 0);
           if (err)
             {
               fail ("cipher-ccm, gcry_cipher_open failed: %s\n",
                     gpg_strerror (err));
               return;
             }
 
           keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
           if (!keylen)
             {
               fail ("cipher-ccm, gcry_cipher_get_algo_keylen failed\n");
               return;
             }
 
           err = gcry_cipher_setkey (hde, tv[i].key, keylen);
           if (!err)
             err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
           if (err)
             {
               fail ("cipher-ccm, gcry_cipher_setkey failed: %s\n",
                     gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
           if (!blklen)
             {
               fail ("cipher-ccm, gcry_cipher_get_algo_blklen failed\n");
               return;
             }
 
           err = gcry_cipher_setiv (hde, tv[i].nonce, tv[i].noncelen);
           if (!err)
             err = gcry_cipher_setiv (hdd, tv[i].nonce, tv[i].noncelen);
           if (err)
             {
               fail ("cipher-ccm, gcry_cipher_setiv failed: %s\n",
                     gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           authlen = tv[i].cipherlen - tv[i].plainlen;
           ctl_params[0] = tv[i].plainlen; /* encryptedlen */
           ctl_params[1] = tv[i].aadlen; /* aadlen */
           ctl_params[2] = authlen; /* authtaglen */
           err = gcry_cipher_ctl (hde, GCRYCTL_SET_CCM_LENGTHS, ctl_params,
                                  sizeof(ctl_params));
           if (!err)
             err = gcry_cipher_ctl (hdd, GCRYCTL_SET_CCM_LENGTHS, ctl_params,
                                    sizeof(ctl_params));
           if (err)
             {
               fail ("cipher-ccm, gcry_cipher_ctl GCRYCTL_SET_CCM_LENGTHS "
                     "failed: %s\n", gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           err = gcry_cipher_info (hde, GCRYCTL_GET_TAGLEN, NULL, &taglen2);
           if (err)
             {
               fail ("cipher-ccm, gcryctl_get_taglen failed (tv %lu): %s\n",
                     (unsigned long) i, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
           if (taglen2 != authlen)
             {
               fail ("cipher-ccm, gcryctl_get_taglen returned bad length"
                     " (tv %lu): got=%zu want=%zu\n",
                     (unsigned long) i, taglen2, authlen);
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           aadsplit = split > tv[i].aadlen ? 0 : split;
 
           err = gcry_cipher_authenticate (hde, tv[i].aad,
                                           tv[i].aadlen - aadsplit);
           if (!err)
             err = gcry_cipher_authenticate (hde,
                                             &tv[i].aad[tv[i].aadlen - aadsplit],
                                             aadsplit);
           if (!err)
             err = gcry_cipher_authenticate (hdd, tv[i].aad,
                                             tv[i].aadlen - aadsplit);
           if (!err)
             err = gcry_cipher_authenticate (hdd,
                                             &tv[i].aad[tv[i].aadlen - aadsplit],
                                             aadsplit);
           if (err)
             {
               fail ("cipher-ccm, gcry_cipher_authenticate failed: %s\n",
                    gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN, tv[i].plaintext,
                                      tv[i].plainlen - split);
           if (!err)
             err = gcry_cipher_encrypt (hde, &out[tv[i].plainlen - split],
                                        MAX_DATA_LEN - (tv[i].plainlen - split),
                                        &tv[i].plaintext[tv[i].plainlen - split],
                                        split);
           if (err)
             {
               fail ("cipher-ccm, gcry_cipher_encrypt (%lu:%lu) failed: %s\n",
                     (unsigned long) i, (unsigned long) j, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           err = gcry_cipher_gettag (hde, &out[tv[i].plainlen], authlen);
           if (err)
             {
               fail ("cipher-ccm, gcry_cipher_gettag (%lu:%lu) failed: %s\n",
                     (unsigned long) i, (unsigned long) j, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           if (memcmp (tv[i].ciphertext, out, tv[i].cipherlen))
             fail ("cipher-ccm, encrypt mismatch entry %lu:%lu\n",
 		  (unsigned long) i, (unsigned long) j);
 
           err = gcry_cipher_decrypt (hdd, out, tv[i].plainlen - split, NULL, 0);
           if (!err)
             err = gcry_cipher_decrypt (hdd, &out[tv[i].plainlen - split], split,
                                        NULL, 0);
           if (err)
             {
               fail ("cipher-ccm, gcry_cipher_decrypt (%lu:%lu) failed: %s\n",
                     (unsigned long) i, (unsigned long) j, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           if (memcmp (tv[i].plaintext, out, tv[i].plainlen))
             fail ("cipher-ccm, decrypt mismatch entry %lu:%lu\n",
 		  (unsigned long) i, (unsigned long) j);
 
           err = gcry_cipher_checktag (hdd, &out[tv[i].plainlen], authlen);
           if (err)
             {
               fail ("cipher-ccm, gcry_cipher_checktag (%lu:%lu) failed: %s\n",
                     (unsigned long) i, (unsigned long) j, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
 
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
         }
     }
 
   /* Large buffer tests.  */
 
   /* Test encoding of aadlen > 0xfeff.  */
   {
     static const char key[]={0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
                              0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f};
     static const char iv[]={0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19};
     static const char tag[]={0x9C,0x76,0xE7,0x33,0xD5,0x15,0xB3,0x6C,
                              0xBA,0x76,0x95,0xF7,0xFB,0x91};
     char buf[1024];
     size_t enclen = 0x20000;
     size_t aadlen = 0x20000;
     size_t taglen = sizeof(tag);
 
     err = gcry_cipher_open (&hde, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CCM, 0);
     if (err)
       {
         fail ("cipher-ccm-large, gcry_cipher_open failed: %s\n",
               gpg_strerror (err));
         return;
       }
 
     err = gcry_cipher_setkey (hde, key, sizeof (key));
     if (err)
       {
          fail ("cipher-ccm-large, gcry_cipher_setkey failed: %s\n",
                gpg_strerror (err));
          gcry_cipher_close (hde);
          return;
       }
 
     err = gcry_cipher_setiv (hde, iv, sizeof (iv));
     if (err)
       {
         fail ("cipher-ccm-large, gcry_cipher_setiv failed: %s\n",
               gpg_strerror (err));
         gcry_cipher_close (hde);
         return;
       }
 
     ctl_params[0] = enclen; /* encryptedlen */
     ctl_params[1] = aadlen; /* aadlen */
     ctl_params[2] = taglen; /* authtaglen */
     err = gcry_cipher_ctl (hde, GCRYCTL_SET_CCM_LENGTHS, ctl_params,
                            sizeof(ctl_params));
     if (err)
       {
         fail ("cipher-ccm-large, gcry_cipher_ctl GCRYCTL_SET_CCM_LENGTHS "
               "failed: %s\n", gpg_strerror (err));
         gcry_cipher_close (hde);
         return;
       }
 
     memset (buf, 0xaa, sizeof(buf));
 
     for (i = 0; i < aadlen; i += sizeof(buf))
       {
         err = gcry_cipher_authenticate (hde, buf, sizeof (buf));
         if (err)
           {
             fail ("cipher-ccm-large, gcry_cipher_authenticate failed: %s\n",
                  gpg_strerror (err));
             gcry_cipher_close (hde);
             return;
           }
       }
 
     for (i = 0; i < enclen; i += sizeof(buf))
       {
         memset (buf, 0xee, sizeof(buf));
         err = gcry_cipher_encrypt (hde, buf, sizeof (buf), NULL, 0);
         if (err)
           {
             fail ("cipher-ccm-large, gcry_cipher_encrypt failed: %s\n",
                  gpg_strerror (err));
             gcry_cipher_close (hde);
             return;
           }
       }
 
     err = gcry_cipher_gettag (hde, buf, taglen);
     if (err)
       {
         fail ("cipher-ccm-large, gcry_cipher_gettag failed: %s\n",
               gpg_strerror (err));
         gcry_cipher_close (hde);
         return;
       }
 
     if (memcmp (buf, tag, taglen) != 0)
       fail ("cipher-ccm-large, encrypt mismatch entry\n");
 
     gcry_cipher_close (hde);
   }
 
 #if 0
   /* Test encoding of aadlen > 0xffffffff.  */
   {
     static const char key[]={0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
                              0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f};
     static const char iv[]={0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19};
     static const char tag[]={0x01,0xB2,0xC3,0x4A,0xA6,0x6A,0x07,0x6D,
                              0xBC,0xBD,0xEA,0x17,0xD3,0x73,0xD7,0xD4};
     char buf[1024];
     size_t enclen = (size_t)0xffffffff + 1 + 1024;
     size_t aadlen = (size_t)0xffffffff + 1 + 1024;
     size_t taglen = sizeof(tag);
 
     err = gcry_cipher_open (&hde, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CCM, 0);
     if (err)
       {
         fail ("cipher-ccm-huge, gcry_cipher_open failed: %s\n",
               gpg_strerror (err));
         return;
       }
 
     err = gcry_cipher_setkey (hde, key, sizeof (key));
     if (err)
       {
          fail ("cipher-ccm-huge, gcry_cipher_setkey failed: %s\n",
                gpg_strerror (err));
          gcry_cipher_close (hde);
          return;
       }
 
     err = gcry_cipher_setiv (hde, iv, sizeof (iv));
     if (err)
       {
         fail ("cipher-ccm-huge, gcry_cipher_setiv failed: %s\n",
               gpg_strerror (err));
         gcry_cipher_close (hde);
         return;
       }
 
     ctl_params[0] = enclen; /* encryptedlen */
     ctl_params[1] = aadlen; /* aadlen */
     ctl_params[2] = taglen; /* authtaglen */
     err = gcry_cipher_ctl (hde, GCRYCTL_SET_CCM_LENGTHS, ctl_params,
                            sizeof(ctl_params));
     if (err)
       {
         fail ("cipher-ccm-huge, gcry_cipher_ctl GCRYCTL_SET_CCM_LENGTHS failed:"
               "%s\n", gpg_strerror (err));
         gcry_cipher_close (hde);
         return;
       }
 
     memset (buf, 0xaa, sizeof(buf));
 
     for (i = 0; i < aadlen; i += sizeof(buf))
       {
         err = gcry_cipher_authenticate (hde, buf, sizeof (buf));
         if (err)
           {
             fail ("cipher-ccm-huge, gcry_cipher_authenticate failed: %s\n",
                  gpg_strerror (err));
             gcry_cipher_close (hde);
             return;
           }
       }
 
     for (i = 0; i < enclen; i += sizeof(buf))
       {
         memset (buf, 0xee, sizeof(buf));
         err = gcry_cipher_encrypt (hde, buf, sizeof (buf), NULL, 0);
         if (err)
           {
             fail ("cipher-ccm-huge, gcry_cipher_encrypt failed: %s\n",
                  gpg_strerror (err));
             gcry_cipher_close (hde);
             return;
           }
       }
 
     err = gcry_cipher_gettag (hde, buf, taglen);
     if (err)
       {
         fail ("cipher-ccm-huge, gcry_cipher_gettag failed: %s\n",
               gpg_strerror (err));
         gcry_cipher_close (hde);
         return;
       }
 
     if (memcmp (buf, tag, taglen) != 0)
       fail ("cipher-ccm-huge, encrypt mismatch entry\n");
 
     gcry_cipher_close (hde);
   }
 
   if (verbose)
     fprintf (stderr, "  Completed CCM checks.\n");
 #endif
 }
 
 
 static void
 do_check_ocb_cipher (int inplace)
 {
   /* Note that we use hex strings and not binary strings in TV.  That
      makes it easier to maintain the test vectors.  */
   static const struct
   {
     int algo;
     int taglen;         /* 16, 12, or 8 bytes  */
     const char *key;    /* NULL means "000102030405060708090A0B0C0D0E0F" */
     const char *nonce;
     const char *aad;
     const char *plain;
     const char *ciph;
   } tv[] = {
     /* The RFC-7253 test vectos*/
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA99887766554433221100",
       "",
       "",
       "785407BFFFC8AD9EDCC5520AC9111EE6"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA99887766554433221101",
       "0001020304050607",
       "0001020304050607",
       "6820B3657B6F615A5725BDA0D3B4EB3A257C9AF1F8F03009"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA99887766554433221102",
       "0001020304050607",
       "",
       "81017F8203F081277152FADE694A0A00"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA99887766554433221103",
       "",
       "0001020304050607",
       "45DD69F8F5AAE72414054CD1F35D82760B2CD00D2F99BFA9"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA99887766554433221104",
       "000102030405060708090A0B0C0D0E0F",
       "000102030405060708090A0B0C0D0E0F",
       "571D535B60B277188BE5147170A9A22C3AD7A4FF3835B8C5"
       "701C1CCEC8FC3358"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA99887766554433221105",
       "000102030405060708090A0B0C0D0E0F",
       "",
       "8CF761B6902EF764462AD86498CA6B97"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA99887766554433221106",
       "",
       "000102030405060708090A0B0C0D0E0F",
       "5CE88EC2E0692706A915C00AEB8B2396F40E1C743F52436B"
       "DF06D8FA1ECA343D"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA99887766554433221107",
       "000102030405060708090A0B0C0D0E0F1011121314151617",
       "000102030405060708090A0B0C0D0E0F1011121314151617",
       "1CA2207308C87C010756104D8840CE1952F09673A448A122"
       "C92C62241051F57356D7F3C90BB0E07F"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA99887766554433221108",
       "000102030405060708090A0B0C0D0E0F1011121314151617",
       "",
       "6DC225A071FC1B9F7C69F93B0F1E10DE"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA99887766554433221109",
       "",
       "000102030405060708090A0B0C0D0E0F1011121314151617",
       "221BD0DE7FA6FE993ECCD769460A0AF2D6CDED0C395B1C3C"
       "E725F32494B9F914D85C0B1EB38357FF"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA9988776655443322110A",
       "000102030405060708090A0B0C0D0E0F1011121314151617"
       "18191A1B1C1D1E1F",
       "000102030405060708090A0B0C0D0E0F1011121314151617"
       "18191A1B1C1D1E1F",
       "BD6F6C496201C69296C11EFD138A467ABD3C707924B964DE"
       "AFFC40319AF5A48540FBBA186C5553C68AD9F592A79A4240"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA9988776655443322110B",
       "000102030405060708090A0B0C0D0E0F1011121314151617"
       "18191A1B1C1D1E1F",
       "",
       "FE80690BEE8A485D11F32965BC9D2A32"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA9988776655443322110C",
       "",
       "000102030405060708090A0B0C0D0E0F1011121314151617"
       "18191A1B1C1D1E1F",
       "2942BFC773BDA23CABC6ACFD9BFD5835BD300F0973792EF4"
       "6040C53F1432BCDFB5E1DDE3BC18A5F840B52E653444D5DF"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA9988776655443322110D",
       "000102030405060708090A0B0C0D0E0F1011121314151617"
       "18191A1B1C1D1E1F2021222324252627",
       "000102030405060708090A0B0C0D0E0F1011121314151617"
       "18191A1B1C1D1E1F2021222324252627",
       "D5CA91748410C1751FF8A2F618255B68A0A12E093FF45460"
       "6E59F9C1D0DDC54B65E8628E568BAD7AED07BA06A4A69483"
       "A7035490C5769E60"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA9988776655443322110E",
       "000102030405060708090A0B0C0D0E0F1011121314151617"
       "18191A1B1C1D1E1F2021222324252627",
       "",
       "C5CD9D1850C141E358649994EE701B68"
     },
     { GCRY_CIPHER_AES, 16, NULL,
       "BBAA9988776655443322110F",
       "",
       "000102030405060708090A0B0C0D0E0F1011121314151617"
       "18191A1B1C1D1E1F2021222324252627",
       "4412923493C57D5DE0D700F753CCE0D1D2D95060122E9F15"
       "A5DDBFC5787E50B5CC55EE507BCB084E479AD363AC366B95"
       "A98CA5F3000B1479"
     },
     { GCRY_CIPHER_AES, 12, "0F0E0D0C0B0A09080706050403020100",
       "BBAA9988776655443322110D",
       "000102030405060708090A0B0C0D0E0F1011121314151617"
       "18191A1B1C1D1E1F2021222324252627",
       "000102030405060708090A0B0C0D0E0F1011121314151617"
       "18191A1B1C1D1E1F2021222324252627",
       "1792A4E31E0755FB03E31B22116E6C2DDF9EFD6E33D536F1"
       "A0124B0A55BAE884ED93481529C76B6AD0C515F4D1CDD4FD"
       "AC4F02AA"
     },
     { GCRY_CIPHER_AES, 12, "0F0E0D0C0B0A09080706050403020100",
       "BBAA9988776655443322110D",
       "000102030405060708090A0B0C0D0E0F1011121314151617"
       "18191A1B1C1D1E1F2021222324252627",
       /* test vector for checksumming */
       "01000000000000000000000000000000"
       "02000000000000000000000000000000"
       "04000000000000000000000000000000"
       "08000000000000000000000000000000"
       "10000000000000000000000000000000"
       "20000000000000000000000000000000"
       "40000000000000000000000000000000"
       "80000000000000000000000000000000"
       "00010000000000000000000000000000"
       "00020000000000000000000000000000"
       "00040000000000000000000000000000"
       "00080000000000000000000000000000"
       "00100000000000000000000000000000"
       "00200000000000000000000000000000"
       "00400000000000000000000000000000"
       "00800000000000000000000000000000"
       "00000100000000000000000000000000"
       "00000200000000000000000000000000"
       "00000400000000000000000000000000"
       "00000800000000000000000000000000"
       "00001000000000000000000000000000"
       "00002000000000000000000000000000"
       "00004000000000000000000000000000"
       "00008000000000000000000000000000"
       "00000001000000000000000000000000"
       "00000002000000000000000000000000"
       "00000004000000000000000000000000"
       "00000008000000000000000000000000"
       "00000010000000000000000000000000"
       "00000020000000000000000000000000"
       "00000040000000000000000000000000"
       "00000080000000000000000000000000"
       "00000000010000000000000000000000"
       "00000000020000000000000000000000"
       "00000000040000000000000000000000"
       "00000000080000000000000000000000"
       "00000000100000000000000000000000"
       "00000000200000000000000000000000"
       "00000000400000000000000000000000"
       "00000000800000000000000000000000"
       "00000000000100000000000000000000"
       "00000000000200000000000000000000"
       "00000000000400000000000000000000"
       "00000000000800000000000000000000"
       "00000000001000000000000000000000"
       "00000000002000000000000000000000"
       "00000000004000000000000000000000"
       "00000000008000000000000000000000",
       "01105c6e36f6ac480f022c51e31ed702"
       "90fda4b7b783194d4b4be8e4e1e2dff4"
       "6a0804d1c5f9f808ea7933e31c063233"
       "2bf65a22b20bb13cde3b80b3682ba965"
       "b1207c58916f7856fa9968b410e50dee"
       "98b35c071163d1b352b9bbccd09fde29"
       "b850f40e71a8ae7d2e2d577f5ee39c46"
       "7fa28130b50a123c29958e4665dda9a5"
       "e0793997f8f19633a96392141d6e0e88"
       "77850ed4364065d1d2f8746e2f1d5fd1"
       "996cdde03215306503a30e41f58ef3c4"
       "400365cfea4fa6381157c12a46598edf"
       "18604854462ec66e3d3cf26d4723cb6a"
       "9d801095048086a606fdb9192760889b"
       "a8ce2e70e1b55a469137a9e2e6734565"
       "283cb1e2c74f37e0854d03e33f8ba499"
       "ef5d9af4edfce077c6280338f0a64286"
       "2e6bc27ebd5a4c91b3778e22631251c8"
       "c5bb75a10945597a9d6c274fc82d3338"
       "b403a0a549d1375f26e71ef22bce0941"
       "93ea87e2ed72fce0546148c351eec3be"
       "867bb1b96070c377fff3c98e21562beb"
       "475cfe28abcaaedf49981f6599b15140"
       "ea6130d24407079f18ba9d4a8960b082"
       "b39c57320e2e064f02fde88c23112146"
       "1cac3655868aef584714826ee4f361fb"
       "e6d692e1589cbb9dd3c74fa628df2a1f"
       "3b0029b1d62b7e9978013ed3c793c1dd"
       "1f184c8f7022a853cac40b74ac749aa3"
       "f33f0d14732dfda0f2c3c20591bf1f5a"
       "710ec0d0bca342baa5146068a78ff58c"
       "66316312b7a98af35a0f4e92799b4047"
       "f047ae61f25c28d232ce5c168cc745d6"
       "6da13cb0f9e38a696635dba7a21571cf"
       "cd64ec8cc33db7879f59a90d9edd00f6"
       "a899e39ab36b9269a3ac04ebad9326bf"
       "53cd9b400168a61714cd628a4056d236"
       "bd8622c76daa54cb65f5db2fe03bafbe"
       "0b23549ae31136f607293e8093a21934"
       "74fd5e9c2451b4c8e0499e6ad34fafc8"
       "ab77722a282f7f84b14ddebf7e696300"
       "c1ef92d4a0263c6cca104530f996e272"
       "f58992ff68d642b071a5848dc4acf2ae"
       "28fb1f27ae0f297d5136a7a0a4a03e89"
       "b588755b8217a1c62773790e69261269"
       "19f45daf7b3ccf18e3fc590a9a0e172f"
       "033ac4d13c3decc4c62d7de718ace802"
       "140452dc850989f6762e3578bbb04be3"
       "1a237c599c4649f4e586b2de"
     }
   };
   gpg_error_t err = 0;
   gcry_cipher_hd_t hde, hdd;
   unsigned char out[1024];
   unsigned char tag[16];
   int tidx;
 
   if (verbose)
     fprintf (stderr, "  Starting OCB checks.\n");
 
   for (tidx = 0; tidx < DIM (tv); tidx++)
     {
       char *key, *nonce, *aad, *ciph, *plain;
       size_t keylen, noncelen, aadlen, ciphlen, plainlen;
       int taglen;
       size_t taglen2;
 
       if (verbose)
         fprintf (stderr, "    checking OCB mode for %s [%i] (tv %d)\n",
                  gcry_cipher_algo_name (tv[tidx].algo), tv[tidx].algo, tidx);
 
       /* Convert to hex strings to binary.  */
       key   = hex2buffer (tv[tidx].key? tv[tidx].key
                           /*        */: "000102030405060708090A0B0C0D0E0F",
                           &keylen);
       nonce = hex2buffer (tv[tidx].nonce, &noncelen);
       aad   = hex2buffer (tv[tidx].aad, &aadlen);
       plain = hex2buffer (tv[tidx].plain, &plainlen);
       ciph  = hex2buffer (tv[tidx].ciph, &ciphlen);
 
       /* Check that our test vectors are sane.  */
       assert (plainlen <= sizeof out);
       assert (tv[tidx].taglen <= ciphlen);
       assert (tv[tidx].taglen <= sizeof tag);
 
       err = gcry_cipher_open (&hde, tv[tidx].algo, GCRY_CIPHER_MODE_OCB, 0);
       if (!err)
         err = gcry_cipher_open (&hdd, tv[tidx].algo, GCRY_CIPHER_MODE_OCB, 0);
       if (err)
         {
           fail ("cipher-ocb, gcry_cipher_open failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           return;
         }
 
       /* Set the taglen.  For the first handle we do this only for a
          non-default taglen.  For the second handle we check that we
          can also set to the default taglen.  */
       taglen = tv[tidx].taglen;
       if (taglen != 16)
         {
           err = gcry_cipher_ctl (hde, GCRYCTL_SET_TAGLEN,
                                  &taglen, sizeof taglen);
           if (err)
             {
               fail ("cipher-ocb, gcryctl_set_taglen failed (tv %d): %s\n",
                     tidx, gpg_strerror (err));
               gcry_cipher_close (hde);
               gcry_cipher_close (hdd);
               return;
             }
         }
       err = gcry_cipher_ctl (hdd, GCRYCTL_SET_TAGLEN,
                              &taglen, sizeof taglen);
       if (err)
         {
           fail ("cipher-ocb, gcryctl_set_taglen failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_info (hde, GCRYCTL_GET_TAGLEN, NULL, &taglen2);
       if (err)
         {
           fail ("cipher-ocb, gcryctl_get_taglen failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
       if (taglen2 != tv[tidx].taglen)
         {
           fail ("cipher-ocb, gcryctl_get_taglen returned bad length (tv %d): "
                 "got=%zu want=%d\n",
                 tidx, taglen2, tv[tidx].taglen);
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_setkey (hde, key, keylen);
       if (!err)
         err = gcry_cipher_setkey (hdd, key, keylen);
       if (err)
         {
           fail ("cipher-ocb, gcry_cipher_setkey failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_setiv (hde, nonce, noncelen);
       if (!err)
         err = gcry_cipher_setiv (hdd, nonce, noncelen);
       if (err)
         {
           fail ("cipher-ocb, gcry_cipher_setiv failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_authenticate (hde, aad, aadlen);
       if (err)
         {
           fail ("cipher-ocb, gcry_cipher_authenticate failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_final (hde);
       if (!err)
         {
           if (inplace)
             {
               memcpy(out, plain, plainlen);
               err = gcry_cipher_encrypt (hde, out, plainlen, NULL, 0);
             }
           else
             {
               err = gcry_cipher_encrypt (hde, out, sizeof(out),
                                          plain, plainlen);
             }
         }
       if (err)
         {
           fail ("cipher-ocb, gcry_cipher_encrypt failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       /* Check that the encrypt output matches the expected cipher
          text without the tag (i.e. at the length of plaintext).  */
       if (memcmp (ciph, out, plainlen))
         {
           mismatch (ciph, plainlen, out, plainlen);
           fail ("cipher-ocb, encrypt data mismatch (tv %d)\n", tidx);
         }
 
       /* Check that the tag matches TAGLEN bytes from the end of the
          expected ciphertext.  */
       err = gcry_cipher_gettag (hde, tag, tv[tidx].taglen);
       if (err)
         {
           fail ("cipher_ocb, gcry_cipher_gettag failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
         }
       if (memcmp (ciph + ciphlen - tv[tidx].taglen, tag, tv[tidx].taglen))
         {
           mismatch (ciph + ciphlen - tv[tidx].taglen, tv[tidx].taglen,
                     tag, tv[tidx].taglen);
           fail ("cipher-ocb, encrypt tag mismatch (tv %d)\n", tidx);
         }
 
 
       err = gcry_cipher_authenticate (hdd, aad, aadlen);
       if (err)
         {
           fail ("cipher-ocb, gcry_cipher_authenticate failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       /* Now for the decryption.  */
       err = gcry_cipher_final (hdd);
       if (!err)
         {
           if (inplace)
             {
               err = gcry_cipher_decrypt (hdd, out, plainlen, NULL, 0);
             }
           else
             {
               unsigned char tmp[sizeof(out)];
 
               memcpy(tmp, out, plainlen);
               err = gcry_cipher_decrypt (hdd, out, plainlen, tmp, plainlen);
             }
         }
       if (err)
         {
           fail ("cipher-ocb, gcry_cipher_decrypt (tv %d) failed: %s\n",
                 tidx, gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       /* We still have TAG from the encryption.  */
       err = gcry_cipher_checktag (hdd, tag, tv[tidx].taglen);
       if (err)
         {
           fail ("cipher-ocb, gcry_cipher_checktag failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
         }
 
       /* Check that the decrypt output matches the original plaintext.  */
       if (memcmp (plain, out, plainlen))
         {
           mismatch (plain, plainlen, out, plainlen);
           fail ("cipher-ocb, decrypt data mismatch (tv %d)\n", tidx);
         }
 
       /* Check that gettag also works for decryption.  */
       err = gcry_cipher_gettag (hdd, tag, tv[tidx].taglen);
       if (err)
         {
           fail ("cipher_ocb, decrypt gettag failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
         }
       if (memcmp (ciph + ciphlen - tv[tidx].taglen, tag, tv[tidx].taglen))
         {
           mismatch (ciph + ciphlen - tv[tidx].taglen, tv[tidx].taglen,
                     tag, tv[tidx].taglen);
           fail ("cipher-ocb, decrypt tag mismatch (tv %d)\n", tidx);
         }
 
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
 
       xfree (nonce);
       xfree (aad);
       xfree (ciph);
       xfree (plain);
       xfree (key);
     }
 
   if (verbose)
     fprintf (stderr, "  Completed OCB checks.\n");
 }
 
 
 static void
 check_ocb_cipher_largebuf_split (int algo, int keylen, const char *tagexpect,
 				 unsigned int splitpos)
 {
   static const unsigned char key[32] =
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F";
   static const unsigned char nonce[12] =
         "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x00\x01\x02\x03";
   const size_t buflen = 1024 * 1024 * 2 + 32;
   unsigned char *inbuf;
   unsigned char *outbuf;
   gpg_error_t err = 0;
   gcry_cipher_hd_t hde, hdd;
   unsigned char tag[16];
   int i;
 
   inbuf = xmalloc(buflen);
   if (!inbuf)
     {
       fail ("out-of-memory\n");
       return;
     }
   outbuf = xmalloc(buflen);
   if (!outbuf)
     {
       fail ("out-of-memory\n");
       xfree(inbuf);
       return;
     }
 
   for (i = 0; i < buflen; i++)
     inbuf[i] = (i + 181081) * 5039;
 
   err = gcry_cipher_open (&hde, algo, GCRY_CIPHER_MODE_OCB, 0);
   if (!err)
     err = gcry_cipher_open (&hdd, algo, GCRY_CIPHER_MODE_OCB, 0);
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_open failed (large, algo %d): %s\n",
             algo, gpg_strerror (err));
       goto out_free;
     }
 
   err = gcry_cipher_setkey (hde, key, keylen);
   if (!err)
     err = gcry_cipher_setkey (hdd, key, keylen);
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_setkey failed (large, algo %d): %s\n",
             algo, gpg_strerror (err));
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
       goto out_free;
     }
 
   err = gcry_cipher_setiv (hde, nonce, 12);
   if (!err)
     err = gcry_cipher_setiv (hdd, nonce, 12);
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_setiv failed (large, algo %d): %s\n",
             algo, gpg_strerror (err));
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
       goto out_free;
     }
 
   if (splitpos)
     {
       err = gcry_cipher_authenticate (hde, inbuf, splitpos);
     }
   if (!err)
     {
       err = gcry_cipher_authenticate (hde, inbuf + splitpos, buflen - splitpos);
     }
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_authenticate failed (large, algo %d): %s\n",
             algo, gpg_strerror (err));
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
       goto out_free;
     }
 
   if (splitpos)
     {
       err = gcry_cipher_encrypt (hde, outbuf, splitpos, inbuf, splitpos);
     }
   if (!err)
     {
       err = gcry_cipher_final (hde);
       if (!err)
 	{
 	  err = gcry_cipher_encrypt (hde, outbuf + splitpos, buflen - splitpos,
 				    inbuf + splitpos, buflen - splitpos);
 	}
     }
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_encrypt failed (large, algo %d): %s\n",
             algo, gpg_strerror (err));
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
       goto out_free;
     }
 
   /* Check that the tag matches. */
   err = gcry_cipher_gettag (hde, tag, 16);
   if (err)
     {
       fail ("cipher_ocb, gcry_cipher_gettag failed (large, algo %d): %s\n",
             algo, gpg_strerror (err));
     }
   if (memcmp (tagexpect, tag, 16))
     {
       mismatch (tagexpect, 16, tag, 16);
       fail ("cipher-ocb, encrypt tag mismatch (large, algo %d)\n", algo);
     }
 
   err = gcry_cipher_authenticate (hdd, inbuf, buflen);
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_authenticate failed (large, algo %d): %s\n",
             algo, gpg_strerror (err));
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
       goto out_free;
     }
 
   /* Now for the decryption.  */
   if (splitpos)
     {
       err = gcry_cipher_decrypt (hdd, outbuf, splitpos, NULL, 0);
     }
   if (!err)
     {
       err = gcry_cipher_final (hdd);
       if (!err)
 	{
 	  err = gcry_cipher_decrypt (hdd, outbuf + splitpos, buflen - splitpos,
 				     NULL, 0);
 	}
     }
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_decrypt (large, algo %d) failed: %s\n",
             algo, gpg_strerror (err));
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
       goto out_free;
     }
 
   /* We still have TAG from the encryption.  */
   err = gcry_cipher_checktag (hdd, tag, 16);
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_checktag failed (large, algo %d): %s\n",
             algo, gpg_strerror (err));
     }
 
   /* Check that the decrypt output matches the original plaintext.  */
   if (memcmp (inbuf, outbuf, buflen))
     {
       /*mismatch (inbuf, buflen, outbuf, buflen);*/
       fail ("cipher-ocb, decrypt data mismatch (large, algo %d)\n", algo);
     }
 
   /* Check that gettag also works for decryption.  */
   err = gcry_cipher_gettag (hdd, tag, 16);
   if (err)
     {
       fail ("cipher_ocb, decrypt gettag failed (large, algo %d): %s\n",
             algo, gpg_strerror (err));
     }
   if (memcmp (tagexpect, tag, 16))
     {
       mismatch (tagexpect, 16, tag, 16);
       fail ("cipher-ocb, decrypt tag mismatch (large, algo %d)\n", algo);
     }
 
   gcry_cipher_close (hde);
   gcry_cipher_close (hdd);
 
 out_free:
   xfree(outbuf);
   xfree(inbuf);
 }
 
 
 static void
 check_ocb_cipher_checksum (int algo, int keylen)
 {
   static const unsigned char key[32] =
 	"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
 	"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F";
   static const unsigned char nonce[12] =
 	"\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x00\x01\x02\x03";
   const size_t buflen = 128 * 16;
   unsigned char *inbuf, *outbuf;
   gpg_error_t err = 0;
   gcry_cipher_hd_t hde, hde2;
   unsigned char tag[16];
   unsigned char tag2[16];
   int i;
 
   inbuf = xmalloc(buflen);
   if (!inbuf)
     {
       fail ("out-of-memory\n");
       return;
     }
   outbuf = xmalloc(buflen);
   if (!inbuf)
     {
       fail ("out-of-memory\n");
       xfree(inbuf);
       return;
     }
 
   memset(inbuf, 0, buflen);
   for (i = 0; i < 128; i += 16)
     {
       unsigned char *blk = inbuf + i;
       int bit2set = i / 16;
       int byteidx = bit2set / 8;
       int bitpos = bit2set % 8;
 
       blk[byteidx] |= 1 << bitpos;
     }
 
   err = gcry_cipher_open (&hde, algo, GCRY_CIPHER_MODE_OCB, 0);
   if (!err)
     err = gcry_cipher_open (&hde2, algo, GCRY_CIPHER_MODE_OCB, 0);
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_open failed (checksum, algo %d): %s\n",
 	    algo, gpg_strerror (err));
       goto out_free;
     }
 
   err = gcry_cipher_setkey (hde, key, keylen);
   if (!err)
     err = gcry_cipher_setkey (hde2, key, keylen);
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_setkey failed (checksum, algo %d): %s\n",
 	    algo, gpg_strerror (err));
       gcry_cipher_close (hde);
       gcry_cipher_close (hde2);
       goto out_free;
     }
 
   err = gcry_cipher_setiv (hde, nonce, 12);
   if (!err)
     err = gcry_cipher_setiv (hde2, nonce, 12);
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_setiv failed (checksum, algo %d): %s\n",
 	    algo, gpg_strerror (err));
       gcry_cipher_close (hde);
       gcry_cipher_close (hde2);
       goto out_free;
     }
 
   err = gcry_cipher_final (hde);
   if (!err)
     {
       err = gcry_cipher_encrypt (hde, outbuf, buflen, inbuf, buflen);
     }
   for (i = 0; i < buflen && !err; i += 16)
     {
       if (i + 16 == buflen)
 	err = gcry_cipher_final (hde2);
       if (!err)
 	err = gcry_cipher_encrypt (hde2, outbuf + i, 16, inbuf + i, 16);
     }
 
   if (err)
     {
       fail ("cipher-ocb, gcry_cipher_encrypt failed (checksum, algo %d): %s\n",
 	    algo, gpg_strerror (err));
       gcry_cipher_close (hde);
       gcry_cipher_close (hde2);
       goto out_free;
     }
 
   /* Check that the tag matches. */
   err = gcry_cipher_gettag (hde, tag, 16);
   if (err)
     {
       fail ("cipher_ocb, gcry_cipher_gettag failed (checksum, algo %d): %s\n",
 	    algo, gpg_strerror (err));
     }
   err = gcry_cipher_gettag (hde2, tag2, 16);
   if (err)
     {
       fail ("cipher_ocb, gcry_cipher_gettag failed (checksum2, algo %d): %s\n",
 	    algo, gpg_strerror (err));
     }
   if (memcmp (tag, tag2, 16))
     {
       mismatch (tag, 16, tag2, 16);
       fail ("cipher-ocb, encrypt tag mismatch (checksum, algo %d)\n", algo);
     }
 
   gcry_cipher_close (hde);
   gcry_cipher_close (hde2);
 
 out_free:
   xfree(inbuf);
   xfree(outbuf);
 }
 
 
 static void
 check_ocb_cipher_largebuf (int algo, int keylen, const char *tagexpect)
 {
   unsigned int split;
 
   for (split = 0; split < 32 * 16; split = split * 2 + 16)
     {
       check_ocb_cipher_largebuf_split(algo, keylen, tagexpect, split);
     }
 
   check_ocb_cipher_checksum(algo, keylen);
 }
 
 
 static void
 check_ocb_cipher_splitaad (void)
 {
   const char t_nonce[] = ("BBAA9988776655443322110D");
   const char t_plain[] = ("000102030405060708090A0B0C0D0E0F1011121314151617"
                           "18191A1B1C1D1E1F2021222324252627");
   const char t_ciph[]  = ("D5CA91748410C1751FF8A2F618255B68A0A12E093FF45460"
                           "6E59F9C1D0DDC54B65E8628E568BAD7AED07BA06A4A69483"
                           "A7035490C5769E60");
   struct {
     const char *aad0;
     const char *aad1;
     const char *aad2;
     const char *aad3;
   } tv[] = {
     {
       "000102030405060708090A0B0C0D0E0F"
       "101112131415161718191A1B1C1D1E1F2021222324252627"
     },
     {
       "000102030405060708090A0B0C0D0E0F",
       "101112131415161718191A1B1C1D1E1F",
       "2021222324252627"
     },
     {
       "000102030405060708090A0B0C0D0E0F",
       "1011121314151617",
       "18191A1B1C1D1E1F",
       "2021222324252627"
     },
     {
       "000102030405060708090A0B0C0D0E0F",
       "101112131415161718191A1B1C1D1E1F",
       "20",
       "21222324252627"
     },
     {
       "000102030405060708090A0B0C0D0E0F",
       "101112131415161718191A1B1C1D1E1F",
       "2021",
       "222324252627"
     },
     {
       "000102030405060708090A0B0C0D0E0F",
       "101112131415161718191A1B1C1D1E1F",
       "202122",
       "2324252627"
     },
     {
       "000102030405060708090A0B0C0D0E0F",
       "101112131415161718191A1B1C1D1E1F",
       "20212223",
       "24252627"
     },
     {
       "000102030405060708090A0B0C0D0E0F",
       "101112131415161718191A1B1C1D1E1F",
       "2021222324",
       "252627"
     },
     {
       "000102030405060708090A0B0C0D0E0F",
       "101112131415161718191A1B1C1D1E1F",
       "202122232425",
       "2627"
     },
     {
       "000102030405060708090A0B0C0D0E0F",
       "101112131415161718191A1B1C1D1E1F",
       "20212223242526"
       "27"
     },
     {
       "000102030405060708090A0B0C0D0E0F",
       "1011121314151617",
       "18191A1B1C1D1E1F2021222324252627"
     },
     {
       "00",
       "0102030405060708090A0B0C0D0E0F",
       "1011121314151617",
       "18191A1B1C1D1E1F2021222324252627"
     },
     {
       "0001",
       "02030405060708090A0B0C0D0E0F",
       "1011121314151617",
       "18191A1B1C1D1E1F2021222324252627"
     },
     {
       "000102030405060708090A0B0C0D",
       "0E0F",
       "1011121314151617",
       "18191A1B1C1D1E1F2021222324252627"
     },
     {
       "000102030405060708090A0B0C0D0E",
       "0F",
       "1011121314151617",
       "18191A1B1C1D1E1F2021222324252627"
     },
     {
       "000102030405060708090A0B0C0D0E",
       "0F101112131415161718191A1B1C1D1E1F20212223242526",
       "27"
     }
   };
 
   gpg_error_t err = 0;
   gcry_cipher_hd_t hde;
   unsigned char out[MAX_DATA_LEN];
   unsigned char tag[16];
   int tidx;
   char *key, *nonce, *ciph, *plain;
   size_t keylen, noncelen, ciphlen, plainlen;
   int i;
 
   /* Convert to hex strings to binary.  */
   key   = hex2buffer ("000102030405060708090A0B0C0D0E0F", &keylen);
   nonce = hex2buffer (t_nonce, &noncelen);
   plain = hex2buffer (t_plain, &plainlen);
   ciph  = hex2buffer (t_ciph, &ciphlen);
 
   /* Check that our test vectors are sane.  */
   assert (plainlen <= sizeof out);
   assert (16 <= ciphlen);
   assert (16 <= sizeof tag);
 
   for (tidx = 0; tidx < DIM (tv); tidx++)
     {
       char *aad[4];
       size_t aadlen[4];
 
       if (verbose)
         fprintf (stderr, "    checking OCB aad split (tv %d)\n", tidx);
 
       aad[0] = tv[tidx].aad0? hex2buffer (tv[tidx].aad0, aadlen+0) : NULL;
       aad[1] = tv[tidx].aad1? hex2buffer (tv[tidx].aad1, aadlen+1) : NULL;
       aad[2] = tv[tidx].aad2? hex2buffer (tv[tidx].aad2, aadlen+2) : NULL;
       aad[3] = tv[tidx].aad3? hex2buffer (tv[tidx].aad3, aadlen+3) : NULL;
 
       err = gcry_cipher_open (&hde, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_OCB, 0);
       if (err)
         {
           fail ("cipher-ocb-splitadd, gcry_cipher_open failed: %s\n",
                 gpg_strerror (err));
           return;
         }
 
       err = gcry_cipher_setkey (hde, key, keylen);
       if (err)
         {
           fail ("cipher-ocb-splitaad, gcry_cipher_setkey failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           return;
         }
 
       err = gcry_cipher_setiv (hde, nonce, noncelen);
       if (err)
         {
           fail ("cipher-ocb-splitaad, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           return;
         }
 
       for (i=0; i < DIM (aad); i++)
         {
           if (!aad[i])
             continue;
           err = gcry_cipher_authenticate (hde, aad[i], aadlen[i]);
           if (err)
             {
               fail ("cipher-ocb-splitaad,"
                     " gcry_cipher_authenticate failed (tv=%d,i=%d): %s\n",
                     tidx, i, gpg_strerror (err));
               gcry_cipher_close (hde);
               return;
             }
         }
 
       err = gcry_cipher_final (hde);
       if (!err)
         err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN, plain, plainlen);
       if (err)
         {
           fail ("cipher-ocb-splitaad, gcry_cipher_encrypt failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           return;
         }
 
       /* Check that the encrypt output matches the expected cipher
          text without the tag (i.e. at the length of plaintext).  */
       if (memcmp (ciph, out, plainlen))
         {
           mismatch (ciph, plainlen, out, plainlen);
           fail ("cipher-ocb-splitaad, encrypt data mismatch\n");
         }
 
       /* Check that the tag matches TAGLEN bytes from the end of the
          expected ciphertext.  */
       err = gcry_cipher_gettag (hde, tag, 16);
       if (err)
         {
           fail ("cipher-ocb-splitaad, gcry_cipher_gettag failed: %s\n",
                 gpg_strerror (err));
         }
       if (memcmp (ciph + ciphlen - 16, tag, 16))
         {
           mismatch (ciph + ciphlen - 16, 16, tag, 16);
           fail ("cipher-ocb-splitaad, encrypt tag mismatch\n");
         }
 
 
       gcry_cipher_close (hde);
       xfree (aad[0]);
       xfree (aad[1]);
       xfree (aad[2]);
       xfree (aad[3]);
     }
 
   xfree (nonce);
   xfree (ciph);
   xfree (plain);
   xfree (key);
 }
 
 
 static void
 check_ocb_cipher (void)
 {
   /* Check OCB cipher with separate destination and source buffers for
    * encryption/decryption. */
   do_check_ocb_cipher(0);
 
   /* Check OCB cipher with inplace encrypt/decrypt. */
   do_check_ocb_cipher(1);
 
   /* Check large buffer encryption/decryption. */
   check_ocb_cipher_largebuf(GCRY_CIPHER_AES, 16,
     "\xc1\x5b\xf1\x80\xa4\xd5\xea\xfd\xae\x17\xa6\xcd\x6b\x10\xa8\xea");
   check_ocb_cipher_largebuf(GCRY_CIPHER_AES256, 32,
     "\x2b\xb7\x25\x6b\x77\xc7\xfb\x21\x5c\xc9\x6c\x36\x17\x1a\x1a\xd5");
   check_ocb_cipher_largebuf(GCRY_CIPHER_CAMELLIA128, 16,
     "\xe0\xae\x3f\x29\x3a\xee\xd8\xe3\xf2\x20\xc1\xa2\xd8\x72\x12\xd9");
   check_ocb_cipher_largebuf(GCRY_CIPHER_CAMELLIA192, 24,
     "\xd7\x98\x71\xcf\x19\x5c\xa3\x3d\x6c\xfc\xc9\xbe\x9f\x13\x6b\xbd");
   check_ocb_cipher_largebuf(GCRY_CIPHER_CAMELLIA256, 32,
     "\x03\xf6\xec\x1a\x0e\xae\x66\x24\x2b\xba\x26\x0f\xb3\xb3\x1f\xb9");
   check_ocb_cipher_largebuf(GCRY_CIPHER_TWOFISH, 16,
     "\x1c\xf9\xc7\xfc\x3a\x32\xac\xc7\x5e\x0a\xc2\x5c\x90\xd6\xf6\xf9");
   check_ocb_cipher_largebuf(GCRY_CIPHER_TWOFISH, 32,
     "\x53\x02\xc8\x0d\x4e\x9a\x44\x9e\x43\xd4\xaa\x06\x30\x93\xcc\x16");
   check_ocb_cipher_largebuf(GCRY_CIPHER_SERPENT128, 16,
     "\xd3\x64\xac\x40\x48\x88\x77\xe2\x41\x26\x4c\xde\x21\x29\x21\x8d");
   check_ocb_cipher_largebuf(GCRY_CIPHER_SERPENT192, 24,
     "\x99\xeb\x35\xb0\x62\x4e\x7b\xf1\x5e\x9f\xed\x32\x78\x90\x0b\xd0");
   check_ocb_cipher_largebuf(GCRY_CIPHER_SERPENT256, 32,
     "\x71\x66\x2f\x68\xbf\xdd\xcc\xb1\xbf\x81\x56\x5f\x01\x73\xeb\x44");
 
   /* Check that the AAD data is correctly buffered.  */
   check_ocb_cipher_splitaad ();
 }
 
 
 
 static void
 do_check_xts_cipher (int inplace)
 {
   /* Note that we use hex strings and not binary strings in TV.  That
      makes it easier to maintain the test vectors.  */
   static const struct
   {
     int algo;
     const char *key;    /* NULL means "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F" */
     const char *iv;
     const char *plain;
     const char *ciph;
   } tv[] = {
     /* CAVS; hex/XTSGenAES128.rsp; COUNT=100 */
     { GCRY_CIPHER_AES,
       "bcb6613c495de4bdad9c19f04e4b3915f9ecb379e1a575b633337e934fca1050",
       "64981173159d58ac355a20120c8e81f1",
       "189acacee06dfa7c94484c7dae59e166",
       "7900191d0f19a97668fdba9def84eedc"
     },
     /* CAVS; hex/XTSGenAES128.rsp; COUNT=101 */
     { GCRY_CIPHER_AES,
       "b7b93f516aef295eff3a29d837cf1f135347e8a21dae616ff5062b2e8d78ce5e",
       "873edea653b643bd8bcf51403197ed14",
       "236f8a5b58dd55f6194ed70c4ac1a17f1fe60ec9a6c454d087ccb77d6b638c47",
       "22e6a3c6379dcf7599b052b5a749c7f78ad8a11b9f1aa9430cf3aef445682e19"
     },
     /* CAVS; hex/XTSGenAES128.rsp; COUNT=301 */
     { GCRY_CIPHER_AES,
       "394c97881abd989d29c703e48a72b397a7acf51b59649eeea9b33274d8541df4",
       "4b15c684a152d485fe9937d39b168c29",
       "2f3b9dcfbae729583b1d1ffdd16bb6fe2757329435662a78f0",
       "f3473802e38a3ffef4d4fb8e6aa266ebde553a64528a06463e"
     },
     /* CAVS; hex/XTSGenAES128.rsp; COUNT=500 */
     { GCRY_CIPHER_AES,
       "783a83ec52a27405dff9de4c57f9c979b360b6a5df88d67ec1a052e6f582a717",
       "886e975b29bdf6f0c01bb47f61f6f0f5",
       "b04d84da856b9a59ce2d626746f689a8051dacd6bce3b990aa901e4030648879",
       "f941039ebab8cac39d59247cbbcb4d816c726daed11577692c55e4ac6d3e6820"
     },
     /* CAVS; hex/XTSGenAES256.rsp; COUNT=1 */
     { GCRY_CIPHER_AES256,
       "1ea661c58d943a0e4801e42f4b0947149e7f9f8e3e68d0c7505210bd311a0e7c"
       "d6e13ffdf2418d8d1911c004cda58da3d619b7e2b9141e58318eea392cf41b08",
       "adf8d92627464ad2f0428e84a9f87564",
       "2eedea52cd8215e1acc647e810bbc3642e87287f8d2e57e36c0a24fbc12a202e",
       "cbaad0e2f6cea3f50b37f934d46a9b130b9d54f07e34f36af793e86f73c6d7db"
     },
     /* CAVS; hex/XTSGenAES256.rsp; COUNT=101 */
     { GCRY_CIPHER_AES256,
       "266c336b3b01489f3267f52835fd92f674374b88b4e1ebd2d36a5f457581d9d0"
       "42c3eef7b0b7e5137b086496b4d9e6ac658d7196a23f23f036172fdb8faee527",
       "06b209a7a22f486ecbfadb0f3137ba42",
       "ca7d65ef8d3dfad345b61ccddca1ad81de830b9e86c7b426d76cb7db766852d9"
       "81c6b21409399d78f42cc0b33a7bbb06",
       "c73256870cc2f4dd57acc74b5456dbd776912a128bc1f77d72cdebbf270044b7"
       "a43ceed29025e1e8be211fa3c3ed002d"
     },
     /* CAVS; hex/XTSGenAES256.rsp; COUNT=401 */
     { GCRY_CIPHER_AES256,
       "33e89e817ff8d037d6ac5a2296657503f20885d94c483e26449066bd9284d130"
       "2dbdbb4b66b6b9f4687f13dd028eb6aa528ca91deb9c5f40db93218806033801",
       "a78c04335ab7498a52b81ed74b48e6cf",
       "14c3ac31291b075f40788247c3019e88c7b40bac3832da45bbc6c4fe7461371b"
       "4dfffb63f71c9f8edb98f28ff4f33121",
       "dead7e587519bc78c70d99279fbe3d9b1ad13cdaae69824e0ab8135413230bfd"
       "b13babe8f986fbb30d46ab5ec56b916e"
     },
     /* From https://github.com/heisencoder/XTS-AES/blob/master/testvals/ */
     { GCRY_CIPHER_AES,
       "fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0",
       "9a785634120000000000000000000000",
       "000102030405060708090a0b0c0d0e0f10",
       "7fb2e8beccbb5c118aa52ddca31220bb1b"
     },
     { GCRY_CIPHER_AES,
       "fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0bfbebdbcbbbab9b8b7b6b5b4b3b2b1b0",
       "9a785634120000000000000000000000",
       "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e",
       "d05bc090a8e04f1b3d3ecdd5baec0fd4edbf9dace45d6f6a7306e64be5dd82"
     },
     { GCRY_CIPHER_AES,
       "2718281828459045235360287471352631415926535897932384626433832795",
       "00000000000000000000000000000000",
       "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F"
       "20212223",
       "27A7479BEFA1D476489F308CD4CFA6E288F548E5C4239F91712A587E2B05AC3D"
       "A96E4BBE"
     },
     { GCRY_CIPHER_AES256,
       "2718281828459045235360287471352662497757247093699959574966967627"
       "3141592653589793238462643383279502884197169399375105820974944592",
       "11000000000000000000000000000000",
       "3A060A8CAD115A6F44572E3759E43C8F8832FEDC28A8E35B357B5CF3EDBEF788"
       "CAD8BFCB23",
       "6D1C78A8BAD91DB2924C507CCEDE835F5BADD157DA0AF55C98BBC28CF676F9FA"
       "61618FA696"
     },
     { GCRY_CIPHER_AES256,
       "2718281828459045235360287471352662497757247093699959574966967627"
       "3141592653589793238462643383279502884197169399375105820974944592",
       "11000000000000000000000000000000",
       "3A060A8CAD115A6F44572E3759E43C8F8832FEDC28A8E35B357B5CF3EDBEF788"
       "CAD8BFCB23",
       "6D1C78A8BAD91DB2924C507CCEDE835F5BADD157DA0AF55C98BBC28CF676F9FA"
       "61618FA696"
     },
     { GCRY_CIPHER_AES,
       "e0e1e2e3e4e5e6e7e8e9eaebecedeeefc0c1c2c3c4c5c6c7c8c9cacbcccdcecf",
       "21436587a90000000000000000000000",
       "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
       "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
       "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"
       "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f"
       "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f"
       "a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
       "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
       "e0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"
       "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
       "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
       "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"
       "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f"
       "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f"
       "a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
       "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
       "e0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"
       "0001020304050607",
       "38b45812ef43a05bd957e545907e223b954ab4aaf088303ad910eadf14b42be6"
       "8b2461149d8c8ba85f992be970bc621f1b06573f63e867bf5875acafa04e42cc"
       "bd7bd3c2a0fb1fff791ec5ec36c66ae4ac1e806d81fbf709dbe29e471fad3854"
       "9c8e66f5345d7c1eb94f405d1ec785cc6f6a68f6254dd8339f9d84057e01a177"
       "41990482999516b5611a38f41bb6478e6f173f320805dd71b1932fc333cb9ee3"
       "9936beea9ad96fa10fb4112b901734ddad40bc1878995f8e11aee7d141a2f5d4"
       "8b7a4e1e7f0b2c04830e69a4fd1378411c2f287edf48c6c4e5c247a19680f7fe"
       "41cefbd49b582106e3616cbbe4dfb2344b2ae9519391f3e0fb4922254b1d6d2d"
       "19c6d4d537b3a26f3bcc51588b32f3eca0829b6a5ac72578fb814fb43cf80d64"
       "a233e3f997a3f02683342f2b33d25b492536b93becb2f5e1a8b82f5b88334272"
       "9e8ae09d16938841a21a97fb543eea3bbff59f13c1a18449e398701c1ad51648"
       "346cbc04c27bb2da3b93a1372ccae548fb53bee476f9e9c91773b1bb19828394"
       "d55d3e1a20ed69113a860b6829ffa847224604435070221b257e8dff783615d2"
       "cae4803a93aa4334ab482a0afac9c0aeda70b45a481df5dec5df8cc0f423c77a"
       "5fd46cd312021d4b438862419a791be03bb4d97c0e59578542531ba466a83baf"
       "92cefc151b5cc1611a167893819b63fb37ec662bc0fc907db74a94468a55a7bc"
       "8a6b18e86de60290"
     },
     { GCRY_CIPHER_AES256,
       "2718281828459045235360287471352662497757247093699959574966967627"
       "3141592653589793238462643383279502884197169399375105820974944592",
       "ffffffff000000000000000000000000",
       "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
       "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
       "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"
       "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f"
       "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f"
       "a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
       "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
       "e0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"
       "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
       "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
       "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"
       "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f"
       "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f"
       "a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
       "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
       "e0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
       "bf53d2dade78e822a4d949a9bc6766b01b06a8ef70d26748c6a7fc36d80ae4c5"
       "520f7c4ab0ac8544424fa405162fef5a6b7f229498063618d39f0003cb5fb8d1"
       "c86b643497da1ff945c8d3bedeca4f479702a7a735f043ddb1d6aaade3c4a0ac"
       "7ca7f3fa5279bef56f82cd7a2f38672e824814e10700300a055e1630b8f1cb0e"
       "919f5e942010a416e2bf48cb46993d3cb6a51c19bacf864785a00bc2ecff15d3"
       "50875b246ed53e68be6f55bd7e05cfc2b2ed6432198a6444b6d8c247fab941f5"
       "69768b5c429366f1d3f00f0345b96123d56204c01c63b22ce78baf116e525ed9"
       "0fdea39fa469494d3866c31e05f295ff21fea8d4e6e13d67e47ce722e9698a1c"
       "1048d68ebcde76b86fcf976eab8aa9790268b7068e017a8b9b749409514f1053"
       "027fd16c3786ea1bac5f15cb79711ee2abe82f5cf8b13ae73030ef5b9e4457e7"
       "5d1304f988d62dd6fc4b94ed38ba831da4b7634971b6cd8ec325d9c61c00f1df"
       "73627ed3745a5e8489f3a95c69639c32cd6e1d537a85f75cc844726e8a72fc00"
       "77ad22000f1d5078f6b866318c668f1ad03d5a5fced5219f2eabbd0aa5c0f460"
       "d183f04404a0d6f469558e81fab24a167905ab4c7878502ad3e38fdbe62a4155"
       "6cec37325759533ce8f25f367c87bb5578d667ae93f9e2fd99bcbc5f2fbba88c"
       "f6516139420fcff3b7361d86322c4bd84c82f335abb152c4a93411373aaa8220"
     }
   };
   gpg_error_t err = 0;
   gcry_cipher_hd_t hde, hdd;
   int tidx;
   int got_err = 0;
 
   if (verbose)
     fprintf (stderr, "  Starting XTS checks.\n");
 
   for (tidx = 0; !got_err && tidx < DIM (tv); tidx++)
     {
       const char *hexkey = tv[tidx].key;
       char *key, *iv, *ciph, *plain, *out;
       size_t keylen, ivlen, ciphlen, plainlen, outlen;
 
       if (verbose)
         fprintf (stderr, "    checking XTS mode for %s [%i] (tv %d)\n",
                  gcry_cipher_algo_name (tv[tidx].algo), tv[tidx].algo, tidx);
 
       if (!hexkey)
 	hexkey = "000102030405060708090A0B0C0D0E0F"
 	         "101112131415161718191A1B1C1D1E1F";
 
       /* Convert to hex strings to binary.  */
       key   = hex2buffer (hexkey, &keylen);
       iv    = hex2buffer (tv[tidx].iv, &ivlen);
       plain = hex2buffer (tv[tidx].plain, &plainlen);
       ciph  = hex2buffer (tv[tidx].ciph, &ciphlen);
       outlen = plainlen + 5;
       out   = xmalloc (outlen);
 
       assert (plainlen == ciphlen);
       assert (plainlen <= outlen);
       assert (out);
 
       err = gcry_cipher_open (&hde, tv[tidx].algo, GCRY_CIPHER_MODE_XTS, 0);
       if (!err)
         err = gcry_cipher_open (&hdd, tv[tidx].algo, GCRY_CIPHER_MODE_XTS, 0);
       if (err)
         {
           fail ("cipher-xts, gcry_cipher_open failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           return;
         }
 
       err = gcry_cipher_setkey (hde, key, keylen);
       if (err && in_fips_mode && memcmp(key, key + keylen/2, keylen/2) == 0)
 	{
 	  /* Since both halves of key are the same, fail to set key in FIPS
 	     mode is expected. */
 	  goto next_tv;
 	}
       if (!err)
         err = gcry_cipher_setkey (hdd, key, keylen);
       if (err)
         {
           fail ("cipher-xts, gcry_cipher_setkey failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           goto err_out;
         }
 
       err = gcry_cipher_setiv (hde, iv, ivlen);
       if (!err)
         err = gcry_cipher_setiv (hdd, iv, ivlen);
       if (err)
         {
           fail ("cipher-xts, gcry_cipher_setiv failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           goto err_out;
         }
 
       if (inplace)
 	{
 	  memcpy(out, plain, plainlen);
 	  err = gcry_cipher_encrypt (hde, out, plainlen, NULL, 0);
 	}
       else
 	{
 	  err = gcry_cipher_encrypt (hde, out, outlen, plain, plainlen);
 	}
       if (err)
         {
           fail ("cipher-xts, gcry_cipher_encrypt failed (tv %d): %s\n",
                 tidx, gpg_strerror (err));
           goto err_out;
         }
 
       /* Check that the encrypt output matches the expected cipher text.  */
       if (memcmp (ciph, out, plainlen))
         {
           mismatch (ciph, plainlen, out, plainlen);
           fail ("cipher-xts, encrypt data mismatch (tv %d)\n", tidx);
         }
 
       /* Now for the decryption.  */
       if (inplace)
 	{
 	  err = gcry_cipher_decrypt (hdd, out, plainlen, NULL, 0);
 	}
       else
 	{
 	  memcpy(ciph, out, ciphlen);
 	  err = gcry_cipher_decrypt (hdd, out, plainlen, ciph, ciphlen);
 	}
       if (err)
         {
           fail ("cipher-xts, gcry_cipher_decrypt (tv %d) failed: %s\n",
                 tidx, gpg_strerror (err));
           goto err_out;
         }
 
       /* Check that the decrypt output matches the expected plain text.  */
       if (memcmp (plain, out, plainlen))
         {
           mismatch (plain, plainlen, out, plainlen);
           fail ("cipher-xts, decrypt data mismatch (tv %d)\n", tidx);
         }
 
       if (0)
 	{
 err_out:
 	  got_err = 1;
 	}
 
 next_tv:
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
 
       xfree (iv);
       xfree (ciph);
       xfree (plain);
       xfree (key);
       xfree (out);
     }
 
   if (verbose)
     fprintf (stderr, "  Completed XTS checks.\n");
 }
 
 
 static void
 check_xts_cipher (void)
 {
   /* Check XTS cipher with separate destination and source buffers for
    * encryption/decryption. */
   do_check_xts_cipher(0);
 
   /* Check XTS cipher with inplace encrypt/decrypt. */
   do_check_xts_cipher(1);
 }
 
 
 static void
 check_gost28147_cipher (void)
 {
 #if USE_GOST28147
   static const struct {
     char key[MAX_DATA_LEN];
     const char *oid;
     unsigned char plaintext[MAX_DATA_LEN];
     int inlen;
     char out[MAX_DATA_LEN];
   } tv[] =
   {
     {
       "\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x80"
       "\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xd0",
       "1.2.643.7.1.2.5.1.1",
       "\x01\x02\x03\x04\x05\x06\x07\x08",
       8,
       "\xce\x5a\x5e\xd7\xe0\x57\x7a\x5f",
     }, {
       "\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x80"
       "\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xd0",
       "1.2.643.2.2.31.0",
       "\x01\x02\x03\x04\x05\x06\x07\x08",
       8,
       "\x98\x56\xcf\x8b\xfc\xc2\x82\xf4",
     }, {
       "\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x80"
       "\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xd0",
       "1.2.643.2.2.31.1",
       "\x01\x02\x03\x04\x05\x06\x07\x08",
       8,
       "\x66\x81\x84\xae\xdc\x48\xc9\x17",
     }, {
       "\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x80"
       "\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xd0",
       "1.2.643.2.2.31.2",
       "\x01\x02\x03\x04\x05\x06\x07\x08",
       8,
       "\xdb\xee\x81\x14\x7b\x74\xb0\xf2",
     }, {
       "\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x80"
       "\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xd0",
       "1.2.643.2.2.31.3",
       "\x01\x02\x03\x04\x05\x06\x07\x08",
       8,
       "\x31\xa3\x85\x9d\x0a\xee\xb8\x0e",
     }, {
       "\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x80"
       "\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xd0",
       "1.2.643.2.2.31.4",
       "\x01\x02\x03\x04\x05\x06\x07\x08",
       8,
       "\xb1\x32\x3e\x0b\x21\x73\xcb\xd1",
     }, {
       "\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x80"
       "\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xd0",
       "1.2.643.2.2.30.0",
       "\x01\x02\x03\x04\x05\x06\x07\x08",
       8,
       "\xce\xd5\x2a\x7f\xf7\xf2\x60\xd5",
     }, {
       "\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x80"
       "\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xd0",
       "1.2.643.2.2.30.1",
       "\x01\x02\x03\x04\x05\x06\x07\x08",
       8,
       "\xe4\x21\x75\xe1\x69\x22\xd0\xa8",
     }
   };
 
   gcry_cipher_hd_t hde, hdd;
   unsigned char out[MAX_DATA_LEN];
   int i, keylen;
   gcry_error_t err = 0;
 
   if (verbose)
     fprintf (stderr, "  Starting GOST28147 cipher checks.\n");
   keylen = gcry_cipher_get_algo_keylen(GCRY_CIPHER_GOST28147);
   if (!keylen)
     {
       fail ("gost28147, gcry_cipher_get_algo_keylen failed\n");
       return;
     }
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       err = gcry_cipher_open (&hde, GCRY_CIPHER_GOST28147,
                               GCRY_CIPHER_MODE_ECB, 0);
       if (!err)
         err = gcry_cipher_open (&hdd, GCRY_CIPHER_GOST28147,
                                 GCRY_CIPHER_MODE_ECB, 0);
       if (err)
         {
           fail ("gost28147, gcry_cipher_open failed: %s\n", gpg_strerror (err));
           return;
         }
 
       err = gcry_cipher_setkey (hde, tv[i].key, keylen);
       if (!err)
         err = gcry_cipher_setkey (hdd, tv[i].key, keylen);
       if (err)
         {
           fail ("gost28147, gcry_cipher_setkey failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
       err = gcry_cipher_set_sbox (hde, tv[i].oid);
       if (!err)
         err = gcry_cipher_set_sbox (hdd, tv[i].oid);
       if (err)
         {
           fail ("gost28147, gcry_cipher_set_sbox failed: %s\n",
                 gpg_strerror (err));
           gcry_cipher_close (hde);
           gcry_cipher_close (hdd);
           return;
         }
 
         err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
                                    tv[i].plaintext,
                                    tv[i].inlen == -1 ?
                                    strlen ((char*)tv[i].plaintext) :
                                    tv[i].inlen);
         if (err)
           {
             fail ("gost28147, gcry_cipher_encrypt (%d) failed: %s\n",
                   i, gpg_strerror (err));
             gcry_cipher_close (hde);
             gcry_cipher_close (hdd);
             return;
           }
 
         if (memcmp (tv[i].out, out, tv[i].inlen))
           {
             fail ("gost28147, encrypt mismatch entry %d\n", i);
             mismatch (tv[i].out, tv[i].inlen,
                       out, tv[i].inlen);
           }
 
         err = gcry_cipher_decrypt (hdd, out, tv[i].inlen, NULL, 0);
         if (err)
           {
             fail ("gost28147, gcry_cipher_decrypt (%d) failed: %s\n",
                   i, gpg_strerror (err));
             gcry_cipher_close (hde);
             gcry_cipher_close (hdd);
             return;
           }
 
         if (memcmp (tv[i].plaintext, out, tv[i].inlen))
           {
             fail ("gost28147, decrypt mismatch entry %d\n", i);
             mismatch (tv[i].plaintext, tv[i].inlen,
                       out, tv[i].inlen);
           }
 
         gcry_cipher_close (hde);
         gcry_cipher_close (hdd);
     }
 
 #endif
 }
 
 
 static void
 check_stream_cipher (void)
 {
   static const struct tv
   {
     const char *name;
     int algo;
     int keylen;
     int ivlen;
     const char *key;
     const char *iv;
     struct data
     {
       unsigned int inlen;
       const char *plaintext;
       const char *out;
     } data[MAX_DATA_LEN];
   } tv[] = {
 #ifdef USE_SALSA20
     {
       "Salsa20 128 bit, test 1",
       GCRY_CIPHER_SALSA20, 16, 8,
       "\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x00\x00\x00\x00\x00\x00\x00\x00",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x4D\xFA\x5E\x48\x1D\xA2\x3E\xA0"
         }
       }
     },
     {
       "Salsa20 128 bit, test 2",
       GCRY_CIPHER_SALSA20, 16, 8,
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x80\x00\x00\x00\x00\x00\x00\x00",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xB6\x6C\x1E\x44\x46\xDD\x95\x57"
         }
       }
     },
     {
       "Salsa20 128 bit, test 3",
       GCRY_CIPHER_SALSA20, 16, 8,
       "\x00\x53\xA6\xF9\x4C\x9F\xF2\x45\x98\xEB\x3E\x91\xE4\x37\x8A\xDD",
       "\x0D\x74\xDB\x42\xA9\x10\x77\xDE",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x05\xE1\xE7\xBE\xB6\x97\xD9\x99"
         }
       }
     },
     {
       "Salsa20 256 bit, test 1",
       GCRY_CIPHER_SALSA20, 32, 8,
       "\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x00\x00\x00\x00\x00\x00\x00\x00",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xE3\xBE\x8F\xDD\x8B\xEC\xA2\xE3"
         }
       }
     },
     {
       "Salsa20 256 bit, test 2",
       GCRY_CIPHER_SALSA20, 32, 8,
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x80\x00\x00\x00\x00\x00\x00\x00",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x2A\xBA\x3D\xC4\x5B\x49\x47\x00"
         }
       }
     },
     {
       "Salsa20 256 bit, ecrypt verified, set 6, vector 0",
       GCRY_CIPHER_SALSA20, 32, 8,
       "\x00\x53\xA6\xF9\x4C\x9F\xF2\x45\x98\xEB\x3E\x91\xE4\x37\x8A\xDD"
       "\x30\x83\xD6\x29\x7C\xCF\x22\x75\xC8\x1B\x6E\xC1\x14\x67\xBA\x0D",
       "\x0D\x74\xDB\x42\xA9\x10\x77\xDE",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xF5\xFA\xD5\x3F\x79\xF9\xDF\x58"
         },
         { 64,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xF5\xFA\xD5\x3F\x79\xF9\xDF\x58\xC4\xAE\xA0\xD0\xED\x9A\x96\x01"
           "\xF2\x78\x11\x2C\xA7\x18\x0D\x56\x5B\x42\x0A\x48\x01\x96\x70\xEA"
           "\xF2\x4C\xE4\x93\xA8\x62\x63\xF6\x77\xB4\x6A\xCE\x19\x24\x77\x3D"
           "\x2B\xB2\x55\x71\xE1\xAA\x85\x93\x75\x8F\xC3\x82\xB1\x28\x0B\x71"
         }
       }
     },
     {
       "Salsa20/12 128 bit, test 1",
       GCRY_CIPHER_SALSA20R12, 16, 8,
       "\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x00\x00\x00\x00\x00\x00\x00\x00",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xFC\x20\x7D\xBF\xC7\x6C\x5E\x17"
         }
       }
     },
     {
       "Salsa20/12 128 bit, test 2",
       GCRY_CIPHER_SALSA20R12, 16, 8,
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x80\x00\x00\x00\x00\x00\x00\x00",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x08\x28\x39\x9A\x6F\xEF\x20\xDA"
         }
       }
     },
     {
       "Salsa20/12 128 bit, test 3",
       GCRY_CIPHER_SALSA20R12, 16, 8,
       "\x00\x53\xA6\xF9\x4C\x9F\xF2\x45\x98\xEB\x3E\x91\xE4\x37\x8A\xDD",
       "\x0D\x74\xDB\x42\xA9\x10\x77\xDE",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xAD\x9E\x60\xE6\xD2\xA2\x64\xB8"
         }
       }
     },
     {
       "Salsa20/12 256 bit, test 1",
       GCRY_CIPHER_SALSA20R12, 32, 8,
       "\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x00\x00\x00\x00\x00\x00\x00\x00",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xAF\xE4\x11\xED\x1C\x4E\x07\xE4"
         }
       }
     },
     {
       "Salsa20/12 256 bit, test 2",
       GCRY_CIPHER_SALSA20R12, 32, 8,
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x80\x00\x00\x00\x00\x00\x00\x00",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x17\x2C\x51\x92\xCB\x6E\x64\x5B"
         }
       }
     },
     {
       "Salsa20/12 256 bit, ecrypt verified, set 6, vector 0",
       GCRY_CIPHER_SALSA20R12, 32, 8,
       "\x00\x53\xA6\xF9\x4C\x9F\xF2\x45\x98\xEB\x3E\x91\xE4\x37\x8A\xDD"
       "\x30\x83\xD6\x29\x7C\xCF\x22\x75\xC8\x1B\x6E\xC1\x14\x67\xBA\x0D",
       "\x0D\x74\xDB\x42\xA9\x10\x77\xDE",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x52\xE2\x0C\xF8\x77\x5A\xE8\x82"
         },
         { 64,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x52\xE2\x0C\xF8\x77\x5A\xE8\x82\xF2\x00\xC2\x99\x9F\xE4\xBA\x31"
           "\xA7\xA1\x8F\x1D\x5C\x97\x16\x19\x1D\x12\x31\x75\xE1\x47\xBD\x4E"
           "\x8C\xA6\xED\x16\x6C\xE0\xFC\x8E\x65\xA5\xCA\x60\x84\x20\xFC\x65"
           "\x44\xC9\x70\x0A\x0F\x21\x38\xE8\xC1\xA2\x86\xFB\x8C\x1F\xBF\xA0"
         }
       }
     },
 #endif /*USE_SALSA20*/
 #ifdef USE_CHACHA20
     /* From draft-strombergson-chacha-test-vectors-01 */
     {
       "ChaCha20 128 bit, TC1",
       GCRY_CIPHER_CHACHA20, 16, 8,
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x00\x00\x00\x00\x00\x00\x00\x00",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x89\x67\x09\x52\x60\x83\x64\xfd"
         },
         { 112,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x89\x67\x09\x52\x60\x83\x64\xfd\x00\xb2\xf9\x09\x36\xf0\x31\xc8"
           "\xe7\x56\xe1\x5d\xba\x04\xb8\x49\x3d\x00\x42\x92\x59\xb2\x0f\x46"
           "\xcc\x04\xf1\x11\x24\x6b\x6c\x2c\xe0\x66\xbe\x3b\xfb\x32\xd9\xaa"
           "\x0f\xdd\xfb\xc1\x21\x23\xd4\xb9\xe4\x4f\x34\xdc\xa0\x5a\x10\x3f"
           "\x6c\xd1\x35\xc2\x87\x8c\x83\x2b\x58\x96\xb1\x34\xf6\x14\x2a\x9d"
           "\x4d\x8d\x0d\x8f\x10\x26\xd2\x0a\x0a\x81\x51\x2c\xbc\xe6\xe9\x75"
           "\x8a\x71\x43\xd0\x21\x97\x80\x22\xa3\x84\x14\x1a\x80\xce\xa3\x06"
         },
         { 128,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x89\x67\x09\x52\x60\x83\x64\xfd\x00\xb2\xf9\x09\x36\xf0\x31\xc8"
           "\xe7\x56\xe1\x5d\xba\x04\xb8\x49\x3d\x00\x42\x92\x59\xb2\x0f\x46"
           "\xcc\x04\xf1\x11\x24\x6b\x6c\x2c\xe0\x66\xbe\x3b\xfb\x32\xd9\xaa"
           "\x0f\xdd\xfb\xc1\x21\x23\xd4\xb9\xe4\x4f\x34\xdc\xa0\x5a\x10\x3f"
           "\x6c\xd1\x35\xc2\x87\x8c\x83\x2b\x58\x96\xb1\x34\xf6\x14\x2a\x9d"
           "\x4d\x8d\x0d\x8f\x10\x26\xd2\x0a\x0a\x81\x51\x2c\xbc\xe6\xe9\x75"
           "\x8a\x71\x43\xd0\x21\x97\x80\x22\xa3\x84\x14\x1a\x80\xce\xa3\x06"
           "\x2f\x41\xf6\x7a\x75\x2e\x66\xad\x34\x11\x98\x4c\x78\x7e\x30\xad"
         }
       }
     },
     {
       "ChaCha20 256 bit, TC1",
       GCRY_CIPHER_CHACHA20, 32, 8,
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x00\x00\x00\x00\x00\x00\x00\x00",
       {
         { 8,
           "\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x76\xb8\xe0\xad\xa0\xf1\x3d\x90"
         },
         { 112,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x76\xb8\xe0\xad\xa0\xf1\x3d\x90\x40\x5d\x6a\xe5\x53\x86\xbd\x28"
           "\xbd\xd2\x19\xb8\xa0\x8d\xed\x1a\xa8\x36\xef\xcc\x8b\x77\x0d\xc7"
           "\xda\x41\x59\x7c\x51\x57\x48\x8d\x77\x24\xe0\x3f\xb8\xd8\x4a\x37"
           "\x6a\x43\xb8\xf4\x15\x18\xa1\x1c\xc3\x87\xb6\x69\xb2\xee\x65\x86"
           "\x9f\x07\xe7\xbe\x55\x51\x38\x7a\x98\xba\x97\x7c\x73\x2d\x08\x0d"
           "\xcb\x0f\x29\xa0\x48\xe3\x65\x69\x12\xc6\x53\x3e\x32\xee\x7a\xed"
           "\x29\xb7\x21\x76\x9c\xe6\x4e\x43\xd5\x71\x33\xb0\x74\xd8\x39\xd5"
         },
         { 128,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x76\xb8\xe0\xad\xa0\xf1\x3d\x90\x40\x5d\x6a\xe5\x53\x86\xbd\x28"
           "\xbd\xd2\x19\xb8\xa0\x8d\xed\x1a\xa8\x36\xef\xcc\x8b\x77\x0d\xc7"
           "\xda\x41\x59\x7c\x51\x57\x48\x8d\x77\x24\xe0\x3f\xb8\xd8\x4a\x37"
           "\x6a\x43\xb8\xf4\x15\x18\xa1\x1c\xc3\x87\xb6\x69\xb2\xee\x65\x86"
           "\x9f\x07\xe7\xbe\x55\x51\x38\x7a\x98\xba\x97\x7c\x73\x2d\x08\x0d"
           "\xcb\x0f\x29\xa0\x48\xe3\x65\x69\x12\xc6\x53\x3e\x32\xee\x7a\xed"
           "\x29\xb7\x21\x76\x9c\xe6\x4e\x43\xd5\x71\x33\xb0\x74\xd8\x39\xd5"
           "\x31\xed\x1f\x28\x51\x0a\xfb\x45\xac\xe1\x0a\x1f\x4b\x79\x4d\x6f"
         }
       }
     },
     {
       "ChaCha20 256 bit, TC2",
       GCRY_CIPHER_CHACHA20, 32, 8,
       "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x00\x00\x00\x00\x00\x00\x00\x00",
       {
         { 128,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xc5\xd3\x0a\x7c\xe1\xec\x11\x93\x78\xc8\x4f\x48\x7d\x77\x5a\x85"
           "\x42\xf1\x3e\xce\x23\x8a\x94\x55\xe8\x22\x9e\x88\x8d\xe8\x5b\xbd"
           "\x29\xeb\x63\xd0\xa1\x7a\x5b\x99\x9b\x52\xda\x22\xbe\x40\x23\xeb"
           "\x07\x62\x0a\x54\xf6\xfa\x6a\xd8\x73\x7b\x71\xeb\x04\x64\xda\xc0"
           "\x10\xf6\x56\xe6\xd1\xfd\x55\x05\x3e\x50\xc4\x87\x5c\x99\x30\xa3"
           "\x3f\x6d\x02\x63\xbd\x14\xdf\xd6\xab\x8c\x70\x52\x1c\x19\x33\x8b"
           "\x23\x08\xb9\x5c\xf8\xd0\xbb\x7d\x20\x2d\x21\x02\x78\x0e\xa3\x52"
           "\x8f\x1c\xb4\x85\x60\xf7\x6b\x20\xf3\x82\xb9\x42\x50\x0f\xce\xac"
         }
       }
     },
     {
       "ChaCha20 256 bit, TC3",
       GCRY_CIPHER_CHACHA20, 32, 8,
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
       "\x01\x00\x00\x00\x00\x00\x00\x00",
       {
         { 128,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xef\x3f\xdf\xd6\xc6\x15\x78\xfb\xf5\xcf\x35\xbd\x3d\xd3\x3b\x80"
           "\x09\x63\x16\x34\xd2\x1e\x42\xac\x33\x96\x0b\xd1\x38\xe5\x0d\x32"
           "\x11\x1e\x4c\xaf\x23\x7e\xe5\x3c\xa8\xad\x64\x26\x19\x4a\x88\x54"
           "\x5d\xdc\x49\x7a\x0b\x46\x6e\x7d\x6b\xbd\xb0\x04\x1b\x2f\x58\x6b"
           "\x53\x05\xe5\xe4\x4a\xff\x19\xb2\x35\x93\x61\x44\x67\x5e\xfb\xe4"
           "\x40\x9e\xb7\xe8\xe5\xf1\x43\x0f\x5f\x58\x36\xae\xb4\x9b\xb5\x32"
           "\x8b\x01\x7c\x4b\x9d\xc1\x1f\x8a\x03\x86\x3f\xa8\x03\xdc\x71\xd5"
           "\x72\x6b\x2b\x6b\x31\xaa\x32\x70\x8a\xfe\x5a\xf1\xd6\xb6\x90\x58"
         }
       }
     },
     {
       "ChaCha20 256 bit, TC4",
       GCRY_CIPHER_CHACHA20, 32, 8,
       "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
       "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
       "\xff\xff\xff\xff\xff\xff\xff\xff",
       {
         { 128,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xd9\xbf\x3f\x6b\xce\x6e\xd0\xb5\x42\x54\x55\x77\x67\xfb\x57\x44"
           "\x3d\xd4\x77\x89\x11\xb6\x06\x05\x5c\x39\xcc\x25\xe6\x74\xb8\x36"
           "\x3f\xea\xbc\x57\xfd\xe5\x4f\x79\x0c\x52\xc8\xae\x43\x24\x0b\x79"
           "\xd4\x90\x42\xb7\x77\xbf\xd6\xcb\x80\xe9\x31\x27\x0b\x7f\x50\xeb"
           "\x5b\xac\x2a\xcd\x86\xa8\x36\xc5\xdc\x98\xc1\x16\xc1\x21\x7e\xc3"
           "\x1d\x3a\x63\xa9\x45\x13\x19\xf0\x97\xf3\xb4\xd6\xda\xb0\x77\x87"
           "\x19\x47\x7d\x24\xd2\x4b\x40\x3a\x12\x24\x1d\x7c\xca\x06\x4f\x79"
           "\x0f\x1d\x51\xcc\xaf\xf6\xb1\x66\x7d\x4b\xbc\xa1\x95\x8c\x43\x06"
         }
       }
     },
     {
       "ChaCha20 256 bit, TC5",
       GCRY_CIPHER_CHACHA20, 32, 8,
       "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
       "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55",
       "\x55\x55\x55\x55\x55\x55\x55\x55",
       {
         { 128,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xbe\xa9\x41\x1a\xa4\x53\xc5\x43\x4a\x5a\xe8\xc9\x28\x62\xf5\x64"
           "\x39\x68\x55\xa9\xea\x6e\x22\xd6\xd3\xb5\x0a\xe1\xb3\x66\x33\x11"
           "\xa4\xa3\x60\x6c\x67\x1d\x60\x5c\xe1\x6c\x3a\xec\xe8\xe6\x1e\xa1"
           "\x45\xc5\x97\x75\x01\x7b\xee\x2f\xa6\xf8\x8a\xfc\x75\x80\x69\xf7"
           "\xe0\xb8\xf6\x76\xe6\x44\x21\x6f\x4d\x2a\x34\x22\xd7\xfa\x36\xc6"
           "\xc4\x93\x1a\xca\x95\x0e\x9d\xa4\x27\x88\xe6\xd0\xb6\xd1\xcd\x83"
           "\x8e\xf6\x52\xe9\x7b\x14\x5b\x14\x87\x1e\xae\x6c\x68\x04\xc7\x00"
           "\x4d\xb5\xac\x2f\xce\x4c\x68\xc7\x26\xd0\x04\xb1\x0f\xca\xba\x86"
         }
       }
     },
     {
       "ChaCha20 256 bit, TC6",
       GCRY_CIPHER_CHACHA20, 32, 8,
       "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
       "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
       "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
       {
         { 128,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x9a\xa2\xa9\xf6\x56\xef\xde\x5a\xa7\x59\x1c\x5f\xed\x4b\x35\xae"
           "\xa2\x89\x5d\xec\x7c\xb4\x54\x3b\x9e\x9f\x21\xf5\xe7\xbc\xbc\xf3"
           "\xc4\x3c\x74\x8a\x97\x08\x88\xf8\x24\x83\x93\xa0\x9d\x43\xe0\xb7"
           "\xe1\x64\xbc\x4d\x0b\x0f\xb2\x40\xa2\xd7\x21\x15\xc4\x80\x89\x06"
           "\x72\x18\x44\x89\x44\x05\x45\xd0\x21\xd9\x7e\xf6\xb6\x93\xdf\xe5"
           "\xb2\xc1\x32\xd4\x7e\x6f\x04\x1c\x90\x63\x65\x1f\x96\xb6\x23\xe6"
           "\x2a\x11\x99\x9a\x23\xb6\xf7\xc4\x61\xb2\x15\x30\x26\xad\x5e\x86"
           "\x6a\x2e\x59\x7e\xd0\x7b\x84\x01\xde\xc6\x3a\x09\x34\xc6\xb2\xa9"
         }
       }
     },
     {
       "ChaCha20 256 bit, TC7",
       GCRY_CIPHER_CHACHA20, 32, 8,
       "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xaa\xbb\xcc\xdd\xee\xff"
       "\xff\xee\xdd\xcc\xbb\xaa\x99\x88\x77\x66\x55\x44\x33\x22\x11\x00",
       "\x0f\x1e\x2d\x3c\x4b\x5a\x69\x78",
       {
         { 128,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x9f\xad\xf4\x09\xc0\x08\x11\xd0\x04\x31\xd6\x7e\xfb\xd8\x8f\xba"
           "\x59\x21\x8d\x5d\x67\x08\xb1\xd6\x85\x86\x3f\xab\xbb\x0e\x96\x1e"
           "\xea\x48\x0f\xd6\xfb\x53\x2b\xfd\x49\x4b\x21\x51\x01\x50\x57\x42"
           "\x3a\xb6\x0a\x63\xfe\x4f\x55\xf7\xa2\x12\xe2\x16\x7c\xca\xb9\x31"
           "\xfb\xfd\x29\xcf\x7b\xc1\xd2\x79\xed\xdf\x25\xdd\x31\x6b\xb8\x84"
           "\x3d\x6e\xde\xe0\xbd\x1e\xf1\x21\xd1\x2f\xa1\x7c\xbc\x2c\x57\x4c"
           "\xcc\xab\x5e\x27\x51\x67\xb0\x8b\xd6\x86\xf8\xa0\x9d\xf8\x7e\xc3"
           "\xff\xb3\x53\x61\xb9\x4e\xbf\xa1\x3f\xec\x0e\x48\x89\xd1\x8d\xa5"
         }
       }
     },
     {
       "ChaCha20 256 bit, TC8",
       GCRY_CIPHER_CHACHA20, 32, 8,
       "\xc4\x6e\xc1\xb1\x8c\xe8\xa8\x78\x72\x5a\x37\xe7\x80\xdf\xb7\x35"
       "\x1f\x68\xed\x2e\x19\x4c\x79\xfb\xc6\xae\xbe\xe1\xa6\x67\x97\x5d",
       "\x1a\xda\x31\xd5\xcf\x68\x82\x21",
       {
         { 128,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\xf6\x3a\x89\xb7\x5c\x22\x71\xf9\x36\x88\x16\x54\x2b\xa5\x2f\x06"
           "\xed\x49\x24\x17\x92\x30\x2b\x00\xb5\xe8\xf8\x0a\xe9\xa4\x73\xaf"
           "\xc2\x5b\x21\x8f\x51\x9a\xf0\xfd\xd4\x06\x36\x2e\x8d\x69\xde\x7f"
           "\x54\xc6\x04\xa6\xe0\x0f\x35\x3f\x11\x0f\x77\x1b\xdc\xa8\xab\x92"
           "\xe5\xfb\xc3\x4e\x60\xa1\xd9\xa9\xdb\x17\x34\x5b\x0a\x40\x27\x36"
           "\x85\x3b\xf9\x10\xb0\x60\xbd\xf1\xf8\x97\xb6\x29\x0f\x01\xd1\x38"
           "\xae\x2c\x4c\x90\x22\x5b\xa9\xea\x14\xd5\x18\xf5\x59\x29\xde\xa0"
           "\x98\xca\x7a\x6c\xcf\xe6\x12\x27\x05\x3c\x84\xe4\x9a\x4a\x33\x32"
         },
         { 127,
           "\xf6\x3a\x89\xb7\x5c\x22\x71\xf9\x36\x88\x16\x54\x2b\xa5\x2f\x06"
           "\xed\x49\x24\x17\x92\x30\x2b\x00\xb5\xe8\xf8\x0a\xe9\xa4\x73\xaf"
           "\xc2\x5b\x21\x8f\x51\x9a\xf0\xfd\xd4\x06\x36\x2e\x8d\x69\xde\x7f"
           "\x54\xc6\x04\xa6\xe0\x0f\x35\x3f\x11\x0f\x77\x1b\xdc\xa8\xab\x92"
           "\xe5\xfb\xc3\x4e\x60\xa1\xd9\xa9\xdb\x17\x34\x5b\x0a\x40\x27\x36"
           "\x85\x3b\xf9\x10\xb0\x60\xbd\xf1\xf8\x97\xb6\x29\x0f\x01\xd1\x38"
           "\xae\x2c\x4c\x90\x22\x5b\xa9\xea\x14\xd5\x18\xf5\x59\x29\xde\xa0"
           "\x98\xca\x7a\x6c\xcf\xe6\x12\x27\x05\x3c\x84\xe4\x9a\x4a\x33",
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         }
       }
     },
     /* from draft-nir-cfrg-chacha20-poly1305-02 */
     {
       "ChaCha20 256 bit, IV96-bit",
       GCRY_CIPHER_CHACHA20, 32, 12,
       "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
       "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f",
       "\x07\x00\x00\x00\x40\x41\x42\x43\x44\x45\x46\x47",
       {
         { 64,
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
           "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
           "\x7b\xac\x2b\x25\x2d\xb4\x47\xaf\x09\xb6\x7a\x55\xa4\xe9\x55\x84"
           "\x0a\xe1\xd6\x73\x10\x75\xd9\xeb\x2a\x93\x75\x78\x3e\xd5\x53\xff"
           "\xa2\x7e\xcc\xde\xad\xdb\x4d\xb4\xd1\x17\x9c\xe4\xc9\x0b\x43\xd8"
           "\xbc\xb7\x94\x8c\x4b\x4b\x7d\x8b\x7d\xf6\x27\x39\x32\xa4\x69\x16"
         },
       },
     },
 #endif /*USE_CHACHA20*/
   };
 
   gcry_cipher_hd_t hde, hdd;
   unsigned char out[MAX_DATA_LEN];
   int i, j;
   gcry_error_t err = 0;
 
 
   if (verbose)
     fprintf (stderr, "  Starting stream cipher checks.\n");
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     tv[i].algo);
           continue;
         }
       if (verbose)
         fprintf (stderr, "    checking stream mode for %s [%i] (%s)\n",
 		 gcry_cipher_algo_name (tv[i].algo), tv[i].algo, tv[i].name);
 
       if (gcry_cipher_get_algo_blklen(tv[i].algo) != 1)
         {
           fail ("stream, gcry_cipher_get_algo_blklen: bad block length\n");
           continue;
         }
 
       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_STREAM, 0);
       if (!err)
         err = gcry_cipher_open (&hdd, tv[i].algo, GCRY_CIPHER_MODE_STREAM, 0);
       if (err)
         {
           fail ("stream, gcry_cipher_open for stream mode failed: %s\n",
                 gpg_strerror (err));
           continue;
         }
 
       /* Now loop over all the data samples.  */
       for (j = 0; tv[i].data[j].inlen; j++)
         {
           err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
           if (!err)
             err = gcry_cipher_setkey (hdd, tv[i].key, tv[i].keylen);
           if (err)
             {
               fail ("stream, gcry_cipher_setkey failed: %s\n",
                     gpg_strerror (err));
               goto next;
             }
 
           err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
           if (!err)
             err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
           if (err)
             {
               fail ("stream, gcry_cipher_setiv failed: %s\n",
                     gpg_strerror (err));
               goto next;
             }
 
           err = gcry_cipher_encrypt (hde, out, MAX_DATA_LEN,
                                      tv[i].data[j].plaintext,
                                      tv[i].data[j].inlen);
           if (err)
             {
               fail ("stream, gcry_cipher_encrypt (%d, %d) failed: %s\n",
                     i, j, gpg_strerror (err));
               goto next;
             }
 
           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
             {
               fail ("stream, encrypt mismatch entry %d:%d\n", i, j);
               mismatch (tv[i].data[j].out, tv[i].data[j].inlen,
                         out, tv[i].data[j].inlen);
             }
 
           err = gcry_cipher_decrypt (hdd, out, tv[i].data[j].inlen, NULL, 0);
           if (err)
             {
               fail ("stream, gcry_cipher_decrypt (%d, %d) failed: %s\n",
                     i, j, gpg_strerror (err));
               goto next;
             }
 
           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
             fail ("stream, decrypt mismatch entry %d:%d\n", i, j);
         }
 
 
       /* This time we encrypt and decrypt one byte at a time */
       for (j = 0; tv[i].data[j].inlen; j++)
         {
           int byteNum;
 
           err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
           if (!err)
             err = gcry_cipher_setkey (hdd, tv[i].key, tv[i].keylen);
           if (err)
             {
               fail ("stream, gcry_cipher_setkey failed: %s\n",
                     gpg_strerror (err));
               goto next;
             }
 
           err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
           if (!err)
             err = gcry_cipher_setiv (hdd, tv[i].iv, tv[i].ivlen);
           if (err)
             {
               fail ("stream, gcry_cipher_setiv failed: %s\n",
                     gpg_strerror (err));
               goto next;
             }
 
           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
             {
               err = gcry_cipher_encrypt (hde, out+byteNum, 1,
                                          (tv[i].data[j].plaintext) + byteNum,
                                          1);
               if (err)
                 {
                   fail ("stream, gcry_cipher_encrypt (%d, %d) failed: %s\n",
                         i, j, gpg_strerror (err));
                   goto next;
                 }
             }
 
           if (memcmp (tv[i].data[j].out, out, tv[i].data[j].inlen))
             fail ("stream, encrypt mismatch entry %d:%d (byte-wise)\n", i, j);
 
           for (byteNum = 0; byteNum < tv[i].data[j].inlen; ++byteNum)
             {
               err = gcry_cipher_decrypt (hdd, out+byteNum, 1, NULL, 0);
               if (err)
                 {
                   fail ("stream, gcry_cipher_decrypt (%d, %d) failed: %s\n",
                         i, j, gpg_strerror (err));
                   goto next;
                 }
             }
 
           if (memcmp (tv[i].data[j].plaintext, out, tv[i].data[j].inlen))
             fail ("stream, decrypt mismatch entry %d:%d (byte-wise)\n", i, j);
         }
 
     next:
       gcry_cipher_close (hde);
       gcry_cipher_close (hdd);
     }
   if (verbose)
     fprintf (stderr, "  Completed stream cipher checks.\n");
 }
 
 
 static void
 check_stream_cipher_large_block (void)
 {
   static const struct tv
   {
     const char *name;
     int algo;
     int keylen;
     int ivlen;
     const char *key;
     const char *iv;
     struct data
     {
       int offset, length;
       const char *result;
     } data[MAX_DATA_LEN];
   } tv[] = {
 #ifdef USE_SALSA20
     {
       "Salsa20 256 bit, ecrypt verified, set 6, vector 0",
       GCRY_CIPHER_SALSA20, 32, 8,
       "\x00\x53\xA6\xF9\x4C\x9F\xF2\x45\x98\xEB\x3E\x91\xE4\x37\x8A\xDD"
       "\x30\x83\xD6\x29\x7C\xCF\x22\x75\xC8\x1B\x6E\xC1\x14\x67\xBA\x0D",
       "\x0D\x74\xDB\x42\xA9\x10\x77\xDE",
       {
         { 0, 64,
           "\xF5\xFA\xD5\x3F\x79\xF9\xDF\x58\xC4\xAE\xA0\xD0\xED\x9A\x96\x01"
           "\xF2\x78\x11\x2C\xA7\x18\x0D\x56\x5B\x42\x0A\x48\x01\x96\x70\xEA"
           "\xF2\x4C\xE4\x93\xA8\x62\x63\xF6\x77\xB4\x6A\xCE\x19\x24\x77\x3D"
           "\x2B\xB2\x55\x71\xE1\xAA\x85\x93\x75\x8F\xC3\x82\xB1\x28\x0B\x71"
         },
         { 65472, 64,
          "\xB7\x0C\x50\x13\x9C\x63\x33\x2E\xF6\xE7\x7A\xC5\x43\x38\xA4\x07"
          "\x9B\x82\xBE\xC9\xF9\xA4\x03\xDF\xEA\x82\x1B\x83\xF7\x86\x07\x91"
          "\x65\x0E\xF1\xB2\x48\x9D\x05\x90\xB1\xDE\x77\x2E\xED\xA4\xE3\xBC"
          "\xD6\x0F\xA7\xCE\x9C\xD6\x23\xD9\xD2\xFD\x57\x58\xB8\x65\x3E\x70"
         },
         { 65536, 64,
          "\x81\x58\x2C\x65\xD7\x56\x2B\x80\xAE\xC2\xF1\xA6\x73\xA9\xD0\x1C"
          "\x9F\x89\x2A\x23\xD4\x91\x9F\x6A\xB4\x7B\x91\x54\xE0\x8E\x69\x9B"
          "\x41\x17\xD7\xC6\x66\x47\x7B\x60\xF8\x39\x14\x81\x68\x2F\x5D\x95"
          "\xD9\x66\x23\xDB\xC4\x89\xD8\x8D\xAA\x69\x56\xB9\xF0\x64\x6B\x6E"
         },
         { 131008, 64,
          "\xA1\x3F\xFA\x12\x08\xF8\xBF\x50\x90\x08\x86\xFA\xAB\x40\xFD\x10"
          "\xE8\xCA\xA3\x06\xE6\x3D\xF3\x95\x36\xA1\x56\x4F\xB7\x60\xB2\x42"
          "\xA9\xD6\xA4\x62\x8C\xDC\x87\x87\x62\x83\x4E\x27\xA5\x41\xDA\x2A"
          "\x5E\x3B\x34\x45\x98\x9C\x76\xF6\x11\xE0\xFE\xC6\xD9\x1A\xCA\xCC"
         }
       }
     },
     {
       "Salsa20 256 bit, ecrypt verified, set 6, vector 1",
       GCRY_CIPHER_SALSA20, 32, 8,
       "\x05\x58\xAB\xFE\x51\xA4\xF7\x4A\x9D\xF0\x43\x96\xE9\x3C\x8F\xE2"
       "\x35\x88\xDB\x2E\x81\xD4\x27\x7A\xCD\x20\x73\xC6\x19\x6C\xBF\x12",
       "\x16\x7D\xE4\x4B\xB2\x19\x80\xE7",
       {
         { 0, 64,
           "\x39\x44\xF6\xDC\x9F\x85\xB1\x28\x08\x38\x79\xFD\xF1\x90\xF7\xDE"
           "\xE4\x05\x3A\x07\xBC\x09\x89\x6D\x51\xD0\x69\x0B\xD4\xDA\x4A\xC1"
           "\x06\x2F\x1E\x47\xD3\xD0\x71\x6F\x80\xA9\xB4\xD8\x5E\x6D\x60\x85"
           "\xEE\x06\x94\x76\x01\xC8\x5F\x1A\x27\xA2\xF7\x6E\x45\xA6\xAA\x87"
         },
         { 65472, 64,
           "\x36\xE0\x3B\x4B\x54\xB0\xB2\xE0\x4D\x06\x9E\x69\x00\x82\xC8\xC5"
           "\x92\xDF\x56\xE6\x33\xF5\xD8\xC7\x68\x2A\x02\xA6\x5E\xCD\x13\x71"
           "\x8C\xA4\x35\x2A\xAC\xCB\x0D\xA2\x0E\xD6\xBB\xBA\x62\xE1\x77\xF2"
           "\x10\xE3\x56\x0E\x63\xBB\x82\x2C\x41\x58\xCA\xA8\x06\xA8\x8C\x82"
         },
         { 65536, 64,
           "\x1B\x77\x9E\x7A\x91\x7C\x8C\x26\x03\x9F\xFB\x23\xCF\x0E\xF8\xE0"
           "\x8A\x1A\x13\xB4\x3A\xCD\xD9\x40\x2C\xF5\xDF\x38\x50\x10\x98\xDF"
           "\xC9\x45\xA6\xCC\x69\xA6\xA1\x73\x67\xBC\x03\x43\x1A\x86\xB3\xED"
           "\x04\xB0\x24\x5B\x56\x37\x9B\xF9\x97\xE2\x58\x00\xAD\x83\x7D\x7D"
         },
         { 131008, 64,
           "\x7E\xC6\xDA\xE8\x1A\x10\x5E\x67\x17\x2A\x0B\x8C\x4B\xBE\x7D\x06"
           "\xA7\xA8\x75\x9F\x91\x4F\xBE\xB1\xAF\x62\xC8\xA5\x52\xEF\x4A\x4F"
           "\x56\x96\x7E\xA2\x9C\x74\x71\xF4\x6F\x3B\x07\xF7\xA3\x74\x6E\x95"
           "\x3D\x31\x58\x21\xB8\x5B\x6E\x8C\xB4\x01\x22\xB9\x66\x35\x31\x3C"
         }
       }
     },
     {
       "Salsa20 256 bit, ecrypt verified, set 6, vector 2",
       GCRY_CIPHER_SALSA20, 32, 8,
       "\x0A\x5D\xB0\x03\x56\xA9\xFC\x4F\xA2\xF5\x48\x9B\xEE\x41\x94\xE7"
       "\x3A\x8D\xE0\x33\x86\xD9\x2C\x7F\xD2\x25\x78\xCB\x1E\x71\xC4\x17",
       "\x1F\x86\xED\x54\xBB\x22\x89\xF0",
       {
         { 0, 64,
           "\x3F\xE8\x5D\x5B\xB1\x96\x0A\x82\x48\x0B\x5E\x6F\x4E\x96\x5A\x44"
           "\x60\xD7\xA5\x45\x01\x66\x4F\x7D\x60\xB5\x4B\x06\x10\x0A\x37\xFF"
           "\xDC\xF6\xBD\xE5\xCE\x3F\x48\x86\xBA\x77\xDD\x5B\x44\xE9\x56\x44"
           "\xE4\x0A\x8A\xC6\x58\x01\x15\x5D\xB9\x0F\x02\x52\x2B\x64\x40\x23"
         },
         { 65472, 64,
           "\xC8\xD6\xE5\x4C\x29\xCA\x20\x40\x18\xA8\x30\xE2\x66\xCE\xEE\x0D"
           "\x03\x7D\xC4\x7E\x92\x19\x47\x30\x2A\xCE\x40\xD1\xB9\x96\xA6\xD8"
           "\x0B\x59\x86\x77\xF3\x35\x2F\x1D\xAA\x6D\x98\x88\xF8\x91\xAD\x95"
           "\xA1\xC3\x2F\xFE\xB7\x1B\xB8\x61\xE8\xB0\x70\x58\x51\x51\x71\xC9"
         },
         { 65536, 64,
           "\xB7\x9F\xD7\x76\x54\x2B\x46\x20\xEF\xCB\x88\x44\x95\x99\xF2\x34"
           "\x03\xE7\x4A\x6E\x91\xCA\xCC\x50\xA0\x5A\x8F\x8F\x3C\x0D\xEA\x8B"
           "\x00\xE1\xA5\xE6\x08\x1F\x55\x26\xAE\x97\x5B\x3B\xC0\x45\x0F\x1A"
           "\x0C\x8B\x66\xF8\x08\xF1\x90\x4B\x97\x13\x61\x13\x7C\x93\x15\x6F"
         },
         { 131008, 64,
           "\x79\x98\x20\x4F\xED\x70\xCE\x8E\x0D\x02\x7B\x20\x66\x35\xC0\x8C"
           "\x8B\xC4\x43\x62\x26\x08\x97\x0E\x40\xE3\xAE\xDF\x3C\xE7\x90\xAE"
           "\xED\xF8\x9F\x92\x26\x71\xB4\x53\x78\xE2\xCD\x03\xF6\xF6\x23\x56"
           "\x52\x9C\x41\x58\xB7\xFF\x41\xEE\x85\x4B\x12\x35\x37\x39\x88\xC8"
         }
       }
     },
     {
       "Salsa20 256 bit, ecrypt verified, set 6, vector 3",
       GCRY_CIPHER_SALSA20, 32, 8,
       "\x0F\x62\xB5\x08\x5B\xAE\x01\x54\xA7\xFA\x4D\xA0\xF3\x46\x99\xEC"
       "\x3F\x92\xE5\x38\x8B\xDE\x31\x84\xD7\x2A\x7D\xD0\x23\x76\xC9\x1C",
       "\x28\x8F\xF6\x5D\xC4\x2B\x92\xF9",
       {
         { 0, 64,
           "\x5E\x5E\x71\xF9\x01\x99\x34\x03\x04\xAB\xB2\x2A\x37\xB6\x62\x5B"
           "\xF8\x83\xFB\x89\xCE\x3B\x21\xF5\x4A\x10\xB8\x10\x66\xEF\x87\xDA"
           "\x30\xB7\x76\x99\xAA\x73\x79\xDA\x59\x5C\x77\xDD\x59\x54\x2D\xA2"
           "\x08\xE5\x95\x4F\x89\xE4\x0E\xB7\xAA\x80\xA8\x4A\x61\x76\x66\x3F"
         },
         { 65472, 64,
           "\x2D\xA2\x17\x4B\xD1\x50\xA1\xDF\xEC\x17\x96\xE9\x21\xE9\xD6\xE2"
           "\x4E\xCF\x02\x09\xBC\xBE\xA4\xF9\x83\x70\xFC\xE6\x29\x05\x6F\x64"
           "\x91\x72\x83\x43\x6E\x2D\x3F\x45\x55\x62\x25\x30\x7D\x5C\xC5\xA5"
           "\x65\x32\x5D\x89\x93\xB3\x7F\x16\x54\x19\x5C\x24\x0B\xF7\x5B\x16"
         },
         { 65536, 64,
           "\xAB\xF3\x9A\x21\x0E\xEE\x89\x59\x8B\x71\x33\x37\x70\x56\xC2\xFE"
           "\xF4\x2D\xA7\x31\x32\x75\x63\xFB\x67\xC7\xBE\xDB\x27\xF3\x8C\x7C"
           "\x5A\x3F\xC2\x18\x3A\x4C\x6B\x27\x7F\x90\x11\x52\x47\x2C\x6B\x2A"
           "\xBC\xF5\xE3\x4C\xBE\x31\x5E\x81\xFD\x3D\x18\x0B\x5D\x66\xCB\x6C"
         },
         { 131008, 64,
           "\x1B\xA8\x9D\xBD\x3F\x98\x83\x97\x28\xF5\x67\x91\xD5\xB7\xCE\x23"
           "\x50\x36\xDE\x84\x3C\xCC\xAB\x03\x90\xB8\xB5\x86\x2F\x1E\x45\x96"
           "\xAE\x8A\x16\xFB\x23\xDA\x99\x7F\x37\x1F\x4E\x0A\xAC\xC2\x6D\xB8"
           "\xEB\x31\x4E\xD4\x70\xB1\xAF\x6B\x9F\x8D\x69\xDD\x79\xA9\xD7\x50"
         }
       }
     },
     {
       "Salsa20/12 256 bit, ecrypt verified, set 6, vector 0",
       GCRY_CIPHER_SALSA20R12, 32, 8,
       "\x00\x53\xA6\xF9\x4C\x9F\xF2\x45\x98\xEB\x3E\x91\xE4\x37\x8A\xDD"
       "\x30\x83\xD6\x29\x7C\xCF\x22\x75\xC8\x1B\x6E\xC1\x14\x67\xBA\x0D",
       "\x0D\x74\xDB\x42\xA9\x10\x77\xDE",
       {
         { 0, 64,
           "\x52\xE2\x0C\xF8\x77\x5A\xE8\x82\xF2\x00\xC2\x99\x9F\xE4\xBA\x31"
           "\xA7\xA1\x8F\x1D\x5C\x97\x16\x19\x1D\x12\x31\x75\xE1\x47\xBD\x4E"
           "\x8C\xA6\xED\x16\x6C\xE0\xFC\x8E\x65\xA5\xCA\x60\x84\x20\xFC\x65"
           "\x44\xC9\x70\x0A\x0F\x21\x38\xE8\xC1\xA2\x86\xFB\x8C\x1F\xBF\xA0"
         },
         { 65472, 64,
           "\x8F\xBC\x9F\xE8\x69\x1B\xD4\xF0\x82\xB4\x7F\x54\x05\xED\xFB\xC1"
           "\x6F\x4D\x5A\x12\xDD\xCB\x2D\x75\x4E\x8A\x99\x98\xD0\xB2\x19\x55"
           "\x7D\xFE\x29\x84\xF4\xA1\xD2\xDD\xA7\x6B\x95\x96\x92\x8C\xCE\x05"
           "\x56\xF5\x00\x66\xCD\x59\x9E\x44\xEF\x5C\x14\xB2\x26\x68\x3A\xEF"
         },
         { 65536, 64,
           "\xBC\xBD\x01\xDD\x28\x96\x1C\xC7\xAD\x30\x47\x38\x6C\xBC\xC6\x7C"
           "\x10\x8D\x6A\xF1\x11\x67\xE4\x0D\x7A\xE1\xB2\xFC\x45\x18\xA8\x67"
           "\xEF\xE4\x02\x65\x1D\x1D\x88\x51\xC4\xFD\x23\x30\xC5\x97\xB3\x6A"
           "\x46\xD5\x68\x9E\x00\xFC\x96\xFE\xCF\x9C\xE3\xE2\x21\x1D\x44\xBE"
         },
         { 131008, 64,
           "\x91\x66\xF3\x1C\xD8\x5B\x5B\xB1\x8F\xC6\x14\xE5\x4E\x4A\xD6\x7F"
           "\xB8\x65\x8E\x3B\xF9\xFB\x19\xB7\xA8\x2F\x0F\xE7\xDC\x90\x2D\xF5"
           "\x63\xC6\xAC\x4F\x44\x67\x48\xC4\xBC\x3E\x14\x05\xE1\x24\x82\x0D"
           "\xC4\x09\x41\x99\x8F\x44\xA8\x10\xE7\x22\x78\x7F\xCD\x47\x78\x4C"
         }
       }
     },
     {
       "Salsa20/12 256 bit, ecrypt verified, set 6, vector 1",
       GCRY_CIPHER_SALSA20R12, 32, 8,
       "\x05\x58\xAB\xFE\x51\xA4\xF7\x4A\x9D\xF0\x43\x96\xE9\x3C\x8F\xE2"
       "\x35\x88\xDB\x2E\x81\xD4\x27\x7A\xCD\x20\x73\xC6\x19\x6C\xBF\x12",
       "\x16\x7D\xE4\x4B\xB2\x19\x80\xE7",
       {
         { 0, 64,
           "\xC0\x75\x60\xB3\xE7\x76\xB4\x71\xC5\xE2\x93\x14\x26\xCA\xF1\xED"
           "\x3A\xE4\xB8\x67\x08\x76\x82\xCA\x9D\xFD\xC2\xBA\xE8\x93\x50\xBD"
           "\x84\x82\x1C\xAE\xFF\x85\xAA\xC4\x9D\x74\x35\xA7\xD9\x88\x93\x52"
           "\xF5\x27\x9E\x36\x12\x3F\x41\x72\x8A\x14\xEF\x26\x9F\xCB\x94\x4B"
         },
         { 65472, 64,
           "\xEE\xD1\xBB\x58\xF9\x0C\x89\xE0\x5C\xC6\x8B\x2D\xB6\x05\x58\x49"
           "\xB3\xD2\xB1\x87\xB7\xF0\x2F\x9A\x24\xCE\x34\x2A\xF0\xFC\x47\xA3"
           "\x74\xBD\x75\x90\xFB\xF4\xFD\x9E\xE5\x9B\x1A\x38\x1E\xBF\xD2\x29"
           "\xAD\x2A\x29\x01\xB3\xFB\x61\x08\x12\x90\x0B\x92\x30\xE6\x22\xE9"
         },
         { 65536, 64,
           "\x70\xF0\x49\x3A\x1B\x62\x53\xCC\x5E\xD3\x45\x0A\x31\xCF\x37\x7D"
           "\x83\x4B\xAD\x20\x72\x30\x29\x27\xCC\xD8\x30\x10\x4B\xD3\x05\xFF"
           "\x59\xD2\x94\x17\xB2\x32\x88\x4E\xC9\x59\x19\x4D\x60\x47\xC3\xDD"
           "\x66\x56\xC4\x7E\x32\x00\x64\xEB\x01\x44\xF7\x34\x1B\xC3\xD6\x97"
         },
         { 131008, 64,
           "\xD2\xCC\xF7\xC1\xAF\x2A\xB4\x66\xE6\x27\xDB\x44\x08\x40\x96\x9A"
           "\xBD\xAB\x68\xD8\x86\xAE\x6A\x38\xA1\x3F\xEE\x17\x50\xCA\x97\xB5"
           "\xD3\x31\x5B\x84\x08\x47\x28\x86\x2F\xBC\xC7\xD4\xA9\x7C\x75\xC8"
           "\x65\x5F\xF9\xD6\xBB\xC2\x61\x88\x63\x6F\x3E\xDF\xE1\x5C\x7D\x30"
         }
       }
     },
     {
       "Salsa20/12 256 bit, ecrypt verified, set 6, vector 2",
       GCRY_CIPHER_SALSA20R12, 32, 8,
       "\x0A\x5D\xB0\x03\x56\xA9\xFC\x4F\xA2\xF5\x48\x9B\xEE\x41\x94\xE7"
       "\x3A\x8D\xE0\x33\x86\xD9\x2C\x7F\xD2\x25\x78\xCB\x1E\x71\xC4\x17",
       "\x1F\x86\xED\x54\xBB\x22\x89\xF0",
       {
         { 0, 64,
           "\x51\x22\x52\x91\x01\x90\xD1\x54\xD1\x4D\x0B\x92\x32\xB8\x84\x31"
           "\x8C\xCB\x43\x81\x9B\xD5\x42\x19\x32\xC0\x3A\x13\xF0\x7B\x40\x10"
           "\x83\xD7\x89\x72\x5A\xA9\xDA\x0B\x41\xCB\x62\x24\x94\x5E\xDC\xB0"
           "\xFB\x6F\xD7\xC2\x34\x22\x35\xC9\x70\xF6\x4E\x10\x1C\x25\x68\x64"
         },
         { 65472, 64,
           "\x97\x96\x74\x55\x84\x0A\x4A\xE5\xC1\xCA\xCE\x49\x15\x19\x13\x8A"
           "\xA3\x5E\x5F\x02\x40\x7D\x4A\x1F\xE5\x08\x6D\x35\xF3\x55\x1E\xF4"
           "\x77\xD9\x28\x9D\x17\x23\x79\x7C\x1A\x49\xEC\x26\x62\x9A\xFA\xDC"
           "\x56\xA0\x38\xA3\x8C\x75\x88\x1B\x62\x17\xFD\x74\x67\x25\x59\x09"
         },
         { 65536, 64,
           "\x1B\xF8\x2E\x3D\x5C\x54\xDA\xAB\xCF\x84\x15\xF8\xA2\xA1\xA2\x2E"
           "\x86\x88\x06\x33\x4F\xF3\x11\x36\x04\x74\x1C\x1D\xF2\xB9\x84\x0F"
           "\x87\xDE\xEF\xB0\x07\x23\xA8\xA1\xB2\x4A\x4D\xA1\x7E\xCD\xAD\x00"
           "\x01\xF9\x79\xDD\xAE\x2D\xF0\xC5\xE1\xE5\x32\xC4\x8F\x8E\x0D\x34"
         },
         { 131008, 64,
           "\x06\xD8\x4F\x6A\x71\x34\x84\x20\x32\x9F\xCD\x0C\x41\x75\x9A\xD1"
           "\x8F\x99\x57\xA3\x8F\x22\x89\x3B\xA5\x58\xC5\x05\x11\x97\x28\x5C"
           "\x6B\xE2\xFD\x6C\x96\xA5\xC6\x62\xAF\xD3\x11\x78\xE7\x0F\x96\x0A"
           "\xAB\x3F\x47\x96\x23\xA4\x44\xB6\x81\x91\xE4\xC5\x28\x46\x93\x88"
         }
       }
     },
     {
       "Salsa20/12 256 bit, ecrypt verified, set 6, vector 3",
       GCRY_CIPHER_SALSA20R12, 32, 8,
       "\x0F\x62\xB5\x08\x5B\xAE\x01\x54\xA7\xFA\x4D\xA0\xF3\x46\x99\xEC"
       "\x3F\x92\xE5\x38\x8B\xDE\x31\x84\xD7\x2A\x7D\xD0\x23\x76\xC9\x1C",
       "\x28\x8F\xF6\x5D\xC4\x2B\x92\xF9",
       {
         { 0, 64,
           "\x99\xDB\x33\xAD\x11\xCE\x0C\xCB\x3B\xFD\xBF\x8D\x0C\x18\x16\x04"
           "\x52\xD0\x14\xCD\xE9\x89\xB4\xC4\x11\xA5\x59\xFF\x7C\x20\xA1\x69"
           "\xE6\xDC\x99\x09\xD8\x16\xBE\xCE\xDC\x40\x63\xCE\x07\xCE\xA8\x28"
           "\xF4\x4B\xF9\xB6\xC9\xA0\xA0\xB2\x00\xE1\xB5\x2A\xF4\x18\x59\xC5"
         },
         { 65472, 64,
           "\x2F\xF2\x02\x64\xEE\xAF\x47\xAB\x7D\x57\xC3\x62\x24\x53\x54\x51"
           "\x73\x5A\xC8\x36\xD3\x2D\xD2\x8A\xE6\x36\x45\xCE\x95\x2F\x7F\xDB"
           "\xE6\x68\x9C\x69\x59\x77\xB1\xC7\x6E\x60\xDD\x5B\x27\xAC\xA4\x76"
           "\xD2\x62\x0F\xDC\x93\x13\xE8\x48\x9B\xA5\x6A\x70\xC9\xF4\xC3\xA8"
         },
         { 65536, 64,
           "\xEB\x30\xCD\xA7\x27\xC0\xF8\xB7\xE4\x5D\x5E\xF3\x0D\xB7\xCB\xE0"
           "\x21\xF2\x29\x1E\x5F\x56\x93\x8D\x56\xF6\x87\xB7\x37\xC3\xB4\x27"
           "\x54\x5C\x56\xA6\xD3\xA0\xBF\x2B\x2F\x47\xB4\x84\x93\xFA\xE4\x5E"
           "\xD5\x0C\x2E\x9B\xBE\x49\xFD\x92\xD6\x7C\x76\x49\x05\x5F\x06\xFD"
         },
         { 131008, 64,
           "\x0E\xBF\x6C\xC3\xCB\xCB\xE7\x4E\x6E\xE8\x07\x47\x1B\x49\x2A\x67"
           "\x39\xA5\x2F\x57\x11\x31\xA2\x50\xBC\xDF\xA0\x76\xA2\x65\x90\xD7"
           "\xED\xE6\x75\x1C\x03\x26\xA0\x2C\xB1\x1C\x58\x77\x35\x52\x80\x4F"
           "\xD8\x68\x67\x15\x35\x5C\x5A\x5C\xC5\x91\x96\x3A\x75\xE9\x94\xB4"
         }
       }
     }
 #endif /*USE_SALSA20*/
   };
 
 
   char zeroes[512];
   gcry_cipher_hd_t hde;
   unsigned char *buffer;
   unsigned char *p;
   size_t buffersize;
   unsigned int n;
   int i, j;
   gcry_error_t err = 0;
 
   if (verbose)
     fprintf (stderr, "  Starting large block stream cipher checks.\n");
 
   memset (zeroes, 0, 512);
 
   buffersize = 128 * 1024;
   buffer = gcry_xmalloc (buffersize+1024);
   memset (buffer+buffersize, 0x5a, 1024);
 
   for (i = 0; i < sizeof (tv) / sizeof (tv[0]); i++)
     {
       if (gcry_cipher_test_algo (tv[i].algo) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     tv[i].algo);
           continue;
         }
 
       if (verbose)
         fprintf (stderr, "    checking large block stream for %s [%i] (%s)\n",
 		 gcry_cipher_algo_name (tv[i].algo), tv[i].algo, tv[i].name);
 
       err = gcry_cipher_open (&hde, tv[i].algo, GCRY_CIPHER_MODE_STREAM, 0);
       if (err)
         {
           fail ("large stream, gcry_cipher_open for stream mode failed: %s\n",
                 gpg_strerror (err));
           continue;
         }
 
       err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
       if (err)
         {
           fail ("large stream, gcry_cipher_setkey failed: %s\n",
                 gpg_strerror (err));
           goto next;
         }
 
       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
       if (err)
         {
           fail ("large stream, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           goto next;
         }
 
       for (j=0, p=buffer; j < buffersize/512; j++, p += 512)
         {
           err = gcry_cipher_encrypt (hde, p, 512, zeroes, 512);
           if (err)
             {
               fail ("large stream, "
                     "gcry_cipher_encrypt (%d) block %d failed: %s\n",
                     i, j, gpg_strerror (err));
               goto next;
             }
         }
       for (j=0, p=buffer+buffersize; j < 1024; j++, p++)
         if (*p != 0x5a)
           die ("large stream, buffer corrupted at j=%d\n", j);
 
       /* Now loop over all the data samples.  */
       for (j = 0; tv[i].data[j].length; j++)
         {
           assert (tv[i].data[j].offset + tv[i].data[j].length <= buffersize);
 
           if (memcmp (tv[i].data[j].result,
                       buffer + tv[i].data[j].offset, tv[i].data[j].length))
             {
               fail ("large stream, encrypt mismatch entry %d:%d\n", i, j);
               mismatch (tv[i].data[j].result, tv[i].data[j].length,
                         buffer + tv[i].data[j].offset, tv[i].data[j].length);
             }
         }
 
       /*
        *  Let's do the same thing again but using changing block sizes.
        */
       err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
       if (err)
         {
           fail ("large stream, gcry_cipher_setkey failed: %s\n",
                 gpg_strerror (err));
           goto next;
         }
 
       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
       if (err)
         {
           fail ("large stream, gcry_cipher_setiv failed: %s\n",
                 gpg_strerror (err));
           goto next;
         }
 
       for (n=0, p=buffer, j = 0; n < buffersize; n += j, p += j)
         {
           switch (j)
             {
             case   0: j =   1;  break;
             case   1: j =  64; break;
             case  64: j=  384; break;
             case 384: j =  63; break;
             case  63: j = 512; break;
             case 512: j =  32; break;
             case  32: j = 503; break;
             default:  j = 509; break;
             }
           if ( n + j >= buffersize )
             j = buffersize - n;
           assert (j <= 512);
           err = gcry_cipher_encrypt (hde, p, j, zeroes, j);
           if (err)
             {
               fail ("large stream, "
                     "gcry_cipher_encrypt (%d) offset %u failed: %s\n",
                     i, n, gpg_strerror (err));
               goto next;
             }
         }
       for (j=0, p=buffer+buffersize; j < 1024; j++, p++)
         if (*p != 0x5a)
           die ("large stream, buffer corrupted at j=%d (line %d)\n",
                j, __LINE__);
 
       /* Now loop over all the data samples.  */
       for (j = 0; tv[i].data[j].length; j++)
         {
           assert (tv[i].data[j].offset + tv[i].data[j].length <= buffersize);
 
           if (memcmp (tv[i].data[j].result,
                       buffer + tv[i].data[j].offset, tv[i].data[j].length))
             {
               fail ("large stream var, encrypt mismatch entry %d:%d\n", i, j);
               mismatch (tv[i].data[j].result, tv[i].data[j].length,
                         buffer + tv[i].data[j].offset, tv[i].data[j].length);
             }
         }
 
     next:
       gcry_cipher_close (hde);
     }
 
   gcry_free (buffer);
   if (verbose)
     fprintf (stderr, "  Completed large block stream cipher checks.\n");
 }
 
 
 
 /* Check that our bulk encryption functions work properly.  */
 static void
 check_bulk_cipher_modes (void)
 {
   static const struct
   {
     int algo;
     int mode;
     const char *key;
     int  keylen;
     const char *iv;
     int ivlen;
     char t1_hash[20];
   } tv[] = {
     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CFB,
       "abcdefghijklmnop", 16,
       "1234567890123456", 16,
 /*[0]*/
       { 0x53, 0xda, 0x27, 0x3c, 0x78, 0x3d, 0x54, 0x66, 0x19, 0x63,
         0xd7, 0xe6, 0x20, 0x10, 0xcd, 0xc0, 0x5a, 0x0b, 0x06, 0xcc }
     },
     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CFB,
       "abcdefghijklmnopABCDEFG", 24,
       "1234567890123456", 16,
 /*[1]*/
       { 0xc7, 0xb1, 0xd0, 0x09, 0x95, 0x04, 0x34, 0x61, 0x2b, 0xd9,
         0xcb, 0xb3, 0xc7, 0xcb, 0xef, 0xea, 0x16, 0x19, 0x9b, 0x3e }
     },
     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB,
       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
       "1234567890123456", 16,
 /*[2]*/
       { 0x31, 0xe1, 0x1f, 0x63, 0x65, 0x47, 0x8c, 0x3f, 0x53, 0xdb,
         0xd9, 0x4d, 0x91, 0x1d, 0x02, 0x9c, 0x05, 0x25, 0x58, 0x29 }
     },
     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CBC,
       "abcdefghijklmnop", 16,
       "1234567890123456", 16,
 /*[3]*/
       { 0xdc, 0x0c, 0xc2, 0xd9, 0x6b, 0x47, 0xf9, 0xeb, 0x06, 0xb4,
         0x2f, 0x6e, 0xec, 0x72, 0xbf, 0x55, 0x26, 0x7f, 0xa9, 0x97 }
     },
     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC,
       "abcdefghijklmnopABCDEFG", 24,
       "1234567890123456", 16,
 /*[4]*/
       { 0x2b, 0x90, 0x9b, 0xe6, 0x40, 0xab, 0x6e, 0xc2, 0xc5, 0xb1,
         0x87, 0xf5, 0x43, 0x84, 0x7b, 0x04, 0x06, 0x47, 0xd1, 0x8f }
     },
     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC,
       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
       "1234567890123456", 16,
 /*[5]*/
       { 0xaa, 0xa8, 0xdf, 0x03, 0xb0, 0xba, 0xc4, 0xe3, 0xc1, 0x02,
         0x38, 0x31, 0x8d, 0x86, 0xcb, 0x49, 0x6d, 0xad, 0xae, 0x01 }
     },
     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_OFB,
       "abcdefghijklmnop", 16,
       "1234567890123456", 16,
 /*[6]*/
       { 0x65, 0xfe, 0xde, 0x48, 0xd0, 0xa1, 0xa6, 0xf9, 0x24, 0x6b,
         0x52, 0x5f, 0x21, 0x8a, 0x6f, 0xc7, 0x70, 0x3b, 0xd8, 0x4a }
     },
     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_OFB,
       "abcdefghijklmnopABCDEFG", 24,
       "1234567890123456", 16,
 /*[7]*/
       { 0x59, 0x5b, 0x02, 0xa2, 0x88, 0xc0, 0xbe, 0x94, 0x43, 0xaa,
         0x39, 0xf6, 0xbd, 0xcc, 0x83, 0x99, 0xee, 0x00, 0xa1, 0x91 }
     },
     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB,
       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
       "1234567890123456", 16,
 /*[8]*/
       { 0x38, 0x8c, 0xe1, 0xe2, 0xbe, 0x67, 0x60, 0xe8, 0xeb, 0xce,
         0xd0, 0xc6, 0xaa, 0xd6, 0xf6, 0x26, 0x15, 0x56, 0xd0, 0x2b }
     },
     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CTR,
       "abcdefghijklmnop", 16,
       "1234567890123456", 16,
 /*[9]*/
       { 0x9a, 0x48, 0x94, 0xd6, 0x50, 0x46, 0x81, 0xdb, 0x68, 0x34,
         0x3b, 0xc5, 0x9e, 0x66, 0x94, 0x81, 0x98, 0xa0, 0xf9, 0xff }
     },
     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CTR,
       "abcdefghijklmnopABCDEFG", 24,
       "1234567890123456", 16,
 /*[10]*/
       { 0x2c, 0x2c, 0xd3, 0x75, 0x81, 0x2a, 0x59, 0x07, 0xeb, 0x08,
         0xce, 0x28, 0x4c, 0x0c, 0x6a, 0xa8, 0x8f, 0xa3, 0x98, 0x7e }
     },
     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CTR,
       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
       "1234567890123456", 16,
 /*[11]*/
       { 0x64, 0xce, 0x73, 0x03, 0xc7, 0x89, 0x99, 0x1f, 0xf1, 0xce,
         0xfe, 0xfb, 0xb9, 0x42, 0x30, 0xdf, 0xbb, 0x68, 0x6f, 0xd3 }
     },
     { GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB,
       "abcdefghijklmnop", 16,
       "1234567890123456", 16,
 /*[12]*/
       { 0x51, 0xae, 0xf5, 0xac, 0x22, 0xa0, 0xba, 0x11, 0xc5, 0xaa,
         0xb4, 0x70, 0x99, 0xce, 0x18, 0x08, 0x12, 0x9b, 0xb1, 0xc5 }
     },
     { GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_ECB,
       "abcdefghijklmnopABCDEFG", 24,
       "1234567890123456", 16,
 /*[13]*/
       { 0x57, 0x91, 0xea, 0x48, 0xd8, 0xbf, 0x9e, 0xc1, 0xae, 0x33,
         0xb3, 0xfd, 0xf7, 0x7a, 0xeb, 0x30, 0xb1, 0x62, 0x0d, 0x82 }
     },
     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_ECB,
       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
       "1234567890123456", 16,
 /*[14]*/
       { 0x2d, 0x71, 0x54, 0xb9, 0xc5, 0x28, 0x76, 0xff, 0x76, 0xb5,
         0x99, 0x37, 0x99, 0x9d, 0xf7, 0x10, 0x6d, 0x86, 0x4f, 0x3f }
     },
     { GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_XTS,
       "abcdefghijklmnopABCDEFGHIJKLMNOP", 32,
       "1234567890123456", 16,
 /*[15]*/
       { 0x71, 0x46, 0x40, 0xb0, 0xed, 0x6f, 0xc4, 0x82, 0x2b, 0x3f,
         0xb6, 0xf7, 0x81, 0x08, 0x4c, 0x8b, 0xc1, 0x66, 0x4c, 0x1b }
     },
     { GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_XTS,
       "abcdefghijklmnopABCDEFGHIJKLMNOP_abcdefghijklmnopABCDEFGHIJKLMNO", 64,
       "1234567890123456", 16,
 /*[16]*/
       { 0x8e, 0xbc, 0xa5, 0x21, 0x0a, 0x4b, 0x53, 0x14, 0x79, 0x81,
         0x25, 0xad, 0x24, 0x45, 0x98, 0xbd, 0x9f, 0x27, 0x5f, 0x01 }
     }
   };
   gcry_cipher_hd_t hde = NULL;
   gcry_cipher_hd_t hdd = NULL;
   unsigned char *buffer_base, *outbuf_base; /* Allocated buffers.  */
   unsigned char *buffer, *outbuf;           /* Aligned buffers.  */
   size_t buflen;
   unsigned char hash[20];
   int i, j, keylen, blklen;
   gcry_error_t err = 0;
 
   if (verbose)
     fprintf (stderr, "Starting bulk cipher checks.\n");
 
   buflen = 16*100;  /* We check a 1600 byte buffer.  */
   buffer_base = gcry_xmalloc (buflen+16);
   buffer = buffer_base + (16 - ((size_t)buffer_base & 0x0f));
   outbuf_base = gcry_xmalloc (buflen+16);
   outbuf = outbuf_base + (16 - ((size_t)outbuf_base & 0x0f));
 
 
   for (i = 0; i < DIM (tv); i++)
     {
       if (verbose)
         fprintf (stderr, "    checking bulk encryption for %s [%i], mode %d\n",
 		 gcry_cipher_algo_name (tv[i].algo),
 		 tv[i].algo, tv[i].mode);
       err = gcry_cipher_open (&hde, tv[i].algo, tv[i].mode, 0);
       if (!err)
         err = gcry_cipher_open (&hdd, tv[i].algo, tv[i].mode, 0);
       if (err)
         {
           fail ("gcry_cipher_open failed: %s\n", gpg_strerror (err));
           goto leave;
         }
 
       keylen = gcry_cipher_get_algo_keylen(tv[i].algo);
       if (!keylen)
         {
           fail ("gcry_cipher_get_algo_keylen failed\n");
           goto leave;
         }
 
       err = gcry_cipher_setkey (hde, tv[i].key, tv[i].keylen);
       if (!err)
         err = gcry_cipher_setkey (hdd, tv[i].key, tv[i].keylen);
       if (err)
         {
           fail ("gcry_cipher_setkey failed: %s\n", gpg_strerror (err));
           goto leave;
         }
 
       blklen = gcry_cipher_get_algo_blklen(tv[i].algo);
       if (!blklen)
         {
           fail ("gcry_cipher_get_algo_blklen failed\n");
           goto leave;
         }
 
       err = gcry_cipher_setiv (hde, tv[i].iv, tv[i].ivlen);
       if (!err)
         err = gcry_cipher_setiv (hdd, tv[i].iv,  tv[i].ivlen);
       if (err)
         {
           fail ("gcry_cipher_setiv failed: %s\n", gpg_strerror (err));
           goto leave;
         }
 
       /* Fill the buffer with our test pattern.  */
       for (j=0; j < buflen; j++)
         buffer[j] = ((j & 0xff) ^ ((j >> 8) & 0xff));
 
       err = gcry_cipher_encrypt (hde, outbuf, buflen, buffer, buflen);
       if (err)
         {
           fail ("gcry_cipher_encrypt (algo %d, mode %d) failed: %s\n",
                 tv[i].algo, tv[i].mode, gpg_strerror (err));
           goto leave;
         }
 
       gcry_md_hash_buffer (GCRY_MD_SHA1, hash, outbuf, buflen);
 #if 0
       printf ("/*[%d]*/\n", i);
       fputs ("      {", stdout);
       for (j=0; j < 20; j++)
         printf (" 0x%02x%c%s", hash[j], j==19? ' ':',', j == 9? "\n       ":"");
       puts ("}");
 #endif
 
       if (memcmp (hash, tv[i].t1_hash, 20))
         fail ("encrypt mismatch (algo %d, mode %d)\n",
               tv[i].algo, tv[i].mode);
 
       err = gcry_cipher_decrypt (hdd, outbuf, buflen, NULL, 0);
       if (err)
         {
           fail ("gcry_cipher_decrypt (algo %d, mode %d) failed: %s\n",
                 tv[i].algo, tv[i].mode, gpg_strerror (err));
           goto leave;
         }
 
       if (memcmp (buffer, outbuf, buflen))
         fail ("decrypt mismatch (algo %d, mode %d)\n",
               tv[i].algo, tv[i].mode);
 
       gcry_cipher_close (hde); hde = NULL;
       gcry_cipher_close (hdd); hdd = NULL;
     }
 
   if (verbose)
     fprintf (stderr, "Completed bulk cipher checks.\n");
  leave:
   gcry_cipher_close (hde);
   gcry_cipher_close (hdd);
   gcry_free (buffer_base);
   gcry_free (outbuf_base);
 }
 
 
 static unsigned int
 get_algo_mode_blklen (int algo, int mode)
 {
   unsigned int blklen = gcry_cipher_get_algo_blklen(algo);
 
   /* Some modes override blklen. */
   switch (mode)
     {
     case GCRY_CIPHER_MODE_STREAM:
     case GCRY_CIPHER_MODE_OFB:
     case GCRY_CIPHER_MODE_CTR:
     case GCRY_CIPHER_MODE_CFB:
     case GCRY_CIPHER_MODE_CFB8:
     case GCRY_CIPHER_MODE_CCM:
     case GCRY_CIPHER_MODE_GCM:
     case GCRY_CIPHER_MODE_EAX:
     case GCRY_CIPHER_MODE_POLY1305:
       return 1;
     }
 
   return blklen;
 }
 
 
 static unsigned int
 get_algo_mode_taglen (int algo, int mode)
 {
   switch (mode)
     {
     case GCRY_CIPHER_MODE_CCM:
     case GCRY_CIPHER_MODE_GCM:
     case GCRY_CIPHER_MODE_POLY1305:
       return 16;
     case GCRY_CIPHER_MODE_EAX:
       return gcry_cipher_get_algo_blklen(algo);
     }
 
   return 0;
 }
 
 
 static int
 check_one_cipher_core_reset (gcry_cipher_hd_t hd, int algo, int mode, int pass,
                              int nplain)
 {
   static const unsigned char iv[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
   u64 ctl_params[3];
   int err;
 
   gcry_cipher_reset (hd);
 
   if (mode == GCRY_CIPHER_MODE_OCB || mode == GCRY_CIPHER_MODE_CCM)
     {
       err = gcry_cipher_setiv (hd, iv, sizeof(iv));
       if (err)
         {
           fail ("pass %d, algo %d, mode %d, gcry_cipher_setiv failed: %s\n",
                 pass, algo, mode, gpg_strerror (err));
           gcry_cipher_close (hd);
           return -1;
         }
     }
 
   if (mode == GCRY_CIPHER_MODE_CCM)
     {
       ctl_params[0] = nplain; /* encryptedlen */
       ctl_params[1] = 0; /* aadlen */
       ctl_params[2] = 16; /* authtaglen */
       err = gcry_cipher_ctl (hd, GCRYCTL_SET_CCM_LENGTHS, ctl_params,
                             sizeof(ctl_params));
       if (err)
         {
           fail ("pass %d, algo %d, mode %d, gcry_cipher_ctl "
                 "GCRYCTL_SET_CCM_LENGTHS failed: %s\n",
                 pass, algo, mode, gpg_strerror (err));
           gcry_cipher_close (hd);
           return -1;
         }
     }
 
   return 0;
 }
 
 /* The core of the cipher check.  In addition to the parameters passed
    to check_one_cipher it also receives the KEY and the plain data.
    PASS is printed with error messages.  The function returns 0 on
    success.  */
 static int
 check_one_cipher_core (int algo, int mode, int flags,
                        const char *key, size_t nkey,
                        const unsigned char *plain, size_t nplain,
                        int bufshift, int pass)
 {
   gcry_cipher_hd_t hd;
   unsigned char *in_buffer, *out_buffer;
   unsigned char *enc_result;
   unsigned char tag_result[16];
   unsigned char tag[16];
   unsigned char *in, *out;
   int keylen;
   gcry_error_t err = 0;
   unsigned int blklen;
   unsigned int piecelen;
   unsigned int pos;
   unsigned int taglen;
 
   in_buffer = malloc (nplain + 1);
   out_buffer = malloc (nplain + 1);
   enc_result = malloc (nplain);
   if (!in_buffer || !out_buffer || !enc_result)
     {
       fail ("pass %d, algo %d, mode %d, malloc failed\n",
 	    pass, algo, mode);
       goto err_out_free;
     }
 
   blklen = get_algo_mode_blklen(algo, mode);
   taglen = get_algo_mode_taglen(algo, mode);
 
   assert (nkey == 64);
   assert (nplain > 0);
   assert ((nplain % 16) == 0);
   assert (blklen > 0);
 
   if ((mode == GCRY_CIPHER_MODE_CBC && (flags & GCRY_CIPHER_CBC_CTS)) ||
       mode == GCRY_CIPHER_MODE_XTS)
     {
       /* Input cannot be split in to multiple operations with CTS. */
       blklen = nplain;
     }
 
   if (!bufshift)
     {
       in = in_buffer;
       out = out_buffer;
     }
   else if (bufshift == 1)
     {
       in = in_buffer+1;
       out = out_buffer;
     }
   else if (bufshift == 2)
     {
       in = in_buffer+1;
       out = out_buffer+1;
     }
   else
     {
       in = in_buffer;
       out = out_buffer+1;
     }
 
   keylen = gcry_cipher_get_algo_keylen (algo);
   if (!keylen)
     {
       fail ("pass %d, algo %d, mode %d, gcry_cipher_get_algo_keylen failed\n",
 	    pass, algo, mode);
       goto err_out_free;
     }
 
   if (keylen < 40 / 8 || keylen > 32)
     {
       fail ("pass %d, algo %d, mode %d, keylength problem (%d)\n", pass, algo, mode, keylen);
       goto err_out_free;
     }
 
   if (mode == GCRY_CIPHER_MODE_XTS)
     {
       keylen *= 2;
     }
 
   err = gcry_cipher_open (&hd, algo, mode, flags);
   if (err)
     {
       fail ("pass %d, algo %d, mode %d, gcry_cipher_open failed: %s\n",
 	    pass, algo, mode, gpg_strerror (err));
       goto err_out_free;
     }
 
   err = gcry_cipher_setkey (hd, key, keylen);
   if (err)
     {
       fail ("pass %d, algo %d, mode %d, gcry_cipher_setkey failed: %s\n",
 	    pass, algo, mode, gpg_strerror (err));
       gcry_cipher_close (hd);
       goto err_out_free;
     }
 
   if (check_one_cipher_core_reset (hd, algo, mode, pass, nplain) < 0)
     goto err_out_free;
 
   err = gcry_cipher_encrypt (hd, out, nplain, plain, nplain);
   if (err)
     {
       fail ("pass %d, algo %d, mode %d, gcry_cipher_encrypt failed: %s\n",
 	    pass, algo, mode, gpg_strerror (err));
       gcry_cipher_close (hd);
       goto err_out_free;
     }
 
   if (taglen > 0)
     {
       err = gcry_cipher_gettag (hd, tag, taglen);
       if (err)
 	{
 	  fail ("pass %d, algo %d, mode %d, gcry_cipher_gettag failed: %s\n",
 		pass, algo, mode, gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  goto err_out_free;
 	}
 
       memcpy(tag_result, tag, taglen);
     }
 
   memcpy (enc_result, out, nplain);
 
   if (check_one_cipher_core_reset (hd, algo, mode, pass, nplain) < 0)
     goto err_out_free;
 
   err = gcry_cipher_decrypt (hd, in, nplain, out, nplain);
   if (err)
     {
       fail ("pass %d, algo %d, mode %d, gcry_cipher_decrypt failed: %s\n",
 	    pass, algo, mode, gpg_strerror (err));
       gcry_cipher_close (hd);
       goto err_out_free;
     }
 
   if (taglen > 0)
     {
       err = gcry_cipher_checktag (hd, tag_result, taglen);
       if (err)
 	{
 	  fail ("pass %d, algo %d, mode %d, gcry_cipher_checktag failed: %s\n",
 		pass, algo, mode, gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  goto err_out_free;
 	}
     }
 
   if (memcmp (plain, in, nplain))
     fail ("pass %d, algo %d, mode %d, encrypt-decrypt mismatch\n",
           pass, algo, mode);
 
   /* Again, using in-place encryption.  */
   if (check_one_cipher_core_reset (hd, algo, mode, pass, nplain) < 0)
     goto err_out_free;
 
   memcpy (out, plain, nplain);
   err = gcry_cipher_encrypt (hd, out, nplain, NULL, 0);
   if (err)
     {
       fail ("pass %d, algo %d, mode %d, in-place, gcry_cipher_encrypt failed:"
             " %s\n",
 	    pass, algo, mode, gpg_strerror (err));
       gcry_cipher_close (hd);
       goto err_out_free;
     }
 
   if (taglen > 0)
     {
       err = gcry_cipher_gettag (hd, tag, taglen);
       if (err)
 	{
 	  fail ("pass %d, algo %d, mode %d, in-place, "
 		"gcry_cipher_gettag failed: %s\n",
 		pass, algo, mode, gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  goto err_out_free;
 	}
 
       if (memcmp (tag_result, tag, taglen))
 	fail ("pass %d, algo %d, mode %d, in-place, tag mismatch\n",
 	      pass, algo, mode);
     }
 
   if (memcmp (enc_result, out, nplain))
     fail ("pass %d, algo %d, mode %d, in-place, encrypt mismatch\n",
           pass, algo, mode);
 
   if (check_one_cipher_core_reset (hd, algo, mode, pass, nplain) < 0)
     goto err_out_free;
 
   err = gcry_cipher_decrypt (hd, out, nplain, NULL, 0);
   if (err)
     {
       fail ("pass %d, algo %d, mode %d, in-place, gcry_cipher_decrypt failed:"
             " %s\n",
 	    pass, algo, mode, gpg_strerror (err));
       gcry_cipher_close (hd);
       goto err_out_free;
     }
 
   if (taglen > 0)
     {
       err = gcry_cipher_checktag (hd, tag_result, taglen);
       if (err)
 	{
 	  fail ("pass %d, algo %d, mode %d, in-place, "
 		"gcry_cipher_checktag failed: %s\n",
 		pass, algo, mode, gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  goto err_out_free;
 	}
     }
 
   if (memcmp (plain, out, nplain))
     fail ("pass %d, algo %d, mode %d, in-place, encrypt-decrypt mismatch\n",
           pass, algo, mode);
 
   /* Again, splitting encryption in multiple operations. */
   if (check_one_cipher_core_reset (hd, algo, mode, pass, nplain) < 0)
     goto err_out_free;
 
   piecelen = blklen;
   pos = 0;
   while (pos < nplain)
     {
       if (piecelen > nplain - pos)
         piecelen = nplain - pos;
 
       err = gcry_cipher_encrypt (hd, out + pos, piecelen, plain + pos,
                                  piecelen);
       if (err)
         {
           fail ("pass %d, algo %d, mode %d, split-buffer (pos: %d, "
                 "piecelen: %d), gcry_cipher_encrypt failed: %s\n",
                 pass, algo, mode, pos, piecelen, gpg_strerror (err));
           gcry_cipher_close (hd);
           goto err_out_free;
         }
 
       pos += piecelen;
       piecelen = piecelen * 2 - ((piecelen != blklen) ? blklen : 0);
     }
 
   if (taglen > 0)
     {
       err = gcry_cipher_gettag (hd, tag, taglen);
       if (err)
 	{
 	  fail ("pass %d, algo %d, mode %d, split-buffer (pos: %d, "
                 "piecelen: %d), gcry_cipher_gettag failed: %s\n",
 		pass, algo, mode, pos, piecelen, gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  goto err_out_free;
 	}
 
       if (memcmp (tag_result, tag, taglen))
 	fail ("pass %d, algo %d, mode %d, in-place, tag mismatch\n",
 	      pass, algo, mode);
     }
 
   if (memcmp (enc_result, out, nplain))
     fail ("pass %d, algo %d, mode %d, split-buffer, encrypt mismatch\n",
           pass, algo, mode);
 
   if (check_one_cipher_core_reset (hd, algo, mode, pass, nplain) < 0)
     goto err_out_free;
 
   piecelen = blklen;
   pos = 0;
   while (pos < nplain)
     {
       if (piecelen > nplain - pos)
         piecelen = nplain - pos;
 
       err = gcry_cipher_decrypt (hd, in + pos, piecelen, out + pos, piecelen);
       if (err)
         {
           fail ("pass %d, algo %d, mode %d, split-buffer (pos: %d, "
                 "piecelen: %d), gcry_cipher_decrypt failed: %s\n",
                 pass, algo, mode, pos, piecelen, gpg_strerror (err));
           gcry_cipher_close (hd);
           goto err_out_free;
         }
 
       pos += piecelen;
       piecelen = piecelen * 2 - ((piecelen != blklen) ? blklen : 0);
     }
 
   if (taglen > 0)
     {
       err = gcry_cipher_checktag (hd, tag_result, taglen);
       if (err)
 	{
 	  fail ("pass %d, algo %d, mode %d, split-buffer (pos: %d, "
                 "piecelen: %d), gcry_cipher_checktag failed: %s\n",
 		pass, algo, mode, pos, piecelen, gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  goto err_out_free;
 	}
     }
 
   if (memcmp (plain, in, nplain))
     fail ("pass %d, algo %d, mode %d, split-buffer, encrypt-decrypt mismatch\n",
           pass, algo, mode);
 
   /* Again, using in-place encryption and splitting encryption in multiple
    * operations. */
   if (check_one_cipher_core_reset (hd, algo, mode, pass, nplain) < 0)
     goto err_out_free;
 
   piecelen = blklen;
   pos = 0;
   while (pos < nplain)
     {
       if (piecelen > nplain - pos)
         piecelen = nplain - pos;
 
       memcpy (out + pos, plain + pos, piecelen);
       err = gcry_cipher_encrypt (hd, out + pos, piecelen, NULL, 0);
       if (err)
         {
           fail ("pass %d, algo %d, mode %d, in-place split-buffer (pos: %d, "
                 "piecelen: %d), gcry_cipher_encrypt failed: %s\n",
                 pass, algo, mode, pos, piecelen, gpg_strerror (err));
           gcry_cipher_close (hd);
           goto err_out_free;
         }
 
       pos += piecelen;
       piecelen = piecelen * 2 - ((piecelen != blklen) ? blklen : 0);
     }
 
   if (memcmp (enc_result, out, nplain))
     fail ("pass %d, algo %d, mode %d, in-place split-buffer, encrypt mismatch\n",
           pass, algo, mode);
 
   if (check_one_cipher_core_reset (hd, algo, mode, pass, nplain) < 0)
     goto err_out_free;
 
   piecelen = blklen;
   pos = 0;
   while (pos < nplain)
     {
       if (piecelen > nplain - pos)
         piecelen = nplain - pos;
 
       err = gcry_cipher_decrypt (hd, out + pos, piecelen, NULL, 0);
       if (err)
         {
           fail ("pass %d, algo %d, mode %d, in-place split-buffer (pos: %d, "
                 "piecelen: %d), gcry_cipher_decrypt failed: %s\n",
                 pass, algo, mode, pos, piecelen, gpg_strerror (err));
           gcry_cipher_close (hd);
           goto err_out_free;
         }
 
       pos += piecelen;
       piecelen = piecelen * 2 - ((piecelen != blklen) ? blklen : 0);
     }
 
   if (memcmp (plain, out, nplain))
     fail ("pass %d, algo %d, mode %d, in-place split-buffer, encrypt-decrypt"
           " mismatch\n", pass, algo, mode);
 
 
   gcry_cipher_close (hd);
 
   free (enc_result);
   free (out_buffer);
   free (in_buffer);
   return 0;
 
 err_out_free:
   free (enc_result);
   free (out_buffer);
   free (in_buffer);
   return -1;
 }
 
 
 
 static void
 check_one_cipher (int algo, int mode, int flags)
 {
   size_t medium_buffer_size = 2048 - 16;
   size_t large_buffer_size = 64 * 1024 + 1024 - 16;
   char key[64+1];
   unsigned char *plain;
   int bufshift, i;
 
   plain = malloc (large_buffer_size + 1);
   if (!plain)
     {
       fail ("pass %d, algo %d, mode %d, malloc failed\n", -1, algo, mode);
       return;
     }
 
   for (bufshift = 0; bufshift < 4; bufshift++)
     {
       /* Pass 0: Standard test.  */
       memcpy (key, "0123456789abcdef.,;/[]{}-=ABCDEF_"
 		   "0123456789abcdef.,;/[]{}-=ABCDEF", 64);
       memcpy (plain, "foobar42FOOBAR17", 16);
       for (i = 16; i < medium_buffer_size; i += 16)
         {
           memcpy (&plain[i], &plain[i-16], 16);
           if (!++plain[i+7])
             plain[i+6]++;
           if (!++plain[i+15])
             plain[i+14]++;
         }
 
       if (check_one_cipher_core (algo, mode, flags, key, 64, plain,
 				 medium_buffer_size, bufshift,
 				 0+10*bufshift))
         goto out;
 
       /* Pass 1: Key not aligned.  */
       memmove (key+1, key, 64);
       if (check_one_cipher_core (algo, mode, flags, key+1, 64, plain,
 				 medium_buffer_size, bufshift,
 				 1+10*bufshift))
         goto out;
 
       /* Pass 2: Key not aligned and data not aligned.  */
       memmove (plain+1, plain, medium_buffer_size);
       if (check_one_cipher_core (algo, mode, flags, key+1, 64, plain+1,
 				 medium_buffer_size, bufshift,
 				 2+10*bufshift))
         goto out;
 
       /* Pass 3: Key aligned and data not aligned.  */
       memmove (key, key+1, 64);
       if (check_one_cipher_core (algo, mode, flags, key, 64, plain+1,
 				 medium_buffer_size, bufshift,
 				 3+10*bufshift))
         goto out;
     }
 
   /* Pass 5: Large buffer test.  */
   memcpy (key, "0123456789abcdef.,;/[]{}-=ABCDEF_"
 		"0123456789abcdef.,;/[]{}-=ABCDEF", 64);
   memcpy (plain, "foobar42FOOBAR17", 16);
   for (i = 16; i < large_buffer_size; i += 16)
     {
       memcpy (&plain[i], &plain[i-16], 16);
       if (!++plain[i+7])
 	plain[i+6]++;
       if (!++plain[i+15])
 	plain[i+14]++;
     }
 
   if (check_one_cipher_core (algo, mode, flags, key, 64, plain,
 			     large_buffer_size, bufshift,
 			     50))
     goto out;
 
 out:
   free (plain);
 }
 
 
 
 static void
 check_ciphers (void)
 {
   static const int algos[] = {
 #if USE_BLOWFISH
     GCRY_CIPHER_BLOWFISH,
 #endif
 #if USE_DES
     GCRY_CIPHER_DES,
     GCRY_CIPHER_3DES,
 #endif
 #if USE_CAST5
     GCRY_CIPHER_CAST5,
 #endif
 #if USE_AES
     GCRY_CIPHER_AES,
     GCRY_CIPHER_AES192,
     GCRY_CIPHER_AES256,
 #endif
 #if USE_TWOFISH
     GCRY_CIPHER_TWOFISH,
     GCRY_CIPHER_TWOFISH128,
 #endif
 #if USE_SERPENT
     GCRY_CIPHER_SERPENT128,
     GCRY_CIPHER_SERPENT192,
     GCRY_CIPHER_SERPENT256,
 #endif
 #if USE_RFC2268
     GCRY_CIPHER_RFC2268_40,
 #endif
 #if USE_SEED
     GCRY_CIPHER_SEED,
 #endif
 #if USE_CAMELLIA
     GCRY_CIPHER_CAMELLIA128,
     GCRY_CIPHER_CAMELLIA192,
     GCRY_CIPHER_CAMELLIA256,
 #endif
 #if USE_IDEA
     GCRY_CIPHER_IDEA,
 #endif
 #if USE_GOST28147
     GCRY_CIPHER_GOST28147,
 #endif
     0
   };
   static const int algos2[] = {
 #if USE_ARCFOUR
     GCRY_CIPHER_ARCFOUR,
 #endif
 #if USE_SALSA20
     GCRY_CIPHER_SALSA20,
     GCRY_CIPHER_SALSA20R12,
 #endif
 #if USE_CHACHA20
     GCRY_CIPHER_CHACHA20,
 #endif
     0
   };
   int i;
 
   if (verbose)
     fprintf (stderr, "Starting Cipher checks.\n");
   for (i = 0; algos[i]; i++)
     {
       if (gcry_cipher_test_algo (algos[i]) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     algos[i]);
           continue;
         }
       if (verbose)
 	fprintf (stderr, "  checking %s [%i]\n",
 		 gcry_cipher_algo_name (algos[i]),
 		 gcry_cipher_map_name (gcry_cipher_algo_name (algos[i])));
 
       check_one_cipher (algos[i], GCRY_CIPHER_MODE_ECB, 0);
       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CFB, 0);
       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CFB8, 0);
       check_one_cipher (algos[i], GCRY_CIPHER_MODE_OFB, 0);
       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, 0);
       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_CBC_CTS);
       check_one_cipher (algos[i], GCRY_CIPHER_MODE_CTR, 0);
       check_one_cipher (algos[i], GCRY_CIPHER_MODE_EAX, 0);
       if (gcry_cipher_get_algo_blklen (algos[i]) == GCRY_CCM_BLOCK_LEN)
         check_one_cipher (algos[i], GCRY_CIPHER_MODE_CCM, 0);
       if (gcry_cipher_get_algo_blklen (algos[i]) == GCRY_GCM_BLOCK_LEN)
         check_one_cipher (algos[i], GCRY_CIPHER_MODE_GCM, 0);
       if (gcry_cipher_get_algo_blklen (algos[i]) == GCRY_OCB_BLOCK_LEN)
         check_one_cipher (algos[i], GCRY_CIPHER_MODE_OCB, 0);
       if (gcry_cipher_get_algo_blklen (algos[i]) == GCRY_XTS_BLOCK_LEN)
         check_one_cipher (algos[i], GCRY_CIPHER_MODE_XTS, 0);
     }
 
   for (i = 0; algos2[i]; i++)
     {
       if (gcry_cipher_test_algo (algos2[i]) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     algos2[i]);
           continue;
         }
       if (verbose)
 	fprintf (stderr, "  checking %s\n",
 		 gcry_cipher_algo_name (algos2[i]));
 
       check_one_cipher (algos2[i], GCRY_CIPHER_MODE_STREAM, 0);
       if (algos2[i] == GCRY_CIPHER_CHACHA20)
 	check_one_cipher (algos2[i], GCRY_CIPHER_MODE_POLY1305, 0);
     }
   /* we have now run all cipher's selftests */
 
   if (verbose)
     fprintf (stderr, "Completed Cipher checks.\n");
 
   /* TODO: add some extra encryption to test the higher level functions */
 }
 
 
 static void
 check_cipher_modes(void)
 {
   if (verbose)
     fprintf (stderr, "Starting Cipher Mode checks.\n");
 
   check_ecb_cipher ();
   check_aes128_cbc_cts_cipher ();
   check_cbc_mac_cipher ();
   check_ctr_cipher ();
   check_cfb_cipher ();
   check_ofb_cipher ();
   check_ccm_cipher ();
   check_gcm_cipher ();
   check_poly1305_cipher ();
   check_ocb_cipher ();
   check_xts_cipher ();
   check_eax_cipher ();
   check_gost28147_cipher ();
   check_stream_cipher ();
   check_stream_cipher_large_block ();
 
   if (verbose)
     fprintf (stderr, "Completed Cipher Mode checks.\n");
 }
 
 
 static void
 fillbuf_count (char *buf, size_t buflen, unsigned char pos)
 {
   while (buflen--)
     *((unsigned char *)(buf++)) = pos++;
 }
 
 
 static void
 check_one_md (int algo, const char *data, int len, const char *expect, int elen,
 	      const char *key, int klen)
 {
   gcry_md_hd_t hd, hd2;
   unsigned char *p;
   int mdlen;
   int i, j;
   int xof = 0;
   gcry_error_t err = 0;
 
   err = gcry_md_open (&hd, algo, 0);
   if (err)
     {
       fail ("algo %d, gcry_md_open failed: %s\n", algo, gpg_strerror (err));
       return;
     }
 
   mdlen = gcry_md_get_algo_dlen (algo);
   if (mdlen < 1 || mdlen > 500)
     {
       if (mdlen == 0 && (algo == GCRY_MD_SHAKE128 || algo == GCRY_MD_SHAKE256))
         {
           xof = 1;
         }
       else
         {
 	  gcry_md_close (hd);
           fail ("algo %d, gcry_md_get_algo_dlen failed: %d\n", algo, mdlen);
           return;
         }
     }
 
   if (key && klen)
     {
       err = gcry_md_setkey (hd, key, klen);
       if (err)
 	{
 	  gcry_md_close (hd);
 	  fail ("algo %d, gcry_md_setkey failed: %s\n", algo, gpg_strerror (err));
 	  return;
 	}
     }
 
   if (*data == '!' && !data[1] && !xof)
    {
       unsigned char *p1, *p2;
       char buf[129];
 
       /* Test hashing small input sizes first as full block, then byte-by-byte
        * and check that resulting digests are the same. */
 
       err = gcry_md_open (&hd2, algo, 0);
       if (err)
 	{
 	  gcry_md_close (hd);
 	  fail ("algo %d, gcry_md_open failed: %s\n", algo, gpg_strerror (err));
 	  return;
 	}
 
       if (key && klen)
 	{
 	  err = gcry_md_setkey (hd2, key, klen);
 	  if (err)
 	    {
 	      gcry_md_close (hd);
 	      gcry_md_close (hd2);
 	      fail ("algo %d, gcry_md_setkey failed: %s\n", algo, gpg_strerror (err));
 	      return;
 	    }
 	}
 
       for (i = 0; i < sizeof(buf); i++)
 	buf[i] = i;
 
       for (i = 1; i < sizeof(buf); i++)
 	{
 	  gcry_md_reset (hd);
 	  gcry_md_reset (hd2);
 
           gcry_md_write (hd, buf, i);
 	  for (j = 0; j < i; j++)
 	    gcry_md_write (hd2, &buf[j], 1);
 
 	  p1 = gcry_md_read (hd, algo);
 	  p2 = gcry_md_read (hd2, algo);
 	  if (memcmp (p1, p2, mdlen))
 	    {
 	      printf ("full block (input length %d): ", i);
 	      for (i = 0; i < mdlen; i++)
 		printf ("%02x ", p1[i] & 0xFF);
 	      printf ("\nbyte-by-byte: ");
 	      for (i = 0; i < mdlen; i++)
 		printf ("%02x ", p2[i] & 0xFF);
 	      printf ("\n");
 
 	      fail ("algo %d, digest mismatch\n", algo);
 	    }
 	}
 
       gcry_md_close (hd2);
       gcry_md_reset (hd);
    }
 
   if ((*data == '!' && !data[1]) || /* hash one million times a "a" */
       (*data == '?' && !data[1]))   /* hash million byte data-set with byte pattern 0x00,0x01,0x02,... */
     {
       char aaa[1000];
       size_t left = 1000 * 1000;
       size_t startlen = 1;
       size_t piecelen = startlen;
 
       if (*data == '!')
         memset (aaa, 'a', 1000);
 
       /* Write in chuck with all sizes 1 to 1000 (500500 bytes)  */
       for (i = 1; i <= 1000 && left > 0; i++)
         {
           piecelen = i;
           if (piecelen > sizeof(aaa))
             piecelen = sizeof(aaa);
           if (piecelen > left)
             piecelen = left;
 
 	  if (*data == '?')
 	    fillbuf_count(aaa, piecelen, 1000 * 1000 - left);
 
           gcry_md_write (hd, aaa, piecelen);
 
           left -= piecelen;
         }
 
       /* Write in odd size chunks so that we test the buffering.  */
       while (left > 0)
         {
           if (piecelen > sizeof(aaa))
             piecelen = sizeof(aaa);
           if (piecelen > left)
             piecelen = left;
 
 	  if (*data == '?')
 	    fillbuf_count(aaa, piecelen, 1000 * 1000 - left);
 
           gcry_md_write (hd, aaa, piecelen);
 
           left -= piecelen;
 
           if (piecelen == sizeof(aaa))
             piecelen = ++startlen;
           else
             piecelen = piecelen * 2 - ((piecelen != startlen) ? startlen : 0);
         }
     }
   else
     gcry_md_write (hd, data, len);
 
   err = gcry_md_copy (&hd2, hd);
   if (err)
     {
       fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
     }
 
   gcry_md_close (hd);
 
   if (!xof)
     {
       p = gcry_md_read (hd2, algo);
 
       if (memcmp (p, expect, mdlen))
         {
           printf ("computed: ");
           for (i = 0; i < mdlen; i++)
             printf ("%02x ", p[i] & 0xFF);
           printf ("\nexpected: ");
           for (i = 0; i < mdlen; i++)
             printf ("%02x ", expect[i] & 0xFF);
           printf ("\n");
 
           fail ("algo %d, digest mismatch\n", algo);
         }
     }
   else
     {
       char buf[1000];
       int outmax = sizeof(buf) > elen ? elen : sizeof(buf);
 
       err = gcry_md_copy (&hd, hd2);
       if (err)
 	{
 	  fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
 	}
 
       err = gcry_md_extract(hd2, algo, buf, outmax);
       if (err)
 	{
 	  fail ("algo %d, gcry_md_extract failed: %s\n", algo, gpg_strerror (err));
 	}
 
       if (memcmp (buf, expect, outmax))
 	{
 	  printf ("computed: ");
 	  for (i = 0; i < outmax; i++)
 	    printf ("%02x ", buf[i] & 0xFF);
 	  printf ("\nexpected: ");
 	  for (i = 0; i < outmax; i++)
 	    printf ("%02x ", expect[i] & 0xFF);
 	  printf ("\n");
 
 	  fail ("algo %d, digest mismatch\n", algo);
 	}
 
       memset(buf, 0, sizeof(buf));
 
       /* Extract one byte at time. */
       for (i = 0; i < outmax && !err; i++)
 	err = gcry_md_extract(hd, algo, &buf[i], 1);
       if (err)
 	{
 	  fail ("algo %d, gcry_md_extract failed: %s\n", algo, gpg_strerror (err));
 	}
 
       if (memcmp (buf, expect, outmax))
 	{
 	  printf ("computed: ");
 	  for (i = 0; i < outmax; i++)
 	    printf ("%02x ", buf[i] & 0xFF);
 	  printf ("\nexpected: ");
 	  for (i = 0; i < outmax; i++)
 	    printf ("%02x ", expect[i] & 0xFF);
 	  printf ("\n");
 
 	  fail ("algo %d, digest mismatch\n", algo);
 	}
 
       if (*data == '!' && !data[1])
 	{
 	  int crcalgo = GCRY_MD_RMD160;
 	  gcry_md_hd_t crc1, crc2;
 	  size_t startlen;
 	  size_t piecelen;
 	  size_t left;
 	  const unsigned char *p1, *p2;
 	  int crclen;
 
 	  crclen = gcry_md_get_algo_dlen (crcalgo);
 
 	  err = gcry_md_open (&crc1, crcalgo, 0);
 	  if (err)
 	    {
 	      fail ("algo %d, crcalgo: %d, gcry_md_open failed: %s\n", algo,
 		    crcalgo, gpg_strerror (err));
 	      return;
 	    }
 
 	  err = gcry_md_open (&crc2, crcalgo, 0);
 	  if (err)
 	    {
 	      fail ("algo %d, crcalgo: %d, gcry_md_open failed: %s\n", algo,
 		    crcalgo, gpg_strerror (err));
 	      return;
 	    }
 
 	  /* Extract large chucks, total 1000000 additional bytes. */
 	  for (i = 0; i < 1000; i++)
 	    {
 	      err = gcry_md_extract(hd, algo, buf, 1000);
 	      if (!err)
 		gcry_md_write(crc1, buf, 1000);
 	    }
 	  if (err)
 	    {
 	      fail ("algo %d, gcry_md_extract failed: %s\n", algo,
 		    gpg_strerror (err));
 	    }
 
 	  /* Extract in odd size chunks, total 1000000 additional bytes.  */
 	  left = 1000 * 1000;
 	  startlen = 1;
 	  piecelen = startlen;
 
 	  while (!err && left > 0)
 	    {
 	      if (piecelen > sizeof(buf))
 		piecelen = sizeof(buf);
 	      if (piecelen > left)
 		piecelen = left;
 
 	      err = gcry_md_extract (hd2, algo, buf, piecelen);
 	      if (!err)
 		gcry_md_write(crc2, buf, piecelen);
 	      if (err)
 		{
 		  fail ("algo %d, gcry_md_extract failed: %s\n", algo,
 			gpg_strerror (err));
 		}
 
 	      left -= piecelen;
 
 	      if (piecelen == sizeof(buf))
 		piecelen = ++startlen;
 	      else
 		piecelen = piecelen * 2 - ((piecelen != startlen) ? startlen : 0);
 	    }
 
 	  p1 = gcry_md_read (crc1, crcalgo);
 	  p2 = gcry_md_read (crc2, crcalgo);
 
 	  if (memcmp (p1, p2, crclen))
 	    {
 	      printf ("computed: ");
 	      for (i = 0; i < crclen; i++)
 		printf ("%02x ", p2[i] & 0xFF);
 	      printf ("\nexpected: ");
 	      for (i = 0; i < crclen; i++)
 		printf ("%02x ", p1[i] & 0xFF);
 	      printf ("\n");
 
 	      fail ("algo %d, large xof output mismatch\n", algo);
 	    }
 
 	  gcry_md_close (crc1);
 	  gcry_md_close (crc2);
 	}
 
       gcry_md_close (hd);
     }
 
   gcry_md_close (hd2);
 }
 
 
 static void
 check_one_md_multi (int algo, const char *data, int len, const char *expect)
 {
   gpg_error_t err;
   gcry_buffer_t iov[3];
   int iovcnt;
   char digest[64];
   int mdlen;
   int i;
 
   mdlen = gcry_md_get_algo_dlen (algo);
   if (mdlen < 1 || mdlen > 64)
     {
       if (mdlen == 0 && (algo == GCRY_MD_SHAKE128 || algo == GCRY_MD_SHAKE256))
         return;
 
       fail ("check_one_md_multi: algo %d, gcry_md_get_algo_dlen failed: %d\n",
             algo, mdlen);
       return;
     }
 
   if (*data == '!' && !data[1])
     return;  /* We can't do that here.  */
   if (*data == '?' && !data[1])
     return;  /* We can't do that here.  */
 
   memset (iov, 0, sizeof iov);
 
   iov[0].data = (void*)data;
   if (len)
     {
       iov[0].len = 1;
       len--;
       data++;
     }
   iovcnt = 1;
   if (len >= 4)
     {
       iov[iovcnt].data = (void*)data;
       iov[iovcnt].len = 4;
       iovcnt++;
       data += 4;
       len  -= 4;
     }
   iov[iovcnt].data = (void*)data;
   iov[iovcnt].len = len;
   iovcnt++;
   assert (iovcnt <= DIM (iov));
 
   err = gcry_md_hash_buffers (algo, 0, digest, iov, iovcnt);
   if (err)
     {
       fail ("check_one_md_multi: algo %d, gcry_hash_buffers failed: %s\n",
             algo, gpg_strerror (err));
       return;
     }
   if (memcmp (digest, expect, mdlen))
     {
       printf ("computed: ");
       for (i = 0; i < mdlen; i++)
 	printf ("%02x ", digest[i] & 0xFF);
       printf ("\nexpected: ");
       for (i = 0; i < mdlen; i++)
 	printf ("%02x ", expect[i] & 0xFF);
       printf ("\n");
 
       fail ("check_one_md_multi: algo %d, digest mismatch\n", algo);
     }
 }
 
 
 static void
 check_one_md_final(int algo, const char *expect, unsigned int expectlen)
 {
   char inbuf[288 + 1];
   char xorbuf[64];
   char digest[64];
   unsigned int mdlen;
   int i, j;
 
   mdlen = gcry_md_get_algo_dlen (algo);
   if (mdlen < 1 || mdlen > 64)
     {
       return;
     }
 
   if (expectlen == 0)
     expectlen = mdlen;
 
   if (expectlen != mdlen)
     {
       fail ("check_one_md_final: algo %d, digest length mismatch\n", algo);
       return;
     }
 
   for (i = 0; i < sizeof(inbuf); i++)
     inbuf[i] = i;
 
   gcry_md_hash_buffer (algo, xorbuf, NULL, 0);
   for (i = 1; i < sizeof(inbuf); i++)
     {
       gcry_md_hash_buffer (algo, digest, inbuf, i);
       for (j = 0; j < expectlen; j++)
 	xorbuf[j] ^= digest[j];
     }
 
   if (memcmp(expect, xorbuf, expectlen) != 0)
     {
       printf ("computed: ");
       for (i = 0; i < expectlen; i++)
 	printf ("%02x ", xorbuf[i] & 0xFF);
       printf ("\nexpected: ");
       for (i = 0; i < expectlen; i++)
 	printf ("%02x ", expect[i] & 0xFF);
       printf ("\n");
 
       fail ("check_one_md_final: algo %d, digest mismatch\n", algo);
     }
 }
 
 
 static void
 check_digests (void)
 {
   static const char blake2_data_vector[] =
       "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
       "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
       "\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f"
       "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f"
       "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f"
       "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f"
       "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f"
       "\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f"
       "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
       "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
       "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf"
       "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
       "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
       "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
       "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
       "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff";
   static const struct algos
   {
     int md;
     const char *data;
     const char *expect;
     int datalen;
     int expectlen;
     const char *key;
     int keylen;
   } algos[] =
     {
       { GCRY_MD_MD2, "",
         "\x83\x50\xe5\xa3\xe2\x4c\x15\x3d\xf2\x27\x5c\x9f\x80\x69\x27\x73" },
       { GCRY_MD_MD2, "a",
         "\x32\xec\x01\xec\x4a\x6d\xac\x72\xc0\xab\x96\xfb\x34\xc0\xb5\xd1" },
       {	GCRY_MD_MD2, "message digest",
         "\xab\x4f\x49\x6b\xfb\x2a\x53\x0b\x21\x9f\xf3\x30\x31\xfe\x06\xb0" },
       { GCRY_MD_MD4, "",
 	"\x31\xD6\xCF\xE0\xD1\x6A\xE9\x31\xB7\x3C\x59\xD7\xE0\xC0\x89\xC0" },
       { GCRY_MD_MD4, "a",
 	"\xbd\xe5\x2c\xb3\x1d\xe3\x3e\x46\x24\x5e\x05\xfb\xdb\xd6\xfb\x24" },
       {	GCRY_MD_MD4, "message digest",
 	"\xd9\x13\x0a\x81\x64\x54\x9f\xe8\x18\x87\x48\x06\xe1\xc7\x01\x4b" },
       {	GCRY_MD_MD5, "",
 	"\xD4\x1D\x8C\xD9\x8F\x00\xB2\x04\xE9\x80\x09\x98\xEC\xF8\x42\x7E" },
       {	GCRY_MD_MD5, "a",
 	"\x0C\xC1\x75\xB9\xC0\xF1\xB6\xA8\x31\xC3\x99\xE2\x69\x77\x26\x61" },
       { GCRY_MD_MD5, "abc",
 	"\x90\x01\x50\x98\x3C\xD2\x4F\xB0\xD6\x96\x3F\x7D\x28\xE1\x7F\x72" },
       { GCRY_MD_MD5, "message digest",
 	"\xF9\x6B\x69\x7D\x7C\xB7\x93\x8D\x52\x5A\x2F\x31\xAA\xF1\x61\xD0" },
       { GCRY_MD_MD5,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\xc4\x1a\x5c\x0b\x44\x5f\xba\x1a\xda\xbc\xc0\x38\x0e\x0c\x9e\x33" },
       { GCRY_MD_MD5, "!",
         "\x77\x07\xd6\xae\x4e\x02\x7c\x70\xee\xa2\xa9\x35\xc2\x29\x6f\x21" },
       { GCRY_MD_MD5, "?",
         "\x5c\x72\x5c\xbc\x2d\xbb\xe1\x14\x81\x59\xe9\xd9\xcf\x90\x64\x8f" },
       { GCRY_MD_SHA1, "abc",
 	"\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E"
 	"\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" },
       {	GCRY_MD_SHA1,
 	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 	"\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE"
 	"\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" },
       { GCRY_MD_SHA1, "!" /* kludge for "a"*1000000 */ ,
 	"\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E"
 	"\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" },
       { GCRY_MD_SHA1, "?" /* kludge for "\x00\x01\x02"..."\xfe\xff\x00\x01"... (length 1000000) */ ,
 	"\x5f\x8d\x3c\x4f\x12\xf0\x49\x9e\x28\x73"
 	"\x79\xec\x97\x3b\x98\x4c\x94\x75\xaa\x8f" },
       { GCRY_MD_SHA1,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\xf5\xd9\xcb\x66\x91\xb4\x7a\x7c\x60\x35\xe2\x1c\x38\x26\x52\x13"
 	"\x8e\xd5\xe5\xdf" },
       /* From RFC3874 */
       {	GCRY_MD_SHA224, "abc",
 	"\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
 	"\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7" },
       {	GCRY_MD_SHA224,
 	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 	"\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01\x50"
 	"\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25" },
       {	GCRY_MD_SHA224, "!",
 	"\x20\x79\x46\x55\x98\x0c\x91\xd8\xbb\xb4\xc1\xea\x97\x61\x8a\x4b"
 	"\xf0\x3f\x42\x58\x19\x48\xb2\xee\x4e\xe7\xad\x67" },
       {	GCRY_MD_SHA224, "?",
 	"\xfa\xb9\xf0\xdf\x12\xfe\xa1\x1a\x34\x78\x96\x31\xe6\x53\x48\xbf"
 	"\x3b\xca\x70\x78\xf2\x44\xdf\x62\xab\x27\xb8\xda" },
       { GCRY_MD_SHA224,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\x80\xf0\x60\x79\xb0\xe9\x65\xab\x8a\x76\xbf\x6e\x88\x64\x75\xe7"
 	"\xfd\xf0\xc2\x4c\xf6\xf2\xa6\x01\xed\x50\x71\x08" },
       {	GCRY_MD_SHA256, "abc",
 	"\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
 	"\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad" },
       {	GCRY_MD_SHA256,
 	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 	"\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
 	"\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1" },
       {	GCRY_MD_SHA256, "!",
 	"\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67"
 	"\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0" },
       {	GCRY_MD_SHA256, "?",
 	"\x67\x87\x0d\xfc\x9c\x64\xe7\xaa\x27\x0a\x3f\x7e\x80\x51\xae\x65"
 	"\xd2\x07\xf9\x3f\xc3\xdf\x04\xd7\x57\x2e\x63\x65\xaf\x69\xcd\x0d" },
       { GCRY_MD_SHA256,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\xb0\x18\x70\x67\xb8\xac\x68\x50\xec\x95\x43\x77\xb5\x44\x5b\x0f"
 	"\x2e\xbd\x40\xc9\xdc\x2a\x2c\x33\x8b\x53\xeb\x3e\x9e\x01\xd7\x02" },
       {	GCRY_MD_SHA384, "abc",
 	"\xcb\x00\x75\x3f\x45\xa3\x5e\x8b\xb5\xa0\x3d\x69\x9a\xc6\x50\x07"
 	"\x27\x2c\x32\xab\x0e\xde\xd1\x63\x1a\x8b\x60\x5a\x43\xff\x5b\xed"
 	"\x80\x86\x07\x2b\xa1\xe7\xcc\x23\x58\xba\xec\xa1\x34\xc8\x25\xa7" },
       { GCRY_MD_SHA384,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\xe4\x6d\xb4\x28\x33\x77\x99\x49\x94\x0f\xcf\x87\xc2\x2f\x30\xd6"
 	"\x06\x24\x82\x9d\x80\x64\x8a\x07\xa1\x20\x8f\x5f\xf3\x85\xb3\xaa"
 	"\x39\xb8\x61\x00\xfc\x7f\x18\xc6\x82\x23\x4b\x45\xfa\xf1\xbc\x69" },
       { GCRY_MD_SHA384, "!",
         "\x9d\x0e\x18\x09\x71\x64\x74\xcb\x08\x6e\x83\x4e\x31\x0a\x4a\x1c"
         "\xed\x14\x9e\x9c\x00\xf2\x48\x52\x79\x72\xce\xc5\x70\x4c\x2a\x5b"
         "\x07\xb8\xb3\xdc\x38\xec\xc4\xeb\xae\x97\xdd\xd8\x7f\x3d\x89\x85" },
       { GCRY_MD_SHA384, "?",
         "\xfa\x77\xbb\x86\x3a\xd5\xae\x88\xa9\x9c\x5e\xda\xb5\xc7\xcb\x40"
 	"\xcd\xf4\x30\xef\xa8\x1b\x23\x7b\xa9\xde\xfd\x81\x12\xf6\x7e\xed"
 	"\xa7\xd2\x27\x91\xd1\xbc\x76\x44\x57\x59\x71\x11\xe6\x8a\x2c\xde" },
       {	GCRY_MD_SHA512, "abc",
 	"\xDD\xAF\x35\xA1\x93\x61\x7A\xBA\xCC\x41\x73\x49\xAE\x20\x41\x31"
 	"\x12\xE6\xFA\x4E\x89\xA9\x7E\xA2\x0A\x9E\xEE\xE6\x4B\x55\xD3\x9A"
 	"\x21\x92\x99\x2A\x27\x4F\xC1\xA8\x36\xBA\x3C\x23\xA3\xFE\xEB\xBD"
 	"\x45\x4D\x44\x23\x64\x3C\xE8\x0E\x2A\x9A\xC9\x4F\xA5\x4C\xA4\x9F" },
       { GCRY_MD_SHA512,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\x72\x8c\xde\xd8\xe4\xd7\xb6\xa5\x0f\xde\x6b\x4d\x33\xaf\x15\x19"
 	"\xdd\xec\x62\x0f\xf7\x1a\x1e\x10\x32\x05\x02\xa6\xb0\x1f\x70\x37"
 	"\xbc\xd7\x15\xed\x71\x6c\x78\x20\xc8\x54\x87\xd0\x66\x6a\x17\x83"
 	"\x05\x61\x92\xbe\xcc\x8f\x3b\xbf\x11\x72\x22\x69\x23\x5b\x48\x5c" },
       { GCRY_MD_SHA512, "!",
         "\xe7\x18\x48\x3d\x0c\xe7\x69\x64\x4e\x2e\x42\xc7\xbc\x15\xb4\x63"
         "\x8e\x1f\x98\xb1\x3b\x20\x44\x28\x56\x32\xa8\x03\xaf\xa9\x73\xeb"
         "\xde\x0f\xf2\x44\x87\x7e\xa6\x0a\x4c\xb0\x43\x2c\xe5\x77\xc3\x1b"
         "\xeb\x00\x9c\x5c\x2c\x49\xaa\x2e\x4e\xad\xb2\x17\xad\x8c\xc0\x9b" },
       { GCRY_MD_SHA512, "?",
         "\x91\xe9\x42\x4e\xa9\xdc\x44\x01\x40\x64\xa4\x5a\x69\xcc\xac\xa3"
         "\x74\xee\x78\xeb\x79\x1f\x94\x38\x5b\x73\xef\xf8\xfd\x5d\x74\xd8"
         "\x51\x36\xfe\x63\x52\xde\x07\x70\x95\xd6\x78\x2b\x7b\x46\x8a\x2c"
         "\x30\x0f\x48\x0c\x74\x43\x06\xdb\xa3\x8d\x64\x3d\xe9\xa1\xa7\x72" },
       { GCRY_MD_SHA512_256, "abc",
 	"\x53\x04\x8E\x26\x81\x94\x1E\xF9\x9B\x2E\x29\xB7\x6B\x4C\x7D\xAB"
 	"\xE4\xC2\xD0\xC6\x34\xFC\x6D\x46\xE0\xE2\xF1\x31\x07\xE7\xAF\x23" },
       { GCRY_MD_SHA512_256, "!",
 	"\x9a\x59\xa0\x52\x93\x01\x87\xa9\x70\x38\xca\xe6\x92\xf3\x07\x08"
 	"\xaa\x64\x91\x92\x3e\xf5\x19\x43\x94\xdc\x68\xd5\x6c\x74\xfb\x21" },
       { GCRY_MD_SHA512_224, "abc",
 	"\x46\x34\x27\x0F\x70\x7B\x6A\x54\xDA\xAE\x75\x30\x46\x08\x42\xE2"
 	"\x0E\x37\xED\x26\x5C\xEE\xE9\xA4\x3E\x89\x24\xAA" },
       { GCRY_MD_SHA512_224, "!",
 	"\x37\xab\x33\x1d\x76\xf0\xd3\x6d\xe4\x22\xbd\x0e\xde\xb2\x2a\x28"
 	"\xac\xcd\x48\x7b\x7a\x84\x53\xae\x96\x5d\xd2\x87" },
       { GCRY_MD_SHA3_224, "abc",
 	"\xe6\x42\x82\x4c\x3f\x8c\xf2\x4a\xd0\x92\x34\xee\x7d\x3c\x76\x6f"
 	"\xc9\xa3\xa5\x16\x8d\x0c\x94\xad\x73\xb4\x6f\xdf" },
       { GCRY_MD_SHA3_256, "abc",
 	"\x3a\x98\x5d\xa7\x4f\xe2\x25\xb2\x04\x5c\x17\x2d\x6b\xd3\x90\xbd"
 	"\x85\x5f\x08\x6e\x3e\x9d\x52\x5b\x46\xbf\xe2\x45\x11\x43\x15\x32" },
       { GCRY_MD_SHA3_384, "abc",
 	"\xec\x01\x49\x82\x88\x51\x6f\xc9\x26\x45\x9f\x58\xe2\xc6\xad\x8d"
 	"\xf9\xb4\x73\xcb\x0f\xc0\x8c\x25\x96\xda\x7c\xf0\xe4\x9b\xe4\xb2"
 	"\x98\xd8\x8c\xea\x92\x7a\xc7\xf5\x39\xf1\xed\xf2\x28\x37\x6d\x25" },
       { GCRY_MD_SHA3_512, "abc",
 	"\xb7\x51\x85\x0b\x1a\x57\x16\x8a\x56\x93\xcd\x92\x4b\x6b\x09\x6e"
 	"\x08\xf6\x21\x82\x74\x44\xf7\x0d\x88\x4f\x5d\x02\x40\xd2\x71\x2e"
 	"\x10\xe1\x16\xe9\x19\x2a\xf3\xc9\x1a\x7e\xc5\x76\x47\xe3\x93\x40"
 	"\x57\x34\x0b\x4c\xf4\x08\xd5\xa5\x65\x92\xf8\x27\x4e\xec\x53\xf0" },
       { GCRY_MD_SHA3_224, "",
 	"\x6b\x4e\x03\x42\x36\x67\xdb\xb7\x3b\x6e\x15\x45\x4f\x0e\xb1\xab"
 	"\xd4\x59\x7f\x9a\x1b\x07\x8e\x3f\x5b\x5a\x6b\xc7" },
       { GCRY_MD_SHA3_256, "",
 	"\xa7\xff\xc6\xf8\xbf\x1e\xd7\x66\x51\xc1\x47\x56\xa0\x61\xd6\x62"
 	"\xf5\x80\xff\x4d\xe4\x3b\x49\xfa\x82\xd8\x0a\x4b\x80\xf8\x43\x4a" },
       { GCRY_MD_SHA3_384, "",
 	"\x0c\x63\xa7\x5b\x84\x5e\x4f\x7d\x01\x10\x7d\x85\x2e\x4c\x24\x85"
 	"\xc5\x1a\x50\xaa\xaa\x94\xfc\x61\x99\x5e\x71\xbb\xee\x98\x3a\x2a"
 	"\xc3\x71\x38\x31\x26\x4a\xdb\x47\xfb\x6b\xd1\xe0\x58\xd5\xf0\x04" },
       { GCRY_MD_SHA3_512, "",
 	"\xa6\x9f\x73\xcc\xa2\x3a\x9a\xc5\xc8\xb5\x67\xdc\x18\x5a\x75\x6e"
 	"\x97\xc9\x82\x16\x4f\xe2\x58\x59\xe0\xd1\xdc\xc1\x47\x5c\x80\xa6"
 	"\x15\xb2\x12\x3a\xf1\xf5\xf9\x4c\x11\xe3\xe9\x40\x2c\x3a\xc5\x58"
 	"\xf5\x00\x19\x9d\x95\xb6\xd3\xe3\x01\x75\x85\x86\x28\x1d\xcd\x26" },
       { GCRY_MD_SHA3_224, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlm"
 	"nomnopnopq",
 	"\x8a\x24\x10\x8b\x15\x4a\xda\x21\xc9\xfd\x55\x74\x49\x44\x79\xba"
 	"\x5c\x7e\x7a\xb7\x6e\xf2\x64\xea\xd0\xfc\xce\x33" },
       { GCRY_MD_SHA3_256, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlm"
 	"nomnopnopq",
 	"\x41\xc0\xdb\xa2\xa9\xd6\x24\x08\x49\x10\x03\x76\xa8\x23\x5e\x2c"
 	"\x82\xe1\xb9\x99\x8a\x99\x9e\x21\xdb\x32\xdd\x97\x49\x6d\x33\x76" },
       { GCRY_MD_SHA3_384, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlm"
 	"nomnopnopq",
 	"\x99\x1c\x66\x57\x55\xeb\x3a\x4b\x6b\xbd\xfb\x75\xc7\x8a\x49\x2e"
 	"\x8c\x56\xa2\x2c\x5c\x4d\x7e\x42\x9b\xfd\xbc\x32\xb9\xd4\xad\x5a"
 	"\xa0\x4a\x1f\x07\x6e\x62\xfe\xa1\x9e\xef\x51\xac\xd0\x65\x7c\x22" },
       { GCRY_MD_SHA3_512, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlm"
 	"nomnopnopq",
 	"\x04\xa3\x71\xe8\x4e\xcf\xb5\xb8\xb7\x7c\xb4\x86\x10\xfc\xa8\x18"
 	"\x2d\xd4\x57\xce\x6f\x32\x6a\x0f\xd3\xd7\xec\x2f\x1e\x91\x63\x6d"
 	"\xee\x69\x1f\xbe\x0c\x98\x53\x02\xba\x1b\x0d\x8d\xc7\x8c\x08\x63"
 	"\x46\xb5\x33\xb4\x9c\x03\x0d\x99\xa2\x7d\xaf\x11\x39\xd6\xe7\x5e" },
       { GCRY_MD_SHA3_224, "abcdefghbcdefghicdefghijdefghijkefghijklfghijk"
 	"lmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
 	"\x54\x3e\x68\x68\xe1\x66\x6c\x1a\x64\x36\x30\xdf\x77\x36\x7a\xe5"
 	"\xa6\x2a\x85\x07\x0a\x51\xc1\x4c\xbf\x66\x5c\xbc" },
       { GCRY_MD_SHA3_256, "abcdefghbcdefghicdefghijdefghijkefghijklfghijk"
 	"lmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
 	"\x91\x6f\x60\x61\xfe\x87\x97\x41\xca\x64\x69\xb4\x39\x71\xdf\xdb"
 	"\x28\xb1\xa3\x2d\xc3\x6c\xb3\x25\x4e\x81\x2b\xe2\x7a\xad\x1d\x18" },
       { GCRY_MD_SHA3_384, "abcdefghbcdefghicdefghijdefghijkefghijklfghijk"
 	"lmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
 	"\x79\x40\x7d\x3b\x59\x16\xb5\x9c\x3e\x30\xb0\x98\x22\x97\x47\x91"
 	"\xc3\x13\xfb\x9e\xcc\x84\x9e\x40\x6f\x23\x59\x2d\x04\xf6\x25\xdc"
 	"\x8c\x70\x9b\x98\xb4\x3b\x38\x52\xb3\x37\x21\x61\x79\xaa\x7f\xc7" },
       { GCRY_MD_SHA3_512, "abcdefghbcdefghicdefghijdefghijkefghijklfghijk"
 	"lmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
 	"\xaf\xeb\xb2\xef\x54\x2e\x65\x79\xc5\x0c\xad\x06\xd2\xe5\x78\xf9"
 	"\xf8\xdd\x68\x81\xd7\xdc\x82\x4d\x26\x36\x0f\xee\xbf\x18\xa4\xfa"
 	"\x73\xe3\x26\x11\x22\x94\x8e\xfc\xfd\x49\x2e\x74\xe8\x2e\x21\x89"
 	"\xed\x0f\xb4\x40\xd1\x87\xf3\x82\x27\x0c\xb4\x55\xf2\x1d\xd1\x85" },
       { GCRY_MD_SHA3_224, "!",
 	"\xd6\x93\x35\xb9\x33\x25\x19\x2e\x51\x6a\x91\x2e\x6d\x19\xa1\x5c"
 	"\xb5\x1c\x6e\xd5\xc1\x52\x43\xe7\xa7\xfd\x65\x3c" },
       { GCRY_MD_SHA3_256, "!",
 	"\x5c\x88\x75\xae\x47\x4a\x36\x34\xba\x4f\xd5\x5e\xc8\x5b\xff\xd6"
 	"\x61\xf3\x2a\xca\x75\xc6\xd6\x99\xd0\xcd\xcb\x6c\x11\x58\x91\xc1" },
       { GCRY_MD_SHA3_384, "!",
 	"\xee\xe9\xe2\x4d\x78\xc1\x85\x53\x37\x98\x34\x51\xdf\x97\xc8\xad"
 	"\x9e\xed\xf2\x56\xc6\x33\x4f\x8e\x94\x8d\x25\x2d\x5e\x0e\x76\x84"
 	"\x7a\xa0\x77\x4d\xdb\x90\xa8\x42\x19\x0d\x2c\x55\x8b\x4b\x83\x40" },
       { GCRY_MD_SHA3_512, "!",
 	"\x3c\x3a\x87\x6d\xa1\x40\x34\xab\x60\x62\x7c\x07\x7b\xb9\x8f\x7e"
 	"\x12\x0a\x2a\x53\x70\x21\x2d\xff\xb3\x38\x5a\x18\xd4\xf3\x88\x59"
 	"\xed\x31\x1d\x0a\x9d\x51\x41\xce\x9c\xc5\xc6\x6e\xe6\x89\xb2\x66"
 	"\xa8\xaa\x18\xac\xe8\x28\x2a\x0e\x0d\xb5\x96\xc9\x0b\x0a\x7b\x87" },
       { GCRY_MD_SHA3_224, "?",
 	"\x1b\xd1\xc6\x12\x02\x35\x52\x8b\x44\x7e\x16\x39\x20\x05\xec\x67"
 	"\x2d\x57\x20\xe0\x90\xc9\x78\x08\x86\x4f\x1b\xd0" },
       { GCRY_MD_SHA3_256, "?",
 	"\xfe\xb7\xf4\x76\x78\x97\x48\x2f\xe2\x29\x1b\x66\x85\xc1\x7b\x45"
 	"\xc5\x08\xed\x82\x50\xcc\x5d\x99\x96\xd2\xc3\x82\x1a\xa8\xd4\xa7" },
       { GCRY_MD_SHA3_384, "?",
 	"\x45\x1f\x0b\x93\x4b\xca\x3e\x65\x93\xd4\xaa\x8c\x18\xc1\x04\x84"
 	"\x12\xd5\x1e\x35\xe1\x05\xd9\x77\x3f\xc1\x08\x8b\x77\x36\xad\x4a"
 	"\x33\x70\xaf\x49\x8b\xea\x4c\x5c\x52\xe7\x5b\xed\x31\x74\x57\x12" },
       { GCRY_MD_SHA3_512, "?",
 	"\xa2\xee\xb5\x6f\x2a\x87\xa5\xb3\x9b\xd9\x1c\xf0\xaa\xdf\xb1\xd5"
 	"\xad\x0a\x1a\xaa\xd3\x63\x81\xcf\xb8\x7c\x36\xa7\x80\x3b\x03\xd6"
 	"\x31\x5c\x5d\x33\x8e\x52\xb1\x42\x4d\x27\x1c\xa2\xa5\xf2\xc5\x97"
 	"\x10\x12\xe5\xee\x86\xa3\xcc\xaf\x91\x7a\x94\x28\x65\xea\x66\xe3" },
       {	GCRY_MD_RMD160, "",
 	"\x9c\x11\x85\xa5\xc5\xe9\xfc\x54\x61\x28"
 	"\x08\x97\x7e\xe8\xf5\x48\xb2\x25\x8d\x31" },
       {	GCRY_MD_RMD160, "a",
 	"\x0b\xdc\x9d\x2d\x25\x6b\x3e\xe9\xda\xae"
 	"\x34\x7b\xe6\xf4\xdc\x83\x5a\x46\x7f\xfe" },
       {	GCRY_MD_RMD160, "abc",
 	"\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04"
 	"\x4a\x8e\x98\xc6\xb0\x87\xf1\x5a\x0b\xfc" },
       {	GCRY_MD_RMD160, "message digest",
 	"\x5d\x06\x89\xef\x49\xd2\xfa\xe5\x72\xb8"
 	"\x81\xb1\x23\xa8\x5f\xfa\x21\x59\x5f\x36" },
       { GCRY_MD_RMD160,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\x06\x6d\x3c\x4e\xc9\xba\x89\x75\x16\x90\x96\x4e\xfd\x43\x07\xde"
 	"\x04\xca\x69\x6b" },
       { GCRY_MD_RMD160, "!",
         "\x52\x78\x32\x43\xc1\x69\x7b\xdb\xe1\x6d\x37\xf9\x7f\x68\xf0\x83"
         "\x25\xdc\x15\x28" },
       { GCRY_MD_RMD160, "?",
 	"\x68\x14\x86\x70\x3d\x51\x4e\x36\x68\x50\xf8\xb3\x00\x75\xda\x49"
 	"\x0a\xaa\x2c\xf6" },
       {	GCRY_MD_CRC32, "", "\x00\x00\x00\x00" },
       {	GCRY_MD_CRC32, "foo", "\x8c\x73\x65\x21" },
       { GCRY_MD_CRC32,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\x4A\x53\x7D\x67" },
       { GCRY_MD_CRC32, "123456789", "\xcb\xf4\x39\x26" },
       { GCRY_MD_CRC32, "!", "\xdc\x25\xbf\xbc" },
       { GCRY_MD_CRC32, "?", "\x61\x82\x29\x1B" },
       { GCRY_MD_CRC32_RFC1510, "", "\x00\x00\x00\x00" },
       {	GCRY_MD_CRC32_RFC1510, "foo", "\x73\x32\xbc\x33" },
       {	GCRY_MD_CRC32_RFC1510, "test0123456789", "\xb8\x3e\x88\xd6" },
       {	GCRY_MD_CRC32_RFC1510, "MASSACHVSETTS INSTITVTE OF TECHNOLOGY",
 	"\xe3\x41\x80\xf7" },
       {	GCRY_MD_CRC32_RFC1510, "\x80\x00", "\x3b\x83\x98\x4b", 2 },
       {	GCRY_MD_CRC32_RFC1510, "\x00\x08", "\x0e\xdb\x88\x32", 2 },
       {	GCRY_MD_CRC32_RFC1510, "\x00\x80", "\xed\xb8\x83\x20", 2 },
       {	GCRY_MD_CRC32_RFC1510, "\x80", "\xed\xb8\x83\x20" },
       {	GCRY_MD_CRC32_RFC1510, "\x80\x00\x00\x00", "\xed\x59\xb6\x3b", 4 },
       {	GCRY_MD_CRC32_RFC1510, "\x00\x00\x00\x01", "\x77\x07\x30\x96", 4 },
       { GCRY_MD_CRC32_RFC1510, "123456789", "\x2d\xfd\x2d\x88" },
       { GCRY_MD_CRC32_RFC1510, "!", "\xce\x5c\x74\x22" },
       {	GCRY_MD_CRC32_RFC1510, "?", "\x73\xfb\xe2\x85" },
       {	GCRY_MD_CRC24_RFC2440, "", "\xb7\x04\xce" },
       {	GCRY_MD_CRC24_RFC2440, "foo", "\x4f\xc2\x55" },
       { GCRY_MD_CRC24_RFC2440, "123456789", "\x21\xcf\x02" },
       { GCRY_MD_CRC24_RFC2440, "!", "\xa5\xcb\x6b" },
       { GCRY_MD_CRC24_RFC2440, "?", "\x7f\x67\x03" },
 
       {	GCRY_MD_TIGER, "",
 	"\x24\xF0\x13\x0C\x63\xAC\x93\x32\x16\x16\x6E\x76"
 	"\xB1\xBB\x92\x5F\xF3\x73\xDE\x2D\x49\x58\x4E\x7A" },
       {	GCRY_MD_TIGER, "abc",
 	"\xF2\x58\xC1\xE8\x84\x14\xAB\x2A\x52\x7A\xB5\x41"
 	"\xFF\xC5\xB8\xBF\x93\x5F\x7B\x95\x1C\x13\x29\x51" },
       {	GCRY_MD_TIGER, "Tiger",
 	"\x9F\x00\xF5\x99\x07\x23\x00\xDD\x27\x6A\xBB\x38"
 	"\xC8\xEB\x6D\xEC\x37\x79\x0C\x11\x6F\x9D\x2B\xDF" },
       {	GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg"
 	"hijklmnopqrstuvwxyz0123456789+-",
 	"\x87\xFB\x2A\x90\x83\x85\x1C\xF7\x47\x0D\x2C\xF8"
 	"\x10\xE6\xDF\x9E\xB5\x86\x44\x50\x34\xA5\xA3\x86" },
       {	GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdef"
 	"ghijklmnopqrstuvwxyz+0123456789",
 	"\x46\x7D\xB8\x08\x63\xEB\xCE\x48\x8D\xF1\xCD\x12"
 	"\x61\x65\x5D\xE9\x57\x89\x65\x65\x97\x5F\x91\x97" },
       {	GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
 	"by Ross Anderson and Eli Biham",
 	"\x0C\x41\x0A\x04\x29\x68\x86\x8A\x16\x71\xDA\x5A"
 	"\x3F\xD2\x9A\x72\x5E\xC1\xE4\x57\xD3\xCD\xB3\x03" },
       {	GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
 	"by Ross Anderson and Eli Biham, proceedings of Fa"
 	"st Software Encryption 3, Cambridge.",
 	"\xEB\xF5\x91\xD5\xAF\xA6\x55\xCE\x7F\x22\x89\x4F"
 	"\xF8\x7F\x54\xAC\x89\xC8\x11\xB6\xB0\xDA\x31\x93" },
       {	GCRY_MD_TIGER, "Tiger - A Fast New Hash Function, "
 	"by Ross Anderson and Eli Biham, proceedings of Fa"
 	"st Software Encryption 3, Cambridge, 1996.",
 	"\x3D\x9A\xEB\x03\xD1\xBD\x1A\x63\x57\xB2\x77\x4D"
 	"\xFD\x6D\x5B\x24\xDD\x68\x15\x1D\x50\x39\x74\xFC" },
       {	GCRY_MD_TIGER, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefgh"
 	"ijklmnopqrstuvwxyz0123456789+-ABCDEFGHIJKLMNOPQRS"
 	"TUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-",
 	"\x00\xB8\x3E\xB4\xE5\x34\x40\xC5\x76\xAC\x6A\xAE"
 	"\xE0\xA7\x48\x58\x25\xFD\x15\xE7\x0A\x59\xFF\xE4" },
 
       {	GCRY_MD_TIGER1, "",
         "\x32\x93\xAC\x63\x0C\x13\xF0\x24\x5F\x92\xBB\xB1"
         "\x76\x6E\x16\x16\x7A\x4E\x58\x49\x2D\xDE\x73\xF3" },
       {	GCRY_MD_TIGER1, "a",
 	"\x77\xBE\xFB\xEF\x2E\x7E\xF8\xAB\x2E\xC8\xF9\x3B"
         "\xF5\x87\xA7\xFC\x61\x3E\x24\x7F\x5F\x24\x78\x09" },
       {	GCRY_MD_TIGER1, "abc",
         "\x2A\xAB\x14\x84\xE8\xC1\x58\xF2\xBF\xB8\xC5\xFF"
         "\x41\xB5\x7A\x52\x51\x29\x13\x1C\x95\x7B\x5F\x93" },
       {	GCRY_MD_TIGER1, "message digest",
 	"\xD9\x81\xF8\xCB\x78\x20\x1A\x95\x0D\xCF\x30\x48"
         "\x75\x1E\x44\x1C\x51\x7F\xCA\x1A\xA5\x5A\x29\xF6" },
       {	GCRY_MD_TIGER1, "abcdefghijklmnopqrstuvwxyz",
 	"\x17\x14\xA4\x72\xEE\xE5\x7D\x30\x04\x04\x12\xBF"
         "\xCC\x55\x03\x2A\x0B\x11\x60\x2F\xF3\x7B\xEE\xE9" },
       {	GCRY_MD_TIGER1,
         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 	"\x0F\x7B\xF9\xA1\x9B\x9C\x58\xF2\xB7\x61\x0D\xF7"
         "\xE8\x4F\x0A\xC3\xA7\x1C\x63\x1E\x7B\x53\xF7\x8E" },
       {	GCRY_MD_TIGER1,
         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
         "abcdefghijklmnopqrstuvwxyz" "0123456789",
         "\x8D\xCE\xA6\x80\xA1\x75\x83\xEE\x50\x2B\xA3\x8A"
         "\x3C\x36\x86\x51\x89\x0F\xFB\xCC\xDC\x49\xA8\xCC" },
       {	GCRY_MD_TIGER1,
         "1234567890" "1234567890" "1234567890" "1234567890"
         "1234567890" "1234567890" "1234567890" "1234567890",
         "\x1C\x14\x79\x55\x29\xFD\x9F\x20\x7A\x95\x8F\x84"
         "\xC5\x2F\x11\xE8\x87\xFA\x0C\xAB\xDF\xD9\x1B\xFD" },
       {	GCRY_MD_TIGER1, "!",
 	"\x6D\xB0\xE2\x72\x9C\xBE\xAD\x93\xD7\x15\xC6\xA7"
         "\xD3\x63\x02\xE9\xB3\xCE\xE0\xD2\xBC\x31\x4B\x41" },
       { GCRY_MD_TIGER1,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\x60\xee\xdf\x95\x39\xc8\x44\x94\x64\xdc\xdf\x3d\x2e\x1c\xe5\x79"
 	"\x6a\x95\xbd\x30\x68\x8c\x7e\xb8" },
       {	GCRY_MD_TIGER1, "?",
 	"\x4b\xe2\x3f\x23\xf5\x34\xbe\xbf\x97\x42\x95\x80"
 	"\x54\xe4\x6c\x12\x64\x85\x44\x0a\xa9\x49\x9b\x65" },
 
       {	GCRY_MD_TIGER2, "",
         "\x44\x41\xBE\x75\xF6\x01\x87\x73\xC2\x06\xC2\x27"
         "\x45\x37\x4B\x92\x4A\xA8\x31\x3F\xEF\x91\x9F\x41" },
       {	GCRY_MD_TIGER2, "a",
         "\x67\xE6\xAE\x8E\x9E\x96\x89\x99\xF7\x0A\x23\xE7"
         "\x2A\xEA\xA9\x25\x1C\xBC\x7C\x78\xA7\x91\x66\x36" },
       {	GCRY_MD_TIGER2, "abc",
         "\xF6\x8D\x7B\xC5\xAF\x4B\x43\xA0\x6E\x04\x8D\x78"
         "\x29\x56\x0D\x4A\x94\x15\x65\x8B\xB0\xB1\xF3\xBF" },
       {	GCRY_MD_TIGER2, "message digest",
         "\xE2\x94\x19\xA1\xB5\xFA\x25\x9D\xE8\x00\x5E\x7D"
         "\xE7\x50\x78\xEA\x81\xA5\x42\xEF\x25\x52\x46\x2D" },
       {	GCRY_MD_TIGER2, "abcdefghijklmnopqrstuvwxyz",
         "\xF5\xB6\xB6\xA7\x8C\x40\x5C\x85\x47\xE9\x1C\xD8"
         "\x62\x4C\xB8\xBE\x83\xFC\x80\x4A\x47\x44\x88\xFD" },
       {	GCRY_MD_TIGER2,
         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
         "\xA6\x73\x7F\x39\x97\xE8\xFB\xB6\x3D\x20\xD2\xDF"
         "\x88\xF8\x63\x76\xB5\xFE\x2D\x5C\xE3\x66\x46\xA9" },
       {	GCRY_MD_TIGER2,
         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
         "abcdefghijklmnopqrstuvwxyz" "0123456789",
         "\xEA\x9A\xB6\x22\x8C\xEE\x7B\x51\xB7\x75\x44\xFC"
         "\xA6\x06\x6C\x8C\xBB\x5B\xBA\xE6\x31\x95\x05\xCD" },
       {	GCRY_MD_TIGER2,
         "1234567890" "1234567890" "1234567890" "1234567890"
         "1234567890" "1234567890" "1234567890" "1234567890",
         "\xD8\x52\x78\x11\x53\x29\xEB\xAA\x0E\xEC\x85\xEC"
         "\xDC\x53\x96\xFD\xA8\xAA\x3A\x58\x20\x94\x2F\xFF" },
       {	GCRY_MD_TIGER2, "!",
         "\xE0\x68\x28\x1F\x06\x0F\x55\x16\x28\xCC\x57\x15"
         "\xB9\xD0\x22\x67\x96\x91\x4D\x45\xF7\x71\x7C\xF4" },
 
       { GCRY_MD_WHIRLPOOL, "",
 	"\x19\xFA\x61\xD7\x55\x22\xA4\x66\x9B\x44\xE3\x9C\x1D\x2E\x17\x26"
 	"\xC5\x30\x23\x21\x30\xD4\x07\xF8\x9A\xFE\xE0\x96\x49\x97\xF7\xA7"
 	"\x3E\x83\xBE\x69\x8B\x28\x8F\xEB\xCF\x88\xE3\xE0\x3C\x4F\x07\x57"
 	"\xEA\x89\x64\xE5\x9B\x63\xD9\x37\x08\xB1\x38\xCC\x42\xA6\x6E\xB3" },
       { GCRY_MD_WHIRLPOOL, "a",
 	"\x8A\xCA\x26\x02\x79\x2A\xEC\x6F\x11\xA6\x72\x06\x53\x1F\xB7\xD7"
 	"\xF0\xDF\xF5\x94\x13\x14\x5E\x69\x73\xC4\x50\x01\xD0\x08\x7B\x42"
 	"\xD1\x1B\xC6\x45\x41\x3A\xEF\xF6\x3A\x42\x39\x1A\x39\x14\x5A\x59"
 	"\x1A\x92\x20\x0D\x56\x01\x95\xE5\x3B\x47\x85\x84\xFD\xAE\x23\x1A" },
       { GCRY_MD_WHIRLPOOL, "?",
 	"\x88\xf0\x78\x6d\x0d\x47\xe5\x32\x1f\x88\xb1\x48\x05\x53\x58\x7d"
 	"\x19\x4b\x32\x9b\xf1\xfb\x17\xc5\x98\x3a\x87\xa2\x48\x61\x3d\x2b"
 	"\xb2\xbc\x9f\x0d\xd2\x14\x37\x30\x55\x30\x91\xa7\xb8\x0c\x0f\x80"
 	"\x7c\x7b\x94\xf6\x55\xf6\x0b\x12\x85\x0c\x8e\x6d\x17\x5b\x1e\x71" },
       { GCRY_MD_WHIRLPOOL,
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
 	"\xDC\x37\xE0\x08\xCF\x9E\xE6\x9B\xF1\x1F\x00\xED\x9A\xBA\x26\x90"
 	"\x1D\xD7\xC2\x8C\xDE\xC0\x66\xCC\x6A\xF4\x2E\x40\xF8\x2F\x3A\x1E"
 	"\x08\xEB\xA2\x66\x29\x12\x9D\x8F\xB7\xCB\x57\x21\x1B\x92\x81\xA6"
 	"\x55\x17\xCC\x87\x9D\x7B\x96\x21\x42\xC6\x5F\x5A\x7A\xF0\x14\x67" },
       { GCRY_MD_WHIRLPOOL,
         "!",
         "\x0C\x99\x00\x5B\xEB\x57\xEF\xF5\x0A\x7C\xF0\x05\x56\x0D\xDF\x5D"
         "\x29\x05\x7F\xD8\x6B\x20\xBF\xD6\x2D\xEC\xA0\xF1\xCC\xEA\x4A\xF5"
         "\x1F\xC1\x54\x90\xED\xDC\x47\xAF\x32\xBB\x2B\x66\xC3\x4F\xF9\xAD"
         "\x8C\x60\x08\xAD\x67\x7F\x77\x12\x69\x53\xB2\x26\xE4\xED\x8B\x01" },
       { GCRY_MD_WHIRLPOOL,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\xcd\x4a\xa4\xaf\xf6\x7f\xec\xce\xbb\x6c\xdf\x91\x96\xe1\xf3\xf6"
 	"\x78\xe2\x8e\x3a\x76\xcf\x06\xc7\xa1\x20\x7b\x81\x32\x60\xf7\x8e"
 	"\x68\x19\x62\x33\x4f\xe5\x0a\x24\xfb\x9e\x74\x03\x74\xe4\x61\x29"
 	"\x6f\xb3\x13\xe6\x7e\xc2\x88\x99\x9e\xfb\xe7\x9d\x11\x30\x89\xd2" },
       { GCRY_MD_GOSTR3411_94,
 	"This is message, length=32 bytes",
 	"\xB1\xC4\x66\xD3\x75\x19\xB8\x2E\x83\x19\x81\x9F\xF3\x25\x95\xE0"
 	"\x47\xA2\x8C\xB6\xF8\x3E\xFF\x1C\x69\x16\xA8\x15\xA6\x37\xFF\xFA" },
       { GCRY_MD_GOSTR3411_94,
 	"Suppose the original message has length = 50 bytes",
 	"\x47\x1A\xBA\x57\xA6\x0A\x77\x0D\x3A\x76\x13\x06\x35\xC1\xFB\xEA"
 	"\x4E\xF1\x4D\xE5\x1F\x78\xB4\xAE\x57\xDD\x89\x3B\x62\xF5\x52\x08" },
       { GCRY_MD_GOSTR3411_94,
 	"",
 	"\xCE\x85\xB9\x9C\xC4\x67\x52\xFF\xFE\xE3\x5C\xAB\x9A\x7B\x02\x78"
 	"\xAB\xB4\xC2\xD2\x05\x5C\xFF\x68\x5A\xF4\x91\x2C\x49\x49\x0F\x8D" },
       { GCRY_MD_GOSTR3411_94,
 	"!",
 	"\x5C\x00\xCC\xC2\x73\x4C\xDD\x33\x32\xD3\xD4\x74\x95\x76\xE3\xC1"
 	"\xA7\xDB\xAF\x0E\x7E\xA7\x4E\x9F\xA6\x02\x41\x3C\x90\xA1\x29\xFA" },
       { GCRY_MD_GOSTR3411_94,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\x00\x0c\x85\xc8\x54\xd2\x9a\x6e\x47\x2e\xff\xa4\xa2\xe7\xd0\x2e"
 	"\x8a\xcc\x14\x53\xb4\x87\xc8\x5c\x95\x9a\x3e\x85\x8c\x7d\x6e\x0c" },
       { GCRY_MD_STRIBOG512,
         "012345678901234567890123456789012345678901234567890123456789012",
         "\x1b\x54\xd0\x1a\x4a\xf5\xb9\xd5\xcc\x3d\x86\xd6\x8d\x28\x54\x62"
         "\xb1\x9a\xbc\x24\x75\x22\x2f\x35\xc0\x85\x12\x2b\xe4\xba\x1f\xfa"
         "\x00\xad\x30\xf8\x76\x7b\x3a\x82\x38\x4c\x65\x74\xf0\x24\xc3\x11"
         "\xe2\xa4\x81\x33\x2b\x08\xef\x7f\x41\x79\x78\x91\xc1\x64\x6f\x48" },
       { GCRY_MD_STRIBOG256,
         "012345678901234567890123456789012345678901234567890123456789012",
         "\x9d\x15\x1e\xef\xd8\x59\x0b\x89\xda\xa6\xba\x6c\xb7\x4a\xf9\x27"
         "\x5d\xd0\x51\x02\x6b\xb1\x49\xa4\x52\xfd\x84\xe5\xe5\x7b\x55\x00" },
       { GCRY_MD_STRIBOG512,
         "\xd1\xe5\x20\xe2\xe5\xf2\xf0\xe8\x2c\x20\xd1\xf2\xf0\xe8\xe1\xee"
         "\xe6\xe8\x20\xe2\xed\xf3\xf6\xe8\x2c\x20\xe2\xe5\xfe\xf2\xfa\x20"
         "\xf1\x20\xec\xee\xf0\xff\x20\xf1\xf2\xf0\xe5\xeb\xe0\xec\xe8\x20"
         "\xed\xe0\x20\xf5\xf0\xe0\xe1\xf0\xfb\xff\x20\xef\xeb\xfa\xea\xfb"
         "\x20\xc8\xe3\xee\xf0\xe5\xe2\xfb",
         "\x1e\x88\xe6\x22\x26\xbf\xca\x6f\x99\x94\xf1\xf2\xd5\x15\x69\xe0"
         "\xda\xf8\x47\x5a\x3b\x0f\xe6\x1a\x53\x00\xee\xe4\x6d\x96\x13\x76"
         "\x03\x5f\xe8\x35\x49\xad\xa2\xb8\x62\x0f\xcd\x7c\x49\x6c\xe5\xb3"
         "\x3f\x0c\xb9\xdd\xdc\x2b\x64\x60\x14\x3b\x03\xda\xba\xc9\xfb\x28" },
       { GCRY_MD_STRIBOG256,
         "\xd1\xe5\x20\xe2\xe5\xf2\xf0\xe8\x2c\x20\xd1\xf2\xf0\xe8\xe1\xee"
         "\xe6\xe8\x20\xe2\xed\xf3\xf6\xe8\x2c\x20\xe2\xe5\xfe\xf2\xfa\x20"
         "\xf1\x20\xec\xee\xf0\xff\x20\xf1\xf2\xf0\xe5\xeb\xe0\xec\xe8\x20"
         "\xed\xe0\x20\xf5\xf0\xe0\xe1\xf0\xfb\xff\x20\xef\xeb\xfa\xea\xfb"
         "\x20\xc8\xe3\xee\xf0\xe5\xe2\xfb",
         "\x9d\xd2\xfe\x4e\x90\x40\x9e\x5d\xa8\x7f\x53\x97\x6d\x74\x05\xb0"
         "\xc0\xca\xc6\x28\xfc\x66\x9a\x74\x1d\x50\x06\x3c\x55\x7e\x8f\x50" },
       /* Special tests for carry flag in addition */
       { GCRY_MD_STRIBOG512,
         "\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE"
 	"\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE"
 	"\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE"
 	"\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE"
 	"\x16\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11"
 	"\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11"
 	"\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11"
 	"\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x16",
 	"\x8b\x06\xf4\x1e\x59\x90\x7d\x96\x36\xe8\x92\xca\xf5\x94\x2f\xcd"
 	"\xfb\x71\xfa\x31\x16\x9a\x5e\x70\xf0\xed\xb8\x73\x66\x4d\xf4\x1c"
 	"\x2c\xce\x6e\x06\xdc\x67\x55\xd1\x5a\x61\xcd\xeb\x92\xbd\x60\x7c"
 	"\xc4\xaa\xca\x67\x32\xbf\x35\x68\xa2\x3a\x21\x0d\xd5\x20\xfd\x41" },
       { GCRY_MD_STRIBOG512,
         "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
 	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
 	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
 	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
 	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
 	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
 	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
 	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
 	"\x90\xa1\x61\xd1\x2a\xd3\x09\x49\x8d\x3f\xe5\xd4\x82\x02\xd8\xa4"
 	"\xe9\xc4\x06\xd6\xa2\x64\xae\xab\x25\x8a\xc5\xec\xc3\x7a\x79\x62"
 	"\xaa\xf9\x58\x7a\x5a\xbb\x09\xb6\xbb\x81\xec\x4b\x37\x52\xa3\xff"
 	"\x5a\x83\x8e\xf1\x75\xbe\x57\x72\x05\x6b\xc5\xfe\x54\xfc\xfc\x7e" },
 #include "./sha3-224.h"
 #include "./sha3-256.h"
 #include "./sha3-384.h"
 #include "./sha3-512.h"
       { GCRY_MD_SHAKE128,
 	"",
 	"\x7F\x9C\x2B\xA4\xE8\x8F\x82\x7D\x61\x60\x45\x50\x76\x05\x85\x3E"
 	"\xD7\x3B\x80\x93\xF6\xEF\xBC\x88\xEB\x1A\x6E\xAC\xFA\x66\xEF\x26"
 	"\x3C\xB1\xEE\xA9\x88\x00\x4B\x93\x10\x3C\xFB\x0A\xEE\xFD\x2A\x68"
 	"\x6E\x01\xFA\x4A\x58\xE8\xA3\x63\x9C\xA8\xA1\xE3\xF9\xAE\x57\xE2"
 	"\x35\xB8\xCC\x87\x3C\x23\xDC\x62\xB8\xD2\x60\x16\x9A\xFA\x2F\x75"
 	"\xAB\x91\x6A\x58\xD9\x74\x91\x88\x35\xD2\x5E\x6A\x43\x50\x85\xB2"
 	"\xBA\xDF\xD6\xDF\xAA\xC3\x59\xA5\xEF\xBB\x7B\xCC\x4B\x59\xD5\x38"
 	"\xDF\x9A\x04\x30\x2E\x10\xC8\xBC\x1C\xBF\x1A\x0B\x3A\x51\x20\xEA"
 	"\x17\xCD\xA7\xCF\xAD\x76\x5F\x56\x23\x47\x4D\x36\x8C\xCC\xA8\xAF"
 	"\x00\x07\xCD\x9F\x5E\x4C\x84\x9F\x16\x7A\x58\x0B\x14\xAA\xBD\xEF"
 	"\xAE\xE7\xEE\xF4\x7C\xB0\xFC\xA9\x76\x7B\xE1\xFD\xA6\x94\x19\xDF"
 	"\xB9\x27\xE9\xDF\x07\x34\x8B\x19\x66\x91\xAB\xAE\xB5\x80\xB3\x2D"
 	"\xEF\x58\x53\x8B\x8D\x23\xF8\x77\x32\xEA\x63\xB0\x2B\x4F\xA0\xF4"
 	"\x87\x33\x60\xE2\x84\x19\x28\xCD\x60\xDD\x4C\xEE\x8C\xC0\xD4\xC9"
 	"\x22\xA9\x61\x88\xD0\x32\x67\x5C\x8A\xC8\x50\x93\x3C\x7A\xFF\x15"
 	"\x33\xB9\x4C\x83\x4A\xDB\xB6\x9C\x61\x15\xBA\xD4\x69\x2D\x86\x19"
 	"\xF9\x0B\x0C\xDF\x8A\x7B\x9C\x26\x40\x29\xAC\x18\x5B\x70\xB8\x3F"
 	"\x28\x01\xF2\xF4\xB3\xF7\x0C\x59\x3E\xA3\xAE\xEB\x61\x3A\x7F\x1B"
 	"\x1D\xE3\x3F\xD7\x50\x81\xF5\x92\x30\x5F\x2E\x45\x26\xED\xC0\x96"
 	"\x31\xB1\x09\x58\xF4\x64\xD8\x89\xF3\x1B\xA0\x10\x25\x0F\xDA\x7F"
 	"\x13\x68\xEC\x29\x67\xFC\x84\xEF\x2A\xE9\xAF\xF2\x68\xE0\xB1\x70"
 	"\x0A\xFF\xC6\x82\x0B\x52\x3A\x3D\x91\x71\x35\xF2\xDF\xF2\xEE\x06"
 	"\xBF\xE7\x2B\x31\x24\x72\x1D\x4A\x26\xC0\x4E\x53\xA7\x5E\x30\xE7"
 	"\x3A\x7A\x9C\x4A\x95\xD9\x1C\x55\xD4\x95\xE9\xF5\x1D\xD0\xB5\xE9"
 	"\xD8\x3C\x6D\x5E\x8C\xE8\x03\xAA\x62\xB8\xD6\x54\xDB\x53\xD0\x9B"
 	"\x8D\xCF\xF2\x73\xCD\xFE\xB5\x73\xFA\xD8\xBC\xD4\x55\x78\xBE\xC2"
 	"\xE7\x70\xD0\x1E\xFD\xE8\x6E\x72\x1A\x3F\x7C\x6C\xCE\x27\x5D\xAB"
 	"\xE6\xE2\x14\x3F\x1A\xF1\x8D\xA7\xEF\xDD\xC4\xC7\xB7\x0B\x5E\x34"
 	"\x5D\xB9\x3C\xC9\x36\xBE\xA3\x23\x49\x1C\xCB\x38\xA3\x88\xF5\x46"
 	"\xA9\xFF\x00\xDD\x4E\x13\x00\xB9\xB2\x15\x3D\x20\x41\xD2\x05\xB4"
 	"\x43\xE4\x1B\x45\xA6\x53\xF2\xA5\xC4\x49\x2C\x1A\xDD\x54\x45\x12"
 	"\xDD\xA2\x52\x98\x33\x46\x2B\x71\xA4\x1A\x45\xBE\x97\x29\x0B\x6F",
 	0, 512, },
       { GCRY_MD_SHAKE128,
 	"\x5A\xAB\x62\x75\x6D\x30\x7A\x66\x9D\x14\x6A\xBA\x98\x8D\x90\x74"
 	"\xC5\xA1\x59\xB3\xDE\x85\x15\x1A\x81\x9B\x11\x7C\xA1\xFF\x65\x97"
 	"\xF6\x15\x6E\x80\xFD\xD2\x8C\x9C\x31\x76\x83\x51\x64\xD3\x7D\xA7"
 	"\xDA\x11\xD9\x4E\x09\xAD\xD7\x70\xB6\x8A\x6E\x08\x1C\xD2\x2C\xA0"
 	"\xC0\x04\xBF\xE7\xCD\x28\x3B\xF4\x3A\x58\x8D\xA9\x1F\x50\x9B\x27"
 	"\xA6\x58\x4C\x47\x4A\x4A\x2F\x3E\xE0\xF1\xF5\x64\x47\x37\x92\x40"
 	"\xA5\xAB\x1F\xB7\x7F\xDC\xA4\x9B\x30\x5F\x07\xBA\x86\xB6\x27\x56"
 	"\xFB\x9E\xFB\x4F\xC2\x25\xC8\x68\x45\xF0\x26\xEA\x54\x20\x76\xB9"
 	"\x1A\x0B\xC2\xCD\xD1\x36\xE1\x22\xC6\x59\xBE\x25\x9D\x98\xE5\x84"
 	"\x1D\xF4\xC2\xF6\x03\x30\xD4\xD8\xCD\xEE\x7B\xF1\xA0\xA2\x44\x52"
 	"\x4E\xEC\xC6\x8F\xF2\xAE\xF5\xBF\x00\x69\xC9\xE8\x7A\x11\xC6\xE5"
 	"\x19\xDE\x1A\x40\x62\xA1\x0C\x83\x83\x73\x88\xF7\xEF\x58\x59\x8A"
 	"\x38\x46\xF4\x9D\x49\x96\x82\xB6\x83\xC4\xA0\x62\xB4\x21\x59\x4F"
 	"\xAF\xBC\x13\x83\xC9\x43\xBA\x83\xBD\xEF\x51\x5E\xFC\xF1\x0D",
 	"\xF0\x71\x5D\xE3\x56\x92\xFD\x70\x12\x3D\xC6\x83\x68\xD0\xFE\xEC"
 	"\x06\xA0\xC7\x4C\xF8\xAD\xB0\x5D\xDC\x25\x54\x87\xB1\xA8\xD4\xD1"
 	"\x21\x3E\x9E\xAB\xAF\x41\xF1\x16\x17\x19\xD0\x65\xD7\x94\xB7\x50"
 	"\xF8\x4B\xE3\x2A\x32\x34\xB4\xD5\x36\x46\x0D\x55\x20\x68\x8A\x5A"
 	"\x79\xA1\x7A\x4B\xA8\x98\x7F\xCB\x61\xBF\x7D\xAA\x8B\x54\x7B\xF5"
 	"\xC1\xCE\x36\xB5\x6A\x73\x25\x7D\xBB\xF1\xBA\xBB\x64\xF2\x49\xBD"
 	"\xCE\xB6\x7B\xA1\xC8\x88\x37\x0A\x96\x3D\xFD\x6B\x6A\x2A\xDE\x2C"
 	"\xEF\xD1\x4C\x32\x52\xCB\x37\x58\x52\x0F\x0C\x65\xF4\x52\x46\x82"
 	"\x77\x24\x99\x46\x3A\xE1\xA3\x41\x80\x01\x83\xAA\x60\xEF\xA0\x51"
 	"\x18\xA2\x82\x01\x74\x4F\x7B\xA0\xB0\xA3\x92\x8D\xD7\xC0\x26\x3F"
 	"\xD2\x64\xB7\xCD\x7B\x2E\x2E\x09\xB3\x22\xBF\xCE\xA8\xEE\xD0\x42"
 	"\x75\x79\x5B\xE7\xC0\xF0\x0E\x11\x38\x27\x37\x0D\x05\x1D\x50\x26"
 	"\x95\x80\x30\x00\x05\xAC\x12\x88\xFE\xA6\xCD\x9A\xE9\xF4\xF3\x7C"
 	"\xE0\xF8\xAC\xE8\xBF\x3E\xBE\x1D\x70\x56\x25\x59\x54\xC7\x61\x93"
 	"\x1D\x3C\x42\xED\x62\xF7\xF1\xCE\x1B\x94\x5C\xDE\xCC\x0A\x74\x32"
 	"\x2D\x7F\x64\xD6\x00\x4F\xF2\x16\x84\x14\x93\x07\x28\x8B\x44\x8E"
 	"\x45\x43\x34\x75\xB1\xEA\x13\x14\xB0\x0F\x1F\xC4\x50\x08\x9A\x9D"
 	"\x1F\x77\x10\xC6\xD7\x65\x2E\xCF\x65\x4F\x3B\x48\x7D\x02\x83\xD4"
 	"\xD8\xA2\x8E\xFB\x50\x66\xC4\x25\x0D\x5A\xD6\x98\xE1\x5D\xBA\x88"
 	"\xE9\x25\xE4\xDE\x99\xB6\x9B\xC3\x83\xAC\x80\x45\xB7\xF1\x02\x2A"
 	"\xDD\x39\xD4\x43\x54\x6A\xE0\x92\x4F\x13\xF4\x89\x60\x96\xDF\xDF"
 	"\x37\xCA\x72\x20\x79\x87\xC4\xA7\x70\x5A\x7A\xBE\x72\x4B\x7F\xA1"
 	"\x0C\x90\x9F\x39\x25\x44\x9F\x01\x0D\x61\xE2\x07\xAD\xD9\x52\x19"
 	"\x07\x1A\xCE\xED\xB9\xB9\xDC\xED\x32\xA9\xE1\x23\x56\x1D\x60\x82"
 	"\xD4\x6A\xEF\xAE\x07\xEE\x1B\xD1\x32\x76\x5E\x3E\x51\x3C\x66\x50"
 	"\x1B\x38\x7A\xB2\xEE\x09\xA0\x4A\xE6\x3E\x25\x80\x85\x17\xAF\xEA"
 	"\x3E\x05\x11\x69\xCF\xD2\xFF\xF8\xC5\x85\x8E\x2D\x96\x23\x89\x7C"
 	"\x9E\x85\x17\x5A\xC5\xA8\x63\x94\xCD\x0A\x32\xA0\xA6\x2A\x8F\x5D"
 	"\x6C\xCC\xBF\x49\x3D\xAA\x43\xF7\x83\x62\xBB\xCA\x40\xAD\xF7\x33"
 	"\xF8\x71\xE0\xC0\x09\x98\xD9\xBF\xD6\x88\x06\x56\x66\x6C\xD7\xBE"
 	"\x4F\xE9\x89\x2C\x61\xDC\xD5\xCD\x23\xA5\xE4\x27\x7E\xEE\x8B\x4A"
 	"\xFD\x29\xB6\x9B\xBA\x55\x66\x0A\x21\x71\x12\xFF\x6E\x34\x56\xB1",
 	223, 512, },
       { GCRY_MD_SHAKE128,
 	"!",
 	"\x9d\x22\x2c\x79\xc4\xff\x9d\x09\x2c\xf6\xca\x86\x14\x3a\xa4\x11"
 	"\xe3\x69\x97\x38\x08\xef\x97\x09\x32\x55\x82\x6c\x55\x72\xef\x58"
 	"\x42\x4c\x4b\x5c\x28\x47\x5f\xfd\xcf\x98\x16\x63\x86\x7f\xec\x63"
 	"\x21\xc1\x26\x2e\x38\x7b\xcc\xf8\xca\x67\x68\x84\xc4\xa9\xd0\xc1"
 	"\x3b\xfa\x68\x69\x76\x3d\x5a\xe4\xbb\xc9\xb3\xcc\xd0\x9d\x1c\xa5"
 	"\xea\x74\x46\x53\x8d\x69\xb3\xfb\x98\xc7\x2b\x59\xa2\xb4\x81\x7d"
 	"\xb5\xea\xdd\x90\x11\xf9\x0f\xa7\x10\x91\x93\x1f\x81\x34\xf4\xf0"
 	"\x0b\x56\x2e\x2f\xe1\x05\x93\x72\x70\x36\x1c\x19\x09\x86\x2a\xd4"
 	"\x50\x46\xe3\x93\x2f\x5d\xd3\x11\xec\x72\xfe\xc5\xf8\xfb\x8f\x60"
 	"\xb4\x5a\x3b\xee\x3f\x85\xbb\xf7\xfc\xed\xc6\xa5\x55\x67\x76\x48"
 	"\xe0\x65\x4b\x38\x19\x41\xa8\x6b\xd3\xe5\x12\x65\x7b\x0d\x57\xa7"
 	"\x99\x1f\xc4\x54\x3f\x89\xd8\x29\x04\x92\x22\x2c\xe4\xa3\x3e\x17"
 	"\x60\x2b\x3b\x99\xc0\x09\xf7\x65\x5f\x87\x53\x5c\xda\xa3\x71\x6f"
 	"\x58\xc4\x7b\x8a\x15\x7a\xd1\x95\xf0\x28\x09\xf2\x75\x00\xb9\x25"
 	"\x49\x79\x31\x1c\x6b\xb4\x15\x96\x8c\xd1\x04\x31\x16\x9a\x27\xd5"
 	"\xa8\xd6\x1e\x13\xa6\xb8\xb7\x7a\xf1\xf8\xb6\xdd\x2e\xef\xde\xa0"
 	"\x40\x78\x96\x80\x49\x0b\x5e\xdc\xb1\xd3\xe5\x38\xa4\x66\xf7\x57"
 	"\xad\x71\x8f\xe1\xfd\x9f\xae\xef\xa4\x72\x46\xad\x5e\x36\x7f\x87"
 	"\xd3\xb4\x85\x0d\x44\x86\xeb\x21\x99\xe9\x4a\x79\x79\xe2\x09\x1a"
 	"\xbc\xdf\x3b\xc1\x33\x79\xc8\x96\xdc\xeb\x79\xa8\xfd\x08\xf1\x10"
 	"\x73\xf3\x3e\x3f\x99\x23\x22\xb3\x12\x02\xde\xe2\x34\x33\x0c\xf3"
 	"\x30\x4a\x58\x8f\x0d\x59\xda\xe4\xe6\x3b\xa2\xac\x3c\xe6\x82\xcc"
 	"\x19\xd4\xe3\x41\x67\x8c\xc3\xa6\x7a\x47\xc1\x13\xb4\xdb\x89\x0f"
 	"\x30\xa9\x2a\xa0\x8a\x1f\x6d\xc8\xfb\x64\x63\xf8\x03\x8c\x2b\x40"
 	"\xb2\x53\x00\x77\xb2\x36\xce\x88\xaf\xcc\xcd\xa0\x8a\xd6\xd7\x5e"
 	"\xee\x18\x99\xb1\x0c\xd8\x00\xc2\xce\x53\x72\xbf\xf2\x2e\xe3\xa3"
 	"\x39\xd4\xb9\xc1\xa2\xf5\xf4\xb8\x20\xf6\x87\xe5\x51\x9b\xd0\x5b"
 	"\x1f\xc5\xda\x0e\xb4\x53\x36\x81\x4f\x48\x13\x2c\x64\x0e\x66\xc3"
 	"\xa0\x2a\x22\xe6\x35\x98\xf9\x4f\x22\xf3\x51\x84\x11\x04\x46\xb6"
 	"\x48\xcf\x84\x74\xf3\x0c\x43\xea\xd5\x83\x09\xfb\x25\x90\x16\x09"
 	"\xe2\x41\x87\xe8\x01\xc8\x09\x56\x1a\x64\x80\x94\x50\xe6\x03\xc4"
 	"\xa8\x03\x95\x25\xc4\x76\xb5\x8e\x32\xce\x2c\x47\xb3\x7d\xa5\x91",
 	0, 512, },
       { GCRY_MD_SHAKE256,
 	"",
 	"\x46\xB9\xDD\x2B\x0B\xA8\x8D\x13\x23\x3B\x3F\xEB\x74\x3E\xEB\x24"
 	"\x3F\xCD\x52\xEA\x62\xB8\x1B\x82\xB5\x0C\x27\x64\x6E\xD5\x76\x2F"
 	"\xD7\x5D\xC4\xDD\xD8\xC0\xF2\x00\xCB\x05\x01\x9D\x67\xB5\x92\xF6"
 	"\xFC\x82\x1C\x49\x47\x9A\xB4\x86\x40\x29\x2E\xAC\xB3\xB7\xC4\xBE"
 	"\x14\x1E\x96\x61\x6F\xB1\x39\x57\x69\x2C\xC7\xED\xD0\xB4\x5A\xE3"
 	"\xDC\x07\x22\x3C\x8E\x92\x93\x7B\xEF\x84\xBC\x0E\xAB\x86\x28\x53"
 	"\x34\x9E\xC7\x55\x46\xF5\x8F\xB7\xC2\x77\x5C\x38\x46\x2C\x50\x10"
 	"\xD8\x46\xC1\x85\xC1\x51\x11\xE5\x95\x52\x2A\x6B\xCD\x16\xCF\x86"
 	"\xF3\xD1\x22\x10\x9E\x3B\x1F\xDD\x94\x3B\x6A\xEC\x46\x8A\x2D\x62"
 	"\x1A\x7C\x06\xC6\xA9\x57\xC6\x2B\x54\xDA\xFC\x3B\xE8\x75\x67\xD6"
 	"\x77\x23\x13\x95\xF6\x14\x72\x93\xB6\x8C\xEA\xB7\xA9\xE0\xC5\x8D"
 	"\x86\x4E\x8E\xFD\xE4\xE1\xB9\xA4\x6C\xBE\x85\x47\x13\x67\x2F\x5C"
 	"\xAA\xAE\x31\x4E\xD9\x08\x3D\xAB\x4B\x09\x9F\x8E\x30\x0F\x01\xB8"
 	"\x65\x0F\x1F\x4B\x1D\x8F\xCF\x3F\x3C\xB5\x3F\xB8\xE9\xEB\x2E\xA2"
 	"\x03\xBD\xC9\x70\xF5\x0A\xE5\x54\x28\xA9\x1F\x7F\x53\xAC\x26\x6B"
 	"\x28\x41\x9C\x37\x78\xA1\x5F\xD2\x48\xD3\x39\xED\xE7\x85\xFB\x7F"
 	"\x5A\x1A\xAA\x96\xD3\x13\xEA\xCC\x89\x09\x36\xC1\x73\xCD\xCD\x0F"
 	"\xAB\x88\x2C\x45\x75\x5F\xEB\x3A\xED\x96\xD4\x77\xFF\x96\x39\x0B"
 	"\xF9\xA6\x6D\x13\x68\xB2\x08\xE2\x1F\x7C\x10\xD0\x4A\x3D\xBD\x4E"
 	"\x36\x06\x33\xE5\xDB\x4B\x60\x26\x01\xC1\x4C\xEA\x73\x7D\xB3\xDC"
 	"\xF7\x22\x63\x2C\xC7\x78\x51\xCB\xDD\xE2\xAA\xF0\xA3\x3A\x07\xB3"
 	"\x73\x44\x5D\xF4\x90\xCC\x8F\xC1\xE4\x16\x0F\xF1\x18\x37\x8F\x11"
 	"\xF0\x47\x7D\xE0\x55\xA8\x1A\x9E\xDA\x57\xA4\xA2\xCF\xB0\xC8\x39"
 	"\x29\xD3\x10\x91\x2F\x72\x9E\xC6\xCF\xA3\x6C\x6A\xC6\xA7\x58\x37"
 	"\x14\x30\x45\xD7\x91\xCC\x85\xEF\xF5\xB2\x19\x32\xF2\x38\x61\xBC"
 	"\xF2\x3A\x52\xB5\xDA\x67\xEA\xF7\xBA\xAE\x0F\x5F\xB1\x36\x9D\xB7"
 	"\x8F\x3A\xC4\x5F\x8C\x4A\xC5\x67\x1D\x85\x73\x5C\xDD\xDB\x09\xD2"
 	"\xB1\xE3\x4A\x1F\xC0\x66\xFF\x4A\x16\x2C\xB2\x63\xD6\x54\x12\x74"
 	"\xAE\x2F\xCC\x86\x5F\x61\x8A\xBE\x27\xC1\x24\xCD\x8B\x07\x4C\xCD"
 	"\x51\x63\x01\xB9\x18\x75\x82\x4D\x09\x95\x8F\x34\x1E\xF2\x74\xBD"
 	"\xAB\x0B\xAE\x31\x63\x39\x89\x43\x04\xE3\x58\x77\xB0\xC2\x8A\x9B"
 	"\x1F\xD1\x66\xC7\x96\xB9\xCC\x25\x8A\x06\x4A\x8F\x57\xE2\x7F\x2A",
 	0, 512, },
       { GCRY_MD_SHAKE256,
 	"\xB3\x2D\x95\xB0\xB9\xAA\xD2\xA8\x81\x6D\xE6\xD0\x6D\x1F\x86\x00"
 	"\x85\x05\xBD\x8C\x14\x12\x4F\x6E\x9A\x16\x3B\x5A\x2A\xDE\x55\xF8"
 	"\x35\xD0\xEC\x38\x80\xEF\x50\x70\x0D\x3B\x25\xE4\x2C\xC0\xAF\x05"
 	"\x0C\xCD\x1B\xE5\xE5\x55\xB2\x30\x87\xE0\x4D\x7B\xF9\x81\x36\x22"
 	"\x78\x0C\x73\x13\xA1\x95\x4F\x87\x40\xB6\xEE\x2D\x3F\x71\xF7\x68"
 	"\xDD\x41\x7F\x52\x04\x82\xBD\x3A\x08\xD4\xF2\x22\xB4\xEE\x9D\xBD"
 	"\x01\x54\x47\xB3\x35\x07\xDD\x50\xF3\xAB\x42\x47\xC5\xDE\x9A\x8A"
 	"\xBD\x62\xA8\xDE\xCE\xA0\x1E\x3B\x87\xC8\xB9\x27\xF5\xB0\x8B\xEB"
 	"\x37\x67\x4C\x6F\x8E\x38\x0C\x04",
 	"\xCC\x2E\xAA\x04\xEE\xF8\x47\x9C\xDA\xE8\x56\x6E\xB8\xFF\xA1\x10"
 	"\x0A\x40\x79\x95\xBF\x99\x9A\xE9\x7E\xDE\x52\x66\x81\xDC\x34\x90"
 	"\x61\x6F\x28\x44\x2D\x20\xDA\x92\x12\x4C\xE0\x81\x58\x8B\x81\x49"
 	"\x1A\xED\xF6\x5C\xAA\xF0\xD2\x7E\x82\xA4\xB0\xE1\xD1\xCA\xB2\x38"
 	"\x33\x32\x8F\x1B\x8D\xA4\x30\xC8\xA0\x87\x66\xA8\x63\x70\xFA\x84"
 	"\x8A\x79\xB5\x99\x8D\xB3\xCF\xFD\x05\x7B\x96\xE1\xE2\xEE\x0E\xF2"
 	"\x29\xEC\xA1\x33\xC1\x55\x48\xF9\x83\x99\x02\x04\x37\x30\xE4\x4B"
 	"\xC5\x2C\x39\xFA\xDC\x1D\xDE\xEA\xD9\x5F\x99\x39\xF2\x20\xCA\x30"
 	"\x06\x61\x54\x0D\xF7\xED\xD9\xAF\x37\x8A\x5D\x4A\x19\xB2\xB9\x3E"
 	"\x6C\x78\xF4\x9C\x35\x33\x43\xA0\xB5\xF1\x19\x13\x2B\x53\x12\xD0"
 	"\x04\x83\x1D\x01\x76\x9A\x31\x6D\x2F\x51\xBF\x64\xCC\xB2\x0A\x21"
 	"\xC2\xCF\x7A\xC8\xFB\x6F\x6E\x90\x70\x61\x26\xBD\xAE\x06\x11\xDD"
 	"\x13\x96\x2E\x8B\x53\xD6\xEA\xE2\x6C\x7B\x0D\x25\x51\xDA\xF6\x24"
 	"\x8E\x9D\x65\x81\x73\x82\xB0\x4D\x23\x39\x2D\x10\x8E\x4D\x34\x43"
 	"\xDE\x5A\xDC\x72\x73\xC7\x21\xA8\xF8\x32\x0E\xCF\xE8\x17\x7A\xC0"
 	"\x67\xCA\x8A\x50\x16\x9A\x6E\x73\x00\x0E\xBC\xDC\x1E\x4E\xE6\x33"
 	"\x9F\xC8\x67\xC3\xD7\xAE\xAB\x84\x14\x63\x98\xD7\xBA\xDE\x12\x1D"
 	"\x19\x89\xFA\x45\x73\x35\x56\x4E\x97\x57\x70\xA3\xA0\x02\x59\xCA"
 	"\x08\x70\x61\x08\x26\x1A\xA2\xD3\x4D\xE0\x0F\x8C\xAC\x7D\x45\xD3"
 	"\x5E\x5A\xA6\x3E\xA6\x9E\x1D\x1A\x2F\x7D\xAB\x39\x00\xD5\x1E\x0B"
 	"\xC6\x53\x48\xA2\x55\x54\x00\x70\x39\xA5\x2C\x3C\x30\x99\x80\xD1"
 	"\x7C\xAD\x20\xF1\x15\x63\x10\xA3\x9C\xD3\x93\x76\x0C\xFE\x58\xF6"
 	"\xF8\xAD\xE4\x21\x31\x28\x82\x80\xA3\x5E\x1D\xB8\x70\x81\x83\xB9"
 	"\x1C\xFA\xF5\x82\x7E\x96\xB0\xF7\x74\xC4\x50\x93\xB4\x17\xAF\xF9"
 	"\xDD\x64\x17\xE5\x99\x64\xA0\x1B\xD2\xA6\x12\xFF\xCF\xBA\x18\xA0"
 	"\xF1\x93\xDB\x29\x7B\x9A\x6C\xC1\xD2\x70\xD9\x7A\xAE\x8F\x8A\x3A"
 	"\x6B\x26\x69\x5A\xB6\x64\x31\xC2\x02\xE1\x39\xD6\x3D\xD3\xA2\x47"
 	"\x78\x67\x6C\xEF\xE3\xE2\x1B\x02\xEC\x4E\x8F\x5C\xFD\x66\x58\x7A"
 	"\x12\xB4\x40\x78\xFC\xD3\x9E\xEE\x44\xBB\xEF\x4A\x94\x9A\x63\xC0"
 	"\xDF\xD5\x8C\xF2\xFB\x2C\xD5\xF0\x02\xE2\xB0\x21\x92\x66\xCF\xC0"
 	"\x31\x81\x74\x86\xDE\x70\xB4\x28\x5A\x8A\x70\xF3\xD3\x8A\x61\xD3"
 	"\x15\x5D\x99\xAA\xF4\xC2\x53\x90\xD7\x36\x45\xAB\x3E\x8D\x80\xF0",
 	136, 512, },
       { GCRY_MD_SHAKE256,
 	"!",
 	"\x35\x78\xa7\xa4\xca\x91\x37\x56\x9c\xdf\x76\xed\x61\x7d\x31\xbb"
 	"\x99\x4f\xca\x9c\x1b\xbf\x8b\x18\x40\x13\xde\x82\x34\xdf\xd1\x3a"
 	"\x3f\xd1\x24\xd4\xdf\x76\xc0\xa5\x39\xee\x7d\xd2\xf6\xe1\xec\x34"
 	"\x61\x24\xc8\x15\xd9\x41\x0e\x14\x5e\xb5\x61\xbc\xd9\x7b\x18\xab"
 	"\x6c\xe8\xd5\x55\x3e\x0e\xab\x3d\x1f\x7d\xfb\x8f\x9d\xee\xfe\x16"
 	"\x84\x7e\x21\x92\xf6\xf6\x1f\xb8\x2f\xb9\x0d\xde\x60\xb1\x90\x63"
 	"\xc5\x6a\x4c\x55\xcd\xd7\xb6\x72\xb7\x5b\xf5\x15\xad\xbf\xe2\x04"
 	"\x90\x3c\x8c\x00\x36\xde\x54\xa2\x99\x9a\x92\x0d\xe9\x0f\x66\xd7"
 	"\xff\x6e\xc8\xe4\xc9\x3d\x24\xae\x34\x6f\xdc\xb3\xa5\xa5\xbd\x57"
 	"\x39\xec\x15\xa6\xed\xdb\x5c\xe5\xb0\x2d\xa5\x30\x39\xfa\xc6\x3e"
 	"\x19\x55\x5f\xaa\x2e\xdd\xc6\x93\xb1\xf0\xc2\xa6\xfc\xbe\x7c\x0a"
 	"\x0a\x09\x1d\x0e\xe7\x00\xd7\x32\x2e\x4b\x0f\xf0\x95\x90\xde\x16"
 	"\x64\x22\xf9\xea\xd5\xda\x4c\x99\x3d\x60\x5f\xe4\xd9\xc6\x34\x84"
 	"\x3a\xa1\x78\xb1\x76\x72\xc6\x56\x8c\x8a\x2e\x62\xab\xeb\xea\x2c"
 	"\x21\xc3\x02\xbd\x36\x6a\xd6\x98\x95\x9e\x1f\x6e\x43\x4a\xf1\x55"
 	"\x56\x8b\x27\x34\xd8\x37\x9f\xcd\x3f\xfe\x64\x89\xba\xff\xa6\xd7"
 	"\x11\x09\x44\x2e\x1b\x34\x4f\x13\x8a\x09\xca\xe3\xe2\xd3\x94\x2e"
 	"\xee\x82\x8f\xc4\x7e\x64\xde\xb5\xe0\x0a\x02\x4a\xe1\xf2\xc0\x77"
 	"\xe6\xb7\xb1\x33\xf6\xc1\xde\x91\x30\x92\xd4\xe8\x29\xec\xd2\xb2"
 	"\xef\x28\xca\x80\x20\x82\x1e\x2b\x8b\xe5\x17\xd9\x3e\xd0\x88\x36"
 	"\xf6\xf0\x66\xcc\x3d\x03\xb6\x25\xd8\x49\x7f\x29\xdb\xc1\xc3\x9e"
 	"\x6f\xe4\x63\x22\x6f\x85\xc1\x28\xa2\xc2\x98\x88\x11\x2e\x06\xa9"
 	"\x9c\x5d\x17\xb2\x5e\x90\x0d\x20\x4f\x39\x72\x31\xcd\xf7\x9c\x31"
 	"\x34\x46\x53\x2d\xad\x07\xf4\xc0\xbd\x9f\xba\x1d\xd4\x13\xd8\xa7"
 	"\xe6\xcb\xc0\xa0\x86\x2c\xc7\x69\x23\x9a\x89\xf9\xdb\x08\x5b\x78"
 	"\xa0\x54\x59\x6a\xd7\x08\x0d\xdf\x96\x01\x9b\x73\x99\xb5\x03\x48"
 	"\x0e\x5a\x65\xa2\x20\x8d\x74\x72\x4c\x98\x7d\x32\x5e\x9b\x0e\x82"
 	"\xfe\xcd\x4f\x27\xf3\x13\x5b\x1d\x9e\x27\xb4\x8e\x69\xdd\x6f\x59"
 	"\x62\xb8\xa6\x3b\x48\x92\x1e\xc8\xee\x53\x86\x9f\x1a\xc1\xc8\x18"
 	"\x23\x87\xee\x0d\x6c\xfe\xf6\x53\xff\x8b\xf6\x05\xf1\x47\x04\xb7"
 	"\x1b\xeb\x65\x53\xf2\x81\xfa\x75\x69\x48\xc4\x38\x49\x4b\x19\xb4"
 	"\xee\x69\xa5\x43\x6b\x22\x2b\xc9\x88\xed\xa4\xac\x60\x00\x24\xc9",
 	0, 512, },
       { GCRY_MD_BLAKE2B_512, "abc",
 	"\xBA\x80\xA5\x3F\x98\x1C\x4D\x0D\x6A\x27\x97\xB6\x9F\x12\xF6\xE9"
 	"\x4C\x21\x2F\x14\x68\x5A\xC4\xB7\x4B\x12\xBB\x6F\xDB\xFF\xA2\xD1"
 	"\x7D\x87\xC5\x39\x2A\xAB\x79\x2D\xC2\x52\xD5\xDE\x45\x33\xCC\x95"
 	"\x18\xD3\x8A\xA8\xDB\xF1\x92\x5A\xB9\x23\x86\xED\xD4\x00\x99\x23" },
       { GCRY_MD_BLAKE2B_512, "\x00",
 	"\x96\x1f\x6d\xd1\xe4\xdd\x30\xf6\x39\x01\x69\x0c\x51\x2e\x78\xe4"
 	"\xb4\x5e\x47\x42\xed\x19\x7c\x3c\x5e\x45\xc5\x49\xfd\x25\xf2\xe4"
 	"\x18\x7b\x0b\xc9\xfe\x30\x49\x2b\x16\xb0\xd0\xbc\x4e\xf9\xb0\xf3"
 	"\x4c\x70\x03\xfa\xc0\x9a\x5e\xf1\x53\x2e\x69\x43\x02\x34\xce\xbd",
 	1, 64,
 	"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
 	"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
 	"\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f"
 	"\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f",
 	64 },
 #include "./blake2b.h"
       { GCRY_MD_BLAKE2B_160,
 	"",
 	"\xad\x75\xea\xd7\x9f\x71\x21\xd1\xf0\x8a\xfe\x59\x99\x27\xa5\xa3"
 	"\x8b\xe1\xb1\x79",
 	0, 20,
 	"\x65\x65\xcb\x30\xfb\x2c\x28\x54\x7c\xd0\x4c\x1d\x6a\x88\xf2\x7a"
 	"\x6d\xe8\x55\x3d",
 	20 },
       { GCRY_MD_BLAKE2B_160,
 	"\x9c\x9c\x38",
 	"\x82\x79\x9d\x7b\xe8\xf4\xd1\x69\xfb\x85\xe6\x63\x6a\x7b\x6c\x50"
 	"\xa0\x1f\x70\xa2",
 	3, 20,
 	"\x65\x65\xcb\x30\xfb\x2c\x28\x54\x7c\xd0\x4c\x1d\x6a\x88\xf2\x7a"
 	"\x6d\xe8\x55\x3d",
 	20 },
       { GCRY_MD_BLAKE2B_256,
 	"",
 	"\x89\x36\x29\x47\x52\x79\xdf\xd8\x2a\x84\x1a\x8f\x21\xa3\x72\xed"
 	"\x30\xcc\xb8\xae\x34\x62\xe1\x90\x7f\x50\x66\x3f\x3c\x03\x66\x83",
 	0, 32,
 	"\xd5\xd5\xab\x80\x2c\xad\xd9\x86\x60\xe7\x47\x2f\x77\xa6\x1d\xc4"
 	"\xe2\xa6\x88\x2f\xb7\xe6\x9e\x85\x23\xa9\xcd\x76\x43\xb9\xfd\xb7",
 	32 },
       { GCRY_MD_BLAKE2B_256,
 	"\x9c\x9c\x38",
 	"\x01\x6a\x18\xbb\x10\xe0\xc3\xa5\xe5\x9f\xce\xfd\x1a\x40\x7a\xb7"
 	"\xf1\xc0\x36\x1b\x3f\x98\x34\x77\x42\x54\xd3\xf0\x4c\xda\x38\x98",
 	3, 32,
 	"\xd5\xd5\xab\x80\x2c\xad\xd9\x86\x60\xe7\x47\x2f\x77\xa6\x1d\xc4"
 	"\xe2\xa6\x88\x2f\xb7\xe6\x9e\x85\x23\xa9\xcd\x76\x43\xb9\xfd\xb7",
 	32 },
       { GCRY_MD_BLAKE2B_384,
 	"",
 	"\xd7\x2c\x9b\x4a\x73\x4e\xb2\x07\xe9\xdd\xbf\xf0\x0b\x10\xc3\x70"
 	"\xc8\x9d\x67\xd7\x96\xc3\xa7\xb9\x68\x15\xa9\x53\x92\x1b\xb2\x97"
 	"\x59\xd2\x9d\x25\x63\xf3\xda\x4d\x7f\x3e\xa4\xa6\xe3\x4c\x32\x6b",
 	0, 48,
 	"\xc0\xc0\x80\x41\xc2\x03\xc6\xca\x90\x5b\xeb\x46\x32\x79\xac\x26"
 	"\xd3\xf9\xcc\xc6\x93\x5a\xed\x48\x35\x7d\xb3\x31\xe5\x16\xfb\x12"
 	"\x0e\x21\x2f\x51\x80\xd1\x52\x24\x77\x9c\x13\xaf\xc3\x73\x37\xaa",
 	48 },
       { GCRY_MD_BLAKE2B_384,
 	"\x9c\x9c\x38",
 	"\xef\x46\xfa\x54\xa2\xc2\x20\xda\x06\xa8\x4c\x77\x6e\x87\xdd\x0a"
 	"\x21\xee\xb5\xe9\x40\x1a\x0a\x78\x11\x19\x74\x18\xfe\x92\x70\x15"
 	"\x77\xd0\xa8\x53\x24\x48\xe8\xb8\x53\x6a\xa6\xc7\x42\xcd\x2c\x62",
 	3, 48,
 	"\xc0\xc0\x80\x41\xc2\x03\xc6\xca\x90\x5b\xeb\x46\x32\x79\xac\x26"
 	"\xd3\xf9\xcc\xc6\x93\x5a\xed\x48\x35\x7d\xb3\x31\xe5\x16\xfb\x12"
 	"\x0e\x21\x2f\x51\x80\xd1\x52\x24\x77\x9c\x13\xaf\xc3\x73\x37\xaa",
 	48 },
       { GCRY_MD_BLAKE2B_512,
 	"",
 	"\xd7\x4b\xf3\x1e\x5c\xe5\xd8\xa2\x5d\x09\x21\x52\x53\xca\xd2\xf8"
 	"\xd2\xfd\xa9\x10\x09\x30\x16\x05\xa6\x8c\xc3\x86\x5b\xb7\x93\x5b"
 	"\xca\xff\x6f\x2a\xf6\x43\xa7\x76\x99\xe8\x02\x61\xa1\xfd\x2c\x80"
 	"\xe8\x37\xb5\x62\x32\xf7\xb1\x46\x43\x4a\xa7\x4d\x71\x18\xbb\x16",
 	0, 64,
 	"\xab\xab\x56\x01\x58\x5a\xb3\x0d\xc1\xce\x8f\x5e\xee\x4d\x3b\x88"
 	"\xc4\x4c\x11\x5e\x6f\xcd\x3d\x0a\x47\x52\x9a\xec\x86\x73\xfa\x6e"
 	"\x68\xd6\x3f\x16\x55\x6b\xc1\x2d\xef\x1d\x0c\x29\x35\x5f\x94\xf3"
 	"\x88\x7c\x04\x81\x86\x07\x8e\x95\x23\xb9\xdd\x97\x74\x0c\x80\x8c",
 	64 },
       { GCRY_MD_BLAKE2B_512,
 	"\x9c\x9c\x38",
 	"\x70\xfc\x57\xe1\x49\x5f\xe4\x39\x0d\x38\xa1\xd3\x97\x05\xee\xf6"
 	"\xaa\xbb\xd2\x64\xc7\xce\x66\x11\x8d\x0a\x87\xd4\x25\x94\xb3\x87"
 	"\xdc\x50\x18\x8b\xba\x61\xf0\x91\xd6\xb3\x4f\xf5\x4e\x09\x1e\x70"
 	"\x24\x01\x83\xcd\xb9\x21\x1f\x14\x39\x77\x5c\xc6\xe6\xe9\x35\x73",
 	3, 64,
 	"\xab\xab\x56\x01\x58\x5a\xb3\x0d\xc1\xce\x8f\x5e\xee\x4d\x3b\x88"
 	"\xc4\x4c\x11\x5e\x6f\xcd\x3d\x0a\x47\x52\x9a\xec\x86\x73\xfa\x6e"
 	"\x68\xd6\x3f\x16\x55\x6b\xc1\x2d\xef\x1d\x0c\x29\x35\x5f\x94\xf3"
 	"\x88\x7c\x04\x81\x86\x07\x8e\x95\x23\xb9\xdd\x97\x74\x0c\x80\x8c",
 	64 },
       { GCRY_MD_BLAKE2B_512, "!",
 	"\x98\xfb\x3e\xfb\x72\x06\xfd\x19\xeb\xf6\x9b\x6f\x31\x2c\xf7\xb6"
 	"\x4e\x3b\x94\xdb\xe1\xa1\x71\x07\x91\x39\x75\xa7\x93\xf1\x77\xe1"
 	"\xd0\x77\x60\x9d\x7f\xba\x36\x3c\xbb\xa0\x0d\x05\xf7\xaa\x4e\x4f"
 	"\xa8\x71\x5d\x64\x28\x10\x4c\x0a\x75\x64\x3b\x0f\xf3\xfd\x3e\xaf" },
       { GCRY_MD_BLAKE2B_512, "?",
 	"\xae\x9c\xf5\x7a\xc2\xff\x7b\x37\x7a\x5b\xb5\xcc\x2e\x62\x92\x20"
 	"\xa9\xba\x0a\x09\xc2\x2a\x0f\xdb\xd9\xa3\xae\xd6\x32\xc1\x72\x0e"
 	"\x6d\x82\x9f\x74\x7f\xba\x12\xe8\x31\xa2\x45\x8d\xf0\x73\x4e\xe0"
 	"\x12\x27\x52\xd3\xe2\x2c\x36\xc4\x42\x89\x3b\xcd\xd1\xbd\xd9\x08" },
       { GCRY_MD_BLAKE2B_384, "?",
 	"\x22\x66\x8e\x05\x81\x44\x52\xa5\x23\x84\xce\x67\xd4\xad\x0e\x03"
 	"\xdf\xe7\x1a\xc1\x56\x9d\x95\x4a\xd2\x22\x7a\x70\x2a\xfe\x6c\x68"
 	"\x5c\x7d\x65\x30\x2b\xc0\xde\xc6\xea\x72\x1e\xdd\x46\xdf\xb2\x08" },
       { GCRY_MD_BLAKE2B_256, "?",
 	"\xfa\x11\x30\xd8\xba\x8a\x4c\x5a\x0e\x6f\x4f\x4c\xd2\xd1\x38\x0c"
 	"\xb9\x22\x2a\xbd\xf6\x20\x70\xf8\x02\x1b\x34\xdd\xd7\x24\x92\x1b" },
       { GCRY_MD_BLAKE2B_160, "?",
 	"\xe7\x86\x08\x31\xf8\x96\x8d\x64\x9b\xe0\x15\x68\x33\xf3\xbd\x2a"
 	"\x5f\x0b\xdb\x40" },
       { GCRY_MD_BLAKE2S_256, "abc",
 	"\x50\x8C\x5E\x8C\x32\x7C\x14\xE2\xE1\xA7\x2B\xA3\x4E\xEB\x45\x2F"
 	"\x37\x45\x8B\x20\x9E\xD6\x3A\x29\x4D\x99\x9B\x4C\x86\x67\x59\x82" },
 #include "./blake2s.h"
       { GCRY_MD_BLAKE2S_128,
 	"",
 	"\x84\x89\x68\xb3\x59\x01\xe9\x57\x9a\x4d\xbf\x28\xdf\x99\xec\x23",
 	0, 16,
 	"\xea\xea\xd5\xc0\x96\x56\xec\x43\x30\x73\xa3\x17\xbb\xd3\x8e\x62",
 	16 },
       { GCRY_MD_BLAKE2S_128,
 	"\x9c\x9c\x38",
 	"\x2e\xbb\x18\x78\xda\x34\x05\xad\x98\x1a\x33\x06\x50\x35\xd3\x75",
 	3, 16,
 	"\xea\xea\xd5\xc0\x96\x56\xec\x43\x30\x73\xa3\x17\xbb\xd3\x8e\x62",
 	16 },
       { GCRY_MD_BLAKE2S_128,
 	"\xab\xab\x56\x01\x58\x5a\xb3\x0d\xc1\xce\x8f\x5e\xee\x4d\x3b\x88"
 	"\xc4\x4c\x11\x5e\x6f\xcd\x3d\x0a\x47\x52\x9a\xec\x86\x73\xfa\x6e"
 	"\x68\xd6\x3f\x16\x55\x6b\xc1\x2d\xef\x1d\x0c\x29\x35\x5f\x94\xf3"
 	"\x88\x7c\x04\x81\x86\x07\x8e\x95\x23\xb9\xdd\x97\x74\x0c\x80\x8c",
 	"\x3c\xd4\xea\xd7\x88\x0b\x8e\x82\xde\x07\x9c\x1f\xad\x34\x17\xd4",
 	64, 16,
 	"\xea\xea\xd5\xc0\x96\x56\xec\x43\x30\x73\xa3\x17\xbb\xd3\x8e\x62",
 	16 },
       { GCRY_MD_BLAKE2S_128,
 	"\x8a\x8a\x14\x9e\xb2\x50\x02\x52\x54\xa6\xfa\xa0\x9a\x3a\xd4\x0e"
 	"\xe3\xf2\xd5\xc7\x9d\x64\x02\x66\x68\xcf\x38\x08\x41\x49\x8a\xd3"
 	"\x5e\x32\x90\xc2\x53\x15\x68\x7e\xe6\x65\x4b\xb0\xfc\xad\xaa\x58"
 	"\x02\x5b\x5e\xb9\x18\xd1\xe9\xbb\xa5\x61\x07\x68\x70\xd9\x49\x22"
 	"\x6b",
 	"\xee\x92\xc5\x25\x4c\x29\x7a\x88\xe6\x9a\x23\x69\x56\xb6\x7c\xee",
 	65, 16,
 	"\xea\xea\xd5\xc0\x96\x56\xec\x43\x30\x73\xa3\x17\xbb\xd3\x8e\x62",
 	16 },
       { GCRY_MD_BLAKE2S_160,
 	"",
 	"\x68\x64\x48\x80\x0c\x80\xc6\xd0\x4f\xb7\x3f\xc1\x7f\xa0\x8c\xa2"
 	"\x39\x03\xe1\xe9",
 	0, 20,
 	"\x65\x65\xcb\x30\xfb\x2c\x28\x54\x7c\xd0\x4c\x1d\x6a\x88\xf2\x7a"
 	"\x6d\xe8\x55\x3d",
 	20 },
       { GCRY_MD_BLAKE2S_160,
 	"\x9c\x9c\x38",
 	"\xba\xb3\x5b\x8c\x87\x04\x1a\x00\x24\x44\xa5\xca\x45\x13\x2d\x75"
 	"\xef\xd3\x4c\xb9",
 	3, 20,
 	"\x65\x65\xcb\x30\xfb\x2c\x28\x54\x7c\xd0\x4c\x1d\x6a\x88\xf2\x7a"
 	"\x6d\xe8\x55\x3d",
 	20 },
       { GCRY_MD_BLAKE2S_160,
 	"\xab\xab\x56\x01\x58\x5a\xb3\x0d\xc1\xce\x8f\x5e\xee\x4d\x3b\x88"
 	"\xc4\x4c\x11\x5e\x6f\xcd\x3d\x0a\x47\x52\x9a\xec\x86\x73\xfa\x6e"
 	"\x68\xd6\x3f\x16\x55\x6b\xc1\x2d\xef\x1d\x0c\x29\x35\x5f\x94\xf3"
 	"\x88\x7c\x04\x81\x86\x07\x8e\x95\x23\xb9\xdd\x97\x74\x0c\x80\x8c",
 	"\xe8\xc3\xf1\xdb\x1c\xf8\xe9\xd1\xb5\x4a\x54\x0a\xdc\xe7\x18\x13"
 	"\x0f\xf4\x12\x98",
 	64, 20,
 	"\x65\x65\xcb\x30\xfb\x2c\x28\x54\x7c\xd0\x4c\x1d\x6a\x88\xf2\x7a"
 	"\x6d\xe8\x55\x3d",
 	20 },
       { GCRY_MD_BLAKE2S_160,
 	"\x8a\x8a\x14\x9e\xb2\x50\x02\x52\x54\xa6\xfa\xa0\x9a\x3a\xd4\x0e"
 	"\xe3\xf2\xd5\xc7\x9d\x64\x02\x66\x68\xcf\x38\x08\x41\x49\x8a\xd3"
 	"\x5e\x32\x90\xc2\x53\x15\x68\x7e\xe6\x65\x4b\xb0\xfc\xad\xaa\x58"
 	"\x02\x5b\x5e\xb9\x18\xd1\xe9\xbb\xa5\x61\x07\x68\x70\xd9\x49\x22"
 	"\x6b",
 	"\x59\x02\xf8\x38\x18\x77\x9c\xd8\x13\x40\x0f\xd6\xbb\x23\x04\x1b"
 	"\x64\x9a\x57\xa7",
 	65, 20,
 	"\x65\x65\xcb\x30\xfb\x2c\x28\x54\x7c\xd0\x4c\x1d\x6a\x88\xf2\x7a"
 	"\x6d\xe8\x55\x3d",
 	20 },
       { GCRY_MD_BLAKE2S_224,
 	"",
 	"\xa8\x66\x86\x63\x35\x3a\xe0\x8f\x4e\x4b\x6b\x1e\xcb\x43\x19\xc8"
 	"\x2b\x41\x3f\x5e\xe5\x43\x95\x9c\xa5\x9a\x73\x1b",
 	0, 28,
 	"\x5a\x5a\xb5\x10\xc6\xd7\x9e\x76\x14\x8a\x9e\x29\xc8\xf1\xba\xab"
 	"\x65\x11\x77\x89\x00\x89\x8a\x14\x9f\xb4\x53\x07",
 	28 },
       { GCRY_MD_BLAKE2S_224,
 	"\x9c\x9c\x38",
 	"\x1a\x34\x9d\xc1\x51\xbd\x8b\xa2\xa7\xa6\x6b\xe4\x93\x98\x51\x88"
 	"\x33\x49\x71\x02\x09\xb1\x20\x85\x8c\x4c\x67\xb8",
 	3, 28,
 	"\x5a\x5a\xb5\x10\xc6\xd7\x9e\x76\x14\x8a\x9e\x29\xc8\xf1\xba\xab"
 	"\x65\x11\x77\x89\x00\x89\x8a\x14\x9f\xb4\x53\x07",
 	28 },
       { GCRY_MD_BLAKE2S_224,
 	"\xab\xab\x56\x01\x58\x5a\xb3\x0d\xc1\xce\x8f\x5e\xee\x4d\x3b\x88"
 	"\xc4\x4c\x11\x5e\x6f\xcd\x3d\x0a\x47\x52\x9a\xec\x86\x73\xfa\x6e"
 	"\x68\xd6\x3f\x16\x55\x6b\xc1\x2d\xef\x1d\x0c\x29\x35\x5f\x94\xf3"
 	"\x88\x7c\x04\x81\x86\x07\x8e\x95\x23\xb9\xdd\x97\x74\x0c\x80\x8c",
 	"\x3a\x0e\xd5\x46\x95\x8c\xd6\xf9\x7c\x38\xd0\xe7\x1c\xfd\xd4\xc5"
 	"\x67\x6d\x5c\xcc\x35\x06\xec\x87\x87\x09\x26\x39",
 	64, 28,
 	"\x5a\x5a\xb5\x10\xc6\xd7\x9e\x76\x14\x8a\x9e\x29\xc8\xf1\xba\xab"
 	"\x65\x11\x77\x89\x00\x89\x8a\x14\x9f\xb4\x53\x07",
 	28 },
       { GCRY_MD_BLAKE2S_224,
 	"\x8a\x8a\x14\x9e\xb2\x50\x02\x52\x54\xa6\xfa\xa0\x9a\x3a\xd4\x0e"
 	"\xe3\xf2\xd5\xc7\x9d\x64\x02\x66\x68\xcf\x38\x08\x41\x49\x8a\xd3"
 	"\x5e\x32\x90\xc2\x53\x15\x68\x7e\xe6\x65\x4b\xb0\xfc\xad\xaa\x58"
 	"\x02\x5b\x5e\xb9\x18\xd1\xe9\xbb\xa5\x61\x07\x68\x70\xd9\x49\x22"
 	"\x6b",
 	"\x63\xd7\x98\xcc\x8e\xe3\x00\x45\x2f\xd8\x19\x83\x02\x94\x7f\xf1"
 	"\xb3\x82\x73\xaa\x19\xae\x72\x8b\x1f\x64\xbe\x88",
 	65, 28,
 	"\x5a\x5a\xb5\x10\xc6\xd7\x9e\x76\x14\x8a\x9e\x29\xc8\xf1\xba\xab"
 	"\x65\x11\x77\x89\x00\x89\x8a\x14\x9f\xb4\x53\x07",
 	28 },
       { GCRY_MD_BLAKE2S_256,
 	"",
 	"\x98\xf3\x21\xe5\x43\xb8\x07\x35\x27\x9c\x86\x1c\x36\x33\x9b\x43"
 	"\x45\x50\xc6\x9d\x23\xc6\xc8\xff\x96\xbf\x4e\x03\x86\x10\x24\xfd",
 	0, 32,
 	"\xd5\xd5\xab\x80\x2c\xad\xd9\x86\x60\xe7\x47\x2f\x77\xa6\x1d\xc4"
 	"\xe2\xa6\x88\x2f\xb7\xe6\x9e\x85\x23\xa9\xcd\x76\x43\xb9\xfd\xb7",
 	32 },
       { GCRY_MD_BLAKE2S_256,
 	"\x9c\x9c\x38",
 	"\x7b\x10\xa3\x67\xb8\x5d\x29\x9a\x91\x27\x37\x05\x9d\x05\x9d\x3d"
 	"\xe6\x42\xa3\x19\x04\x57\x01\xb6\x25\x0b\xfd\x3c\x6c\xb9\x4f\x87",
 	3, 32,
 	"\xd5\xd5\xab\x80\x2c\xad\xd9\x86\x60\xe7\x47\x2f\x77\xa6\x1d\xc4"
 	"\xe2\xa6\x88\x2f\xb7\xe6\x9e\x85\x23\xa9\xcd\x76\x43\xb9\xfd\xb7",
 	32 },
       { GCRY_MD_BLAKE2S_256,
 	"\xab\xab\x56\x01\x58\x5a\xb3\x0d\xc1\xce\x8f\x5e\xee\x4d\x3b\x88"
 	"\xc4\x4c\x11\x5e\x6f\xcd\x3d\x0a\x47\x52\x9a\xec\x86\x73\xfa\x6e"
 	"\x68\xd6\x3f\x16\x55\x6b\xc1\x2d\xef\x1d\x0c\x29\x35\x5f\x94\xf3"
 	"\x88\x7c\x04\x81\x86\x07\x8e\x95\x23\xb9\xdd\x97\x74\x0c\x80\x8c",
 	"\xd7\x8b\x98\x28\x54\x4c\xc1\x62\x9e\xab\x7d\xfe\xb1\xfa\xdd\x2b"
 	"\xed\x98\x1c\xe6\x5f\xef\xd8\x08\x42\x9a\x11\x1e\x97\x44\x92\xa3",
 	64, 32,
 	"\xd5\xd5\xab\x80\x2c\xad\xd9\x86\x60\xe7\x47\x2f\x77\xa6\x1d\xc4"
 	"\xe2\xa6\x88\x2f\xb7\xe6\x9e\x85\x23\xa9\xcd\x76\x43\xb9\xfd\xb7",
 	32 },
       { GCRY_MD_BLAKE2S_256,
 	"\x8a\x8a\x14\x9e\xb2\x50\x02\x52\x54\xa6\xfa\xa0\x9a\x3a\xd4\x0e"
 	"\xe3\xf2\xd5\xc7\x9d\x64\x02\x66\x68\xcf\x38\x08\x41\x49\x8a\xd3"
 	"\x5e\x32\x90\xc2\x53\x15\x68\x7e\xe6\x65\x4b\xb0\xfc\xad\xaa\x58"
 	"\x02\x5b\x5e\xb9\x18\xd1\xe9\xbb\xa5\x61\x07\x68\x70\xd9\x49\x22"
 	"\x6b",
 	"\x1b\x9e\x26\x9a\x90\xf8\x73\x51\x73\xbc\x4f\x65\xce\x29\x2c\x61"
 	"\x16\x65\xc7\xb0\x72\x07\xa8\x0b\xfb\x2e\xea\x12\x7d\x97\xcd\x06",
 	65, 32,
 	"\xd5\xd5\xab\x80\x2c\xad\xd9\x86\x60\xe7\x47\x2f\x77\xa6\x1d\xc4"
 	"\xe2\xa6\x88\x2f\xb7\xe6\x9e\x85\x23\xa9\xcd\x76\x43\xb9\xfd\xb7",
 	32 },
       { GCRY_MD_BLAKE2S_256, "!",
 	"\xbe\xc0\xc0\xe6\xcd\xe5\xb6\x7a\xcb\x73\xb8\x1f\x79\xa6\x7a\x40"
 	"\x79\xae\x1c\x60\xda\xc9\xd2\x66\x1a\xf1\x8e\x9f\x8b\x50\xdf\xa5" },
       { GCRY_MD_BLAKE2S_256, "?",
 	"\xdc\x5a\xe7\x1b\xd4\x63\xa1\xf8\x4d\x73\x33\x44\x63\x6b\xa6\x87"
 	"\xe6\xbd\xf4\xba\xed\xc3\xef\xc8\xb3\x86\x55\xbb\x08\x56\x3e\xdb" },
       { GCRY_MD_BLAKE2S_224, "?",
 	"\x2e\x34\x7d\x6b\xcc\x80\xbe\xc3\xf8\x61\x35\x6a\x88\x27\xcd\x84"
 	"\x32\xd4\xd4\x05\xe0\x43\x20\x58\xc7\xb6\xda\xa3" },
       { GCRY_MD_BLAKE2S_160, "?",
 	"\xaa\x83\xe1\xcd\x8d\x4e\x9c\xb7\xf4\x6b\x43\xe1\xbc\x6f\x73\x3b"
 	"\x0e\xfc\x29\xde" },
       { GCRY_MD_BLAKE2S_128, "?",
 	"\x70\x0b\x8a\x71\x1d\x34\x0a\xf0\x13\x93\x19\x93\x5e\xd7\x54\x9c" },
 
       { GCRY_MD_SM3, "abc",
 	"\x66\xc7\xf0\xf4\x62\xee\xed\xd9\xd1\xf2\xd4\x6b\xdc\x10\xe4\xe2"
 	"\x41\x67\xc4\x87\x5c\xf2\xf7\xa2\x29\x7d\xa0\x2b\x8f\x4b\xa8\xe0" },
       { GCRY_MD_SM3,
 	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 	"\x63\x9b\x6c\xc5\xe6\x4d\x9e\x37\xa3\x90\xb1\x92\xdf\x4f\xa1\xea"
 	"\x07\x20\xab\x74\x7f\xf6\x92\xb9\xf3\x8c\x4e\x66\xad\x7b\x8c\x05" },
       { GCRY_MD_SM3, "!",
 	"\xc8\xaa\xf8\x94\x29\x55\x40\x29\xe2\x31\x94\x1a\x2a\xcc\x0a\xd6"
 	"\x1f\xf2\xa5\xac\xd8\xfa\xdd\x25\x84\x7a\x3a\x73\x2b\x3b\x02\xc3" },
       { GCRY_MD_SM3, "?",
 	"\x3a\x3f\x53\xfc\x96\xc2\xde\xb2\xd9\x12\x3a\x1b\xd8\x47\x71\x28"
 	"\xbc\x5d\x5e\x94\xea\x08\x86\x3d\xfb\xe4\x00\x5a\xd9\xed\x79\x26" },
       { GCRY_MD_SM3,
 	"Libgcrypt is free software; you can redistribute it and/or modif"
 	"y it under the terms of the GNU Lesser general Public License as"
 	" published by the Free Software Foundation; either version 2.1 o"
 	"f the License, or (at your option) any later version.\nLibgcrypt"
 	" is distributed in the hope that it will be useful, but WITHOUT "
 	"ANY WARRANTY; without even the implied warranty of MERCHANTABILI"
 	"TY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser Gene"
 	"ral Public License for more details.",
 	"\x8b\x91\x3f\x0e\x85\xae\x43\x25\x6d\x28\x38\x6c\x09\x5c\xc7\x72"
 	"\xcc\x2e\x78\x89\x7e\x2e\x4e\x5a\x3d\xf6\x55\xfe\x87\xbe\xa6\xbc" },
 
       { GCRY_MD_GOSTR3411_CP,
         "*",
         "\x72\xd7\xe3\xbf\xa0\x08\xc9\x62\xae\xa9\xc5\xd8\x93\x5f\x17\xd7"
         "\x3f\xf2\x52\xb4\xc1\x16\xcf\x63\xa4\xcc\x4a\x8c\x7f\xe5\x60\x2c" },
       { GCRY_MD_MD4,
         "*",
         "\xe8\xb9\xe4\x59\x61\x08\xc0\xfe\x54\xef\xc5\x8e\x20\x7c\x9b\x37" },
       { GCRY_MD_MD5,
         "*",
         "\x0b\x1e\xab\xa2\x5e\x48\x76\x92\xae\x16\x12\xde\x5f\xb3\x29\x41" },
       { GCRY_MD_RMD160,
         "*",
         "\x28\xfd\xd6\xa8\x95\x29\x43\x6b\x5e\xd9\xa0\x06\x82\xbb\xe6\x10"
         "\xd3\xcc\x79\x33" },
       { GCRY_MD_SHA1,
         "*",
         "\xd8\x37\x46\x1a\x46\xfe\x42\x11\x7d\x50\xca\xf7\x3d\x7e\x0c\x36"
         "\x42\x0c\x15\xb6" },
       { GCRY_MD_SHA224,
         "*",
         "\x2e\xba\x51\x6c\x71\x5a\x1d\xb8\x6b\x57\xfb\xf1\x46\xa0\xa7\x1d"
         "\x72\x66\xaf\x90\xb8\x01\x18\xc8\x58\x57\xa5\x63" },
       { GCRY_MD_SHA256,
         "*",
         "\x30\xed\xe4\x69\xf3\x1c\x70\x8a\x6d\x92\x00\xac\xd8\x08\x89\xea"
         "\x7e\x92\xff\x02\x0b\x72\x4a\xdf\xa9\x2b\x9f\x80\xba\xd0\x25\xd0" },
       { GCRY_MD_SHA384,
         "*",
         "\x21\xd7\x40\xdf\x34\x13\xcf\x56\xf7\x61\x0a\x1b\x11\xb7\x1e\x01"
         "\x87\xad\xbb\x3e\x9a\xe8\xaa\xaa\xbc\x3a\x89\x39\x0a\xa9\xcb\x4f"
         "\x09\x75\x4c\x44\x59\x42\xf5\x13\x5f\xe5\xa6\x2b\x16\xbe\xfc\xdf" },
       { GCRY_MD_SHA512,
         "*",
         "\x5c\xbe\x01\x03\xbd\x8d\xa1\x38\x5e\x87\x00\x94\x8d\x14\xd0\xb3"
         "\x2c\x88\xeb\xb8\xf6\xcc\x06\x44\x54\xb1\x58\x88\xa9\x67\xa0\xe3"
         "\x0d\x28\x8b\xf4\x2c\xc6\x7a\xdc\x1a\x35\xbf\x0c\xc8\x35\xf0\x24"
         "\x69\xb5\xfe\x15\x6f\x71\xbd\x87\x07\x52\x27\xcc\xdc\x21\x84\x21" },
       { GCRY_MD_SHA3_224,
         "*",
         "\x1a\xa6\x6f\x1a\x3c\x62\x14\x75\xea\x9d\x49\x4d\x39\x01\x2b\xbd"
         "\x4d\xe1\x58\xbc\x32\xac\x48\xcf\x6a\x1a\x54\x34" },
       { GCRY_MD_SHA3_256,
         "*",
         "\x87\xf8\x0e\x78\xc1\x7b\x0c\x36\x4c\xbb\x8d\xca\x5e\x77\xc3\xfd"
         "\x95\xbd\xaf\x94\x85\xc6\x0c\xe6\x22\x52\xeb\x22\x50\x32\x48\x57" },
       { GCRY_MD_SHA3_384,
         "*",
         "\x89\x5a\xd6\xc8\x60\x20\x66\xe7\x9e\xb3\x6d\x5c\x07\xd7\x5e\xd0"
         "\x48\x84\x9d\x51\x75\x14\x77\xdb\xcd\xbf\x70\x18\xdc\x64\x53\x85"
         "\x94\x95\xa5\xd3\x26\x9c\xf1\x63\x14\x8d\x11\xa0\xfc\xd8\x05\x9e" },
       { GCRY_MD_SHA3_512,
         "*",
         "\x53\x0b\x1c\xb7\xff\x2c\xaa\x7e\x62\x15\xa7\x57\x9a\xd0\xcf\x4f"
         "\xa5\xae\xe0\x05\x1c\x77\x0f\x29\x5b\x3f\xba\xab\x88\x0c\x0b\x8e"
         "\x10\xcf\x3d\xa9\x0d\x1e\x97\x98\x96\xeb\x24\x2e\x70\x30\xd0\x78"
         "\x2b\x9e\x30\xad\x5d\xcf\x56\xcf\xd0\xc1\x58\x95\x53\x09\x78\xd6" },
       { GCRY_MD_SM3,
         "*",
         "\xb6\xfc\x1e\xc4\xad\x9b\x88\xbd\x08\xaa\xf3\xb3\xfa\x4f\x1b\x9c"
         "\xd6\x9a\x32\x09\x28\x9e\xda\x3a\x99\xb6\x09\x8f\x35\x99\xa6\x11" },
       { GCRY_MD_STRIBOG256,
         "*",
         "\x35\x0b\xec\x46\x1f\x98\x19\xe7\x33\x12\xda\x9f\xaf\x3d\x32\xa6"
         "\xe4\xa5\x80\x38\x1b\x56\x68\x13\x2d\x0d\xa6\xfd\xfa\xe5\x3d\xf2" },
       { GCRY_MD_STRIBOG512,
         "*",
         "\x01\x4c\xbd\xd4\x3a\x1a\x51\x9e\xa8\x7c\x1f\xd2\xc3\x2e\x71\x78"
         "\x03\x46\xd0\x1b\x30\xdd\x07\xf6\x82\x2b\xa4\x43\x8f\x95\x44\x9d"
         "\x92\x3a\x17\x70\x1b\xdd\xfc\x8f\x71\x20\xc6\xa0\xd8\x6f\xb2\x06"
         "\xb6\x61\x27\x48\x45\x94\x96\xe7\xdc\xf5\x7a\x2f\x83\x82\x03\x08" },
       { GCRY_MD_TIGER1,
         "*",
         "\x95\xe1\x25\x8f\xc5\x4b\x82\x12\x69\x83\xfa\xfd\x79\x7d\x87\x38"
         "\x01\x4f\xf9\x24\xa2\xf0\x8f\x85" },
       { GCRY_MD_WHIRLPOOL,
         "*",
         "\x8e\x02\x8e\x8d\xeb\x03\xcc\x37\xf2\x67\x61\x4e\x16\x27\x06\x13"
         "\x26\x8c\x35\x17\x0c\xab\x3c\x8b\x25\xc3\x3a\x2b\x7d\x54\xbf\xcf"
         "\x7e\xa2\xe4\x4f\x8d\x67\xb7\x85\xfa\x54\x76\x7c\xb0\x24\x87\xd5"
         "\x0e\x7d\x3b\x02\x8f\x30\x9e\x91\x78\xea\xc6\xdc\x0e\xee\x71\xca" },
       { GCRY_MD_CRC24_RFC2440,
         "*",
         "\x44\x53\xd8" },
       { GCRY_MD_CRC32,
         "*",
         "\x96\x11\x46\x4d" },
       { GCRY_MD_TIGER,
         "*",
         "\x12\x82\x4b\xc5\x8f\x25\xe1\x95\x38\x87\x7d\x79\xfd\xfa\x83\x69"
         "\x85\x8f\xf0\xa2\x24\xf9\x4f\x01" },
       { GCRY_MD_TIGER2,
         "*",
         "\xc6\x8f\x98\x71\xee\xb3\x1a\xf6\x77\x50\x8e\x74\x98\x08\x6c\x42"
         "\xc0\x37\x43\xc2\x17\x89\x5f\x98" },
       { GCRY_MD_CRC32_RFC1510,
         "*",
         "\xf4\x45\xfd\x43" },
       { GCRY_MD_BLAKE2B_512,
         "*",
         "\xe0\xf7\x38\x87\x07\xf9\xfd\xeb\x58\x8d\xb9\xb8\xa4\x85\x21\x8e"
         "\x56\xa9\xe6\x8d\x64\x4d\xfb\xe8\x8a\x84\xa4\x45\xc7\x80\x4b\x1f"
         "\x63\x0b\x27\x84\x96\xd4\xeb\x99\x19\xcb\xc6\x37\x01\x42\xb9\x03"
         "\x50\x63\xdf\xb9\x5e\xc5\xb1\xda\x2d\x19\xeb\x65\x73\xd2\xfa\xfa" },
       { GCRY_MD_BLAKE2B_384,
         "*",
         "\x44\xde\xb8\x2b\x46\x22\xe5\xc6\xa5\x66\x8a\x88\x2b\xc3\x2c\x27"
         "\xc1\x4e\x4f\x6b\x70\x96\xcb\x1a\x99\x04\x67\x54\x8a\x0a\x55\xb4"
         "\xdb\x8b\xf6\x36\xfc\x2e\xf6\x2a\x6b\xe2\x1d\x09\x0e\x2f\x65\x33" },
       { GCRY_MD_BLAKE2B_256,
         "*",
         "\x75\xd1\x62\xad\x02\xf1\x3f\xa3\x95\x2f\x5f\x89\x13\x2c\xf4\x2f"
         "\xc3\x84\xd2\x46\xbc\x35\x2b\x13\x01\xe0\x9e\x46\x55\x92\x40\x5a" },
       { GCRY_MD_BLAKE2B_160,
         "*",
         "\x8c\x67\x38\x0e\xf8\xc7\xb6\x3e\x7f\x8e\x32\x73\x8a\xba\xa4\x71"
         "\x87\x9a\xb0\x4c" },
       { GCRY_MD_BLAKE2S_256,
         "*",
         "\x71\x4a\x6d\xe4\xbb\x6c\x9f\x22\xff\x50\x02\xba\x5f\x54\xa6\x39"
         "\x9d\x07\x95\x82\x38\x98\xac\x62\xab\xc6\x13\x12\x65\x64\x9e\x69" },
       { GCRY_MD_BLAKE2S_224,
         "*",
         "\x4c\x01\xe6\x67\xa2\x02\xd1\x62\x9b\xc3\x3b\xb5\x93\xc4\x3c\xa9"
         "\x90\x7b\x96\x70\xfd\xdf\xd1\xc3\xad\x09\xa9\xe7" },
       { GCRY_MD_BLAKE2S_160,
         "*",
         "\x21\xca\x18\x74\x76\x3c\x6b\xe4\x92\x01\xd6\xd5\x91\xd1\x53\xfb"
         "\x37\x73\x99\xb9" },
       { GCRY_MD_BLAKE2S_128,
         "*",
         "\x1d\x87\xfa\x69\xe0\x93\xd9\xcd\xb0\x3c\x52\x00\x35\xe1\xa3\xee" },
       { GCRY_MD_GOSTR3411_94,
         "*",
         "\x6e\xa9\x9e\x23\xde\x5f\x7a\xb7\x7f\xa7\xdc\xe1\xc8\x05\x46\xae"
         "\x1e\x7c\x76\xbb\x52\x0f\x52\x07\x78\x59\xd3\xc1\x64\xdb\x51\xac" },
       { 0 }
     };
   gcry_error_t err;
   int i;
 
   if (verbose)
     fprintf (stderr, "Starting hash checks.\n");
 
   for (i = 0; algos[i].md; i++)
     {
       if (gcry_md_test_algo (algos[i].md))
         {
           show_md_not_available (algos[i].md);
           continue;
         }
       if (gcry_md_test_algo (algos[i].md) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     algos[i].md);
           continue;
         }
 
       if (!strcmp (algos[i].data, "*"))
 	{
 	  if (verbose)
 	    fprintf (stderr, "  checking %s [%i] for final handling\n",
 		    gcry_md_algo_name (algos[i].md),
 		    algos[i].md);
 
 	  check_one_md_final (algos[i].md, algos[i].expect, algos[i].expectlen);
 
 	  continue;
 	}
 
       if (verbose)
 	fprintf (stderr, "  checking %s [%i] for length %d\n",
 		 gcry_md_algo_name (algos[i].md),
 		 algos[i].md,
                  (!strcmp (algos[i].data, "!") || !strcmp (algos[i].data, "?"))?
                  1000000 : (int)strlen(algos[i].data));
 
       check_one_md (algos[i].md, algos[i].data,
 		    algos[i].datalen > 0 ? algos[i].datalen
 					 : strlen (algos[i].data),
 		    algos[i].expect, algos[i].expectlen,
 		    algos[i].key, algos[i].keylen);
 
       if (algos[i].key && algos[i].keylen)
 	continue;
 
       check_one_md_multi (algos[i].md, algos[i].data,
 			  algos[i].datalen > 0 ? algos[i].datalen
 					       : strlen (algos[i].data),
 			  algos[i].expect);
     }
 
   /* Check the Whirlpool bug emulation.  */
   if (!gcry_md_test_algo (GCRY_MD_WHIRLPOOL) && !in_fips_mode)
     {
       static const char expect[] =
         "\x35\x28\xd6\x4c\x56\x2c\x55\x2e\x3b\x91\x93\x95\x7b\xdd\xcc\x6e"
         "\x6f\xb7\xbf\x76\x22\x9c\xc6\x23\xda\x3e\x09\x9b\x36\xe8\x6d\x76"
         "\x2f\x94\x3b\x0c\x63\xa0\xba\xa3\x4d\x66\x71\xe6\x5d\x26\x67\x28"
         "\x36\x1f\x0e\x1a\x40\xf0\xce\x83\x50\x90\x1f\xfa\x3f\xed\x6f\xfd";
       gcry_md_hd_t hd;
       int algo = GCRY_MD_WHIRLPOOL;
       unsigned char *p;
       int mdlen;
 
       err = gcry_md_open (&hd, GCRY_MD_WHIRLPOOL, GCRY_MD_FLAG_BUGEMU1);
       if (err)
         {
           fail ("algo %d, gcry_md_open failed: %s\n", algo, gpg_strerror (err));
           goto leave;
         }
 
       mdlen = gcry_md_get_algo_dlen (algo);
       if (mdlen < 1 || mdlen > 500)
         {
           fail ("algo %d, gcry_md_get_algo_dlen failed: %d\n", algo, mdlen);
           gcry_md_close (hd);
           goto leave;
         }
 
       /* Hash 62 byes in chunks.  */
       gcry_md_write (hd, "1234567890", 10);
       gcry_md_write (hd, "1234567890123456789012345678901234567890123456789012",
                      52);
 
       p = gcry_md_read (hd, algo);
 
       if (memcmp (p, expect, mdlen))
         {
           printf ("computed: ");
           for (i = 0; i < mdlen; i++)
             printf ("%02x ", p[i] & 0xFF);
           printf ("\nexpected: ");
           for (i = 0; i < mdlen; i++)
             printf ("%02x ", expect[i] & 0xFF);
           printf ("\n");
 
           fail ("algo %d, digest mismatch\n", algo);
         }
 
       gcry_md_close (hd);
     }
 
  leave:
   if (verbose)
     fprintf (stderr, "Completed hash checks.\n");
 }
 
 static void
 check_one_hmac (int algo, const char *data, int datalen,
 		const char *key, int keylen, const char *expect)
 {
   gcry_md_hd_t hd, hd2;
   unsigned char *p;
   int mdlen;
   int i;
   gcry_error_t err = 0;
 
   err = gcry_md_open (&hd, algo, GCRY_MD_FLAG_HMAC);
   if (err)
     {
       fail ("algo %d, gcry_md_open failed: %s\n", algo, gpg_strerror (err));
       return;
     }
 
   mdlen = gcry_md_get_algo_dlen (algo);
   if (mdlen < 1 || mdlen > 500)
     {
       fail ("algo %d, gcry_md_get_algo_dlen failed: %d\n", algo, mdlen);
       return;
     }
 
   gcry_md_setkey( hd, key, keylen );
 
   gcry_md_write (hd, data, datalen);
 
   err = gcry_md_copy (&hd2, hd);
   if (err)
     {
       fail ("algo %d, gcry_md_copy failed: %s\n", algo, gpg_strerror (err));
     }
 
   gcry_md_close (hd);
 
   p = gcry_md_read (hd2, algo);
   if (!p)
     fail("algo %d, hmac gcry_md_read failed\n", algo);
 
   if (memcmp (p, expect, mdlen))
     {
       printf ("computed: ");
       for (i = 0; i < mdlen; i++)
 	printf ("%02x ", p[i] & 0xFF);
       printf ("\nexpected: ");
       for (i = 0; i < mdlen; i++)
 	printf ("%02x ", expect[i] & 0xFF);
       printf ("\n");
 
       fail ("algo %d, digest mismatch\n", algo);
     }
 
   gcry_md_close (hd2);
 }
 
 static void
 check_hmac (void)
 {
   static const struct algos
   {
     int md;
     const char *data;
     const char *key;
     const char *expect;
   } algos[] =
     {
       { GCRY_MD_MD5, "what do ya want for nothing?", "Jefe",
 	"\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7\x38" },
       { GCRY_MD_MD5,
 	"Hi There",
 	"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
 	"\x92\x94\x72\x7a\x36\x38\xbb\x1c\x13\xf4\x8e\xf8\x15\x8b\xfc\x9d" },
       { GCRY_MD_MD5,
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd",
 	"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA",
 	"\x56\xbe\x34\x52\x1d\x14\x4c\x88\xdb\xb8\xc7\x33\xf0\xe8\xb3\xf6" },
       { GCRY_MD_MD5,
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd",
 	"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
 	"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
 	"\x69\x7e\xaf\x0a\xca\x3a\x3a\xea\x3a\x75\x16\x47\x46\xff\xaa\x79" },
       { GCRY_MD_MD5, "Test With Truncation",
 	"\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c",
 	"\x56\x46\x1e\xf2\x34\x2e\xdc\x00\xf9\xba\xb9\x95\x69\x0e\xfd\x4c" },
       { GCRY_MD_MD5, "Test Using Larger Than Block-Size Key - Hash Key First",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa",
 	"\x6b\x1a\xb7\xfe\x4b\xd7\xbf\x8f\x0b\x62\xe6\xce\x61\xb9\xd0\xcd" },
       { GCRY_MD_MD5,
 	"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa",
 	"\x6f\x63\x0f\xad\x67\xcd\xa0\xee\x1f\xb1\xf5\x62\xdb\x3a\xa5\x3e", },
       { GCRY_MD_SHA256, "what do ya want for nothing?", "Jefe",
 	"\x5b\xdc\xc1\x46\xbf\x60\x75\x4e\x6a\x04\x24\x26\x08\x95\x75\xc7\x5a"
 	"\x00\x3f\x08\x9d\x27\x39\x83\x9d\xec\x58\xb9\x64\xec\x38\x43" },
       { GCRY_MD_SHA256,
 	"Hi There",
 	"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
 	"\x0b\x0b\x0b",
 	"\xb0\x34\x4c\x61\xd8\xdb\x38\x53\x5c\xa8\xaf\xce\xaf\x0b\xf1\x2b\x88"
 	"\x1d\xc2\x00\xc9\x83\x3d\xa7\x26\xe9\x37\x6c\x2e\x32\xcf\xf7" },
       { GCRY_MD_SHA256,
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd",
 	"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
 	"\xAA\xAA\xAA\xAA",
 	"\x77\x3e\xa9\x1e\x36\x80\x0e\x46\x85\x4d\xb8\xeb\xd0\x91\x81\xa7"
 	"\x29\x59\x09\x8b\x3e\xf8\xc1\x22\xd9\x63\x55\x14\xce\xd5\x65\xfe" },
       { GCRY_MD_SHA256,
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd",
 	"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
 	"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
 	"\x82\x55\x8a\x38\x9a\x44\x3c\x0e\xa4\xcc\x81\x98\x99\xf2\x08"
 	"\x3a\x85\xf0\xfa\xa3\xe5\x78\xf8\x07\x7a\x2e\x3f\xf4\x67\x29\x66\x5b" },
       { GCRY_MD_SHA256,
 	"Test Using Larger Than Block-Size Key - Hash Key First",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\x60\xe4\x31\x59\x1e\xe0\xb6\x7f\x0d\x8a\x26\xaa\xcb\xf5\xb7\x7f"
 	"\x8e\x0b\xc6\x21\x37\x28\xc5\x14\x05\x46\x04\x0f\x0e\xe3\x7f\x54" },
       { GCRY_MD_SHA256,
 	"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.",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\x9b\x09\xff\xa7\x1b\x94\x2f\xcb\x27\x63\x5f\xbc\xd5\xb0\xe9\x44"
 	"\xbf\xdc\x63\x64\x4f\x07\x13\x93\x8a\x7f\x51\x53\x5c\x3a\x35\xe2" },
       { GCRY_MD_SHA224, "what do ya want for nothing?", "Jefe",
 	"\xa3\x0e\x01\x09\x8b\xc6\xdb\xbf\x45\x69\x0f\x3a\x7e\x9e\x6d\x0f"
 	"\x8b\xbe\xa2\xa3\x9e\x61\x48\x00\x8f\xd0\x5e\x44" },
       { GCRY_MD_SHA224,
 	"Hi There",
 	"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
 	"\x0b\x0b\x0b",
 	"\x89\x6f\xb1\x12\x8a\xbb\xdf\x19\x68\x32\x10\x7c\xd4\x9d\xf3\x3f\x47"
 	"\xb4\xb1\x16\x99\x12\xba\x4f\x53\x68\x4b\x22" },
       { GCRY_MD_SHA224,
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd",
 	"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
 	"\xAA\xAA\xAA\xAA",
 	"\x7f\xb3\xcb\x35\x88\xc6\xc1\xf6\xff\xa9\x69\x4d\x7d\x6a\xd2\x64"
 	"\x93\x65\xb0\xc1\xf6\x5d\x69\xd1\xec\x83\x33\xea" },
       { GCRY_MD_SHA224,
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd",
 	"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
 	"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
 	"\x6c\x11\x50\x68\x74\x01\x3c\xac\x6a\x2a\xbc\x1b\xb3\x82\x62"
 	"\x7c\xec\x6a\x90\xd8\x6e\xfc\x01\x2d\xe7\xaf\xec\x5a" },
       { GCRY_MD_SHA224,
 	"Test Using Larger Than Block-Size Key - Hash Key First",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\x95\xe9\xa0\xdb\x96\x20\x95\xad\xae\xbe\x9b\x2d\x6f\x0d\xbc\xe2"
 	"\xd4\x99\xf1\x12\xf2\xd2\xb7\x27\x3f\xa6\x87\x0e" },
       { GCRY_MD_SHA224,
 	"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.",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\x3a\x85\x41\x66\xac\x5d\x9f\x02\x3f\x54\xd5\x17\xd0\xb3\x9d\xbd"
 	"\x94\x67\x70\xdb\x9c\x2b\x95\xc9\xf6\xf5\x65\xd1" },
       { GCRY_MD_SHA384, "what do ya want for nothing?", "Jefe",
 	"\xaf\x45\xd2\xe3\x76\x48\x40\x31\x61\x7f\x78\xd2\xb5\x8a\x6b\x1b"
 	"\x9c\x7e\xf4\x64\xf5\xa0\x1b\x47\xe4\x2e\xc3\x73\x63\x22\x44\x5e"
 	"\x8e\x22\x40\xca\x5e\x69\xe2\xc7\x8b\x32\x39\xec\xfa\xb2\x16\x49" },
       { GCRY_MD_SHA384,
 	"Hi There",
 	"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
 	"\x0b\x0b\x0b",
 	"\xaf\xd0\x39\x44\xd8\x48\x95\x62\x6b\x08\x25\xf4\xab\x46\x90\x7f\x15"
 	"\xf9\xda\xdb\xe4\x10\x1e\xc6\x82\xaa\x03\x4c\x7c\xeb\xc5\x9c\xfa\xea"
 	"\x9e\xa9\x07\x6e\xde\x7f\x4a\xf1\x52\xe8\xb2\xfa\x9c\xb6" },
       { GCRY_MD_SHA384,
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd",
 	"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
 	"\xAA\xAA\xAA\xAA",
 	"\x88\x06\x26\x08\xd3\xe6\xad\x8a\x0a\xa2\xac\xe0\x14\xc8\xa8\x6f"
 	"\x0a\xa6\x35\xd9\x47\xac\x9f\xeb\xe8\x3e\xf4\xe5\x59\x66\x14\x4b"
 	"\x2a\x5a\xb3\x9d\xc1\x38\x14\xb9\x4e\x3a\xb6\xe1\x01\xa3\x4f\x27" },
       { GCRY_MD_SHA384,
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd",
 	"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
 	"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
 	"\x3e\x8a\x69\xb7\x78\x3c\x25\x85\x19\x33\xab\x62\x90\xaf\x6c\xa7"
 	"\x7a\x99\x81\x48\x08\x50\x00\x9c\xc5\x57\x7c\x6e\x1f\x57\x3b\x4e"
 	"\x68\x01\xdd\x23\xc4\xa7\xd6\x79\xcc\xf8\xa3\x86\xc6\x74\xcf\xfb" },
       { GCRY_MD_SHA384,
 	"Test Using Larger Than Block-Size Key - Hash Key First",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\x4e\xce\x08\x44\x85\x81\x3e\x90\x88\xd2\xc6\x3a\x04\x1b\xc5\xb4"
 	"\x4f\x9e\xf1\x01\x2a\x2b\x58\x8f\x3c\xd1\x1f\x05\x03\x3a\xc4\xc6"
 	"\x0c\x2e\xf6\xab\x40\x30\xfe\x82\x96\x24\x8d\xf1\x63\xf4\x49\x52" },
       { GCRY_MD_SHA384,
 	"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.",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\x66\x17\x17\x8e\x94\x1f\x02\x0d\x35\x1e\x2f\x25\x4e\x8f\xd3\x2c"
 	"\x60\x24\x20\xfe\xb0\xb8\xfb\x9a\xdc\xce\xbb\x82\x46\x1e\x99\xc5"
 	"\xa6\x78\xcc\x31\xe7\x99\x17\x6d\x38\x60\xe6\x11\x0c\x46\x52\x3e" },
       { GCRY_MD_SHA512, "what do ya want for nothing?", "Jefe",
 	"\x16\x4b\x7a\x7b\xfc\xf8\x19\xe2\xe3\x95\xfb\xe7\x3b\x56\xe0\xa3"
 	"\x87\xbd\x64\x22\x2e\x83\x1f\xd6\x10\x27\x0c\xd7\xea\x25\x05\x54"
 	"\x97\x58\xbf\x75\xc0\x5a\x99\x4a\x6d\x03\x4f\x65\xf8\xf0\xe6\xfd"
 	"\xca\xea\xb1\xa3\x4d\x4a\x6b\x4b\x63\x6e\x07\x0a\x38\xbc\xe7\x37" },
       { GCRY_MD_SHA512,
 	"Hi There",
 	"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
 	"\x0b\x0b\x0b",
 	"\x87\xaa\x7c\xde\xa5\xef\x61\x9d\x4f\xf0\xb4\x24\x1a\x1d\x6c\xb0"
 	"\x23\x79\xf4\xe2\xce\x4e\xc2\x78\x7a\xd0\xb3\x05\x45\xe1\x7c\xde"
 	"\xda\xa8\x33\xb7\xd6\xb8\xa7\x02\x03\x8b\x27\x4e\xae\xa3\xf4\xe4"
 	"\xbe\x9d\x91\x4e\xeb\x61\xf1\x70\x2e\x69\x6c\x20\x3a\x12\x68\x54" },
       { GCRY_MD_SHA512,
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
 	"\xdd\xdd\xdd\xdd\xdd",
 	"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
 	"\xAA\xAA\xAA\xAA",
 	"\xfa\x73\xb0\x08\x9d\x56\xa2\x84\xef\xb0\xf0\x75\x6c\x89\x0b\xe9"
 	"\xb1\xb5\xdb\xdd\x8e\xe8\x1a\x36\x55\xf8\x3e\x33\xb2\x27\x9d\x39"
 	"\xbf\x3e\x84\x82\x79\xa7\x22\xc8\x06\xb4\x85\xa4\x7e\x67\xc8\x07"
 	"\xb9\x46\xa3\x37\xbe\xe8\x94\x26\x74\x27\x88\x59\xe1\x32\x92\xfb"  },
       { GCRY_MD_SHA512,
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
 	"\xcd\xcd\xcd\xcd\xcd",
 	"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
 	"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
 	"\xb0\xba\x46\x56\x37\x45\x8c\x69\x90\xe5\xa8\xc5\xf6\x1d\x4a\xf7"
 	"\xe5\x76\xd9\x7f\xf9\x4b\x87\x2d\xe7\x6f\x80\x50\x36\x1e\xe3\xdb"
 	"\xa9\x1c\xa5\xc1\x1a\xa2\x5e\xb4\xd6\x79\x27\x5c\xc5\x78\x80\x63"
 	"\xa5\xf1\x97\x41\x12\x0c\x4f\x2d\xe2\xad\xeb\xeb\x10\xa2\x98\xdd" },
       { GCRY_MD_SHA512,
 	"Test Using Larger Than Block-Size Key - Hash Key First",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\x80\xb2\x42\x63\xc7\xc1\xa3\xeb\xb7\x14\x93\xc1\xdd\x7b\xe8\xb4"
 	"\x9b\x46\xd1\xf4\x1b\x4a\xee\xc1\x12\x1b\x01\x37\x83\xf8\xf3\x52"
 	"\x6b\x56\xd0\x37\xe0\x5f\x25\x98\xbd\x0f\xd2\x21\x5d\x6a\x1e\x52"
 	"\x95\xe6\x4f\x73\xf6\x3f\x0a\xec\x8b\x91\x5a\x98\x5d\x78\x65\x98" },
       { GCRY_MD_SHA512,
 	"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.",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\xe3\x7b\x6a\x77\x5d\xc8\x7d\xba\xa4\xdf\xa9\xf9\x6e\x5e\x3f\xfd"
 	"\xde\xbd\x71\xf8\x86\x72\x89\x86\x5d\xf5\xa3\x2d\x20\xcd\xc9\x44"
 	"\xb6\x02\x2c\xac\x3c\x49\x82\xb1\x0d\x5e\xeb\x55\xc3\xe4\xde\x15"
 	"\x13\x46\x76\xfb\x6d\xe0\x44\x60\x65\xc9\x74\x40\xfa\x8c\x6a\x58" },
       {	0 },
     };
   int i;
 
   if (verbose)
     fprintf (stderr, "Starting hashed MAC checks.\n");
 
   for (i = 0; algos[i].md; i++)
     {
       if (gcry_md_test_algo (algos[i].md))
         {
           show_old_hmac_not_available (algos[i].md);
           continue;
         }
       if (gcry_md_test_algo (algos[i].md) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     algos[i].md);
           continue;
         }
       if (verbose)
 	fprintf (stderr,
                  "  checking %s [%i] for %d byte key and %d byte data\n",
 		 gcry_md_algo_name (algos[i].md),
 		 algos[i].md,
 		 (int)strlen(algos[i].key), (int)strlen(algos[i].data));
 
       check_one_hmac (algos[i].md, algos[i].data, strlen (algos[i].data),
 		      algos[i].key, strlen(algos[i].key),
 		      algos[i].expect);
     }
 
   if (verbose)
     fprintf (stderr, "Completed hashed MAC checks.\n");
 }
 
 
 static void
 check_one_mac (int algo, const char *data, int datalen,
 	       const char *key, int keylen, const char *iv, int ivlen,
 	       const char *expect, int test_buffering)
 {
   gcry_mac_hd_t hd;
   unsigned char *p;
   unsigned int maclen;
   size_t macoutlen;
   int i;
   gcry_error_t err = 0;
 
   if (test_buffering)
     {
       if ((*data == '!' && !data[1]) ||
           (*data == '?' && !data[1]))
         {
           return; /* Skip. */
         }
     }
 
   err = gcry_mac_open (&hd, algo, 0, NULL);
   if (err)
     {
       fail ("algo %d, gcry_mac_open failed: %s\n", algo, gpg_strerror (err));
       return;
     }
 
   i = gcry_mac_get_algo (hd);
   if (i != algo)
     {
       fail ("algo %d, gcry_mac_get_algo failed: %d\n", algo, i);
     }
 
   maclen = gcry_mac_get_algo_maclen (algo);
   if (maclen < 1 || maclen > 500)
     {
       fail ("algo %d, gcry_mac_get_algo_maclen failed: %d\n", algo, maclen);
       return;
     }
 
   p = malloc(maclen);
   if (!p)
     {
       fail ("algo %d, could not malloc %d bytes\n", algo, maclen);
       return;
     }
 
   err = gcry_mac_setkey (hd, key, keylen);
   if (err)
     fail("algo %d, mac gcry_mac_setkey failed: %s\n", algo, gpg_strerror (err));
   if (err)
     goto out;
 
   if (ivlen && iv)
     {
       err = gcry_mac_setiv (hd, iv, ivlen);
       if (err)
         fail("algo %d, mac gcry_mac_ivkey failed: %s\n", algo,
              gpg_strerror (err));
       if (err)
         goto out;
     }
 
   if (test_buffering)
     {
       for (i = 0; i < datalen; i++)
         {
           err = gcry_mac_write (hd, &data[i], 1);
           if (err)
             fail("algo %d, mac gcry_mac_write [buf-offset: %d] failed: %s\n",
                  algo, i, gpg_strerror (err));
           if (err)
             goto out;
         }
     }
   else
     {
       if ((*data == '!' && !data[1]) || /* hash one million times a "a" */
           (*data == '?' && !data[1]))   /* hash million byte data-set with byte pattern 0x00,0x01,0x02,... */
         {
           char aaa[1000];
           size_t left = 1000 * 1000;
           size_t startlen = 1;
           size_t piecelen = startlen;
 
           if (*data == '!')
             memset (aaa, 'a', 1000);
 
           /* Write in chuck with all sizes 1 to 1000 (500500 bytes)  */
           for (i = 1; i <= 1000 && left > 0; i++)
             {
               piecelen = i;
               if (piecelen > sizeof(aaa))
                 piecelen = sizeof(aaa);
               if (piecelen > left)
                 piecelen = left;
 
               if (*data == '?')
                 fillbuf_count(aaa, piecelen, 1000 * 1000 - left);
 
               gcry_mac_write (hd, aaa, piecelen);
 
               left -= piecelen;
             }
 
           /* Write in odd size chunks so that we test the buffering.  */
           while (left > 0)
             {
               if (piecelen > sizeof(aaa))
                 piecelen = sizeof(aaa);
               if (piecelen > left)
                 piecelen = left;
 
               if (*data == '?')
                 fillbuf_count(aaa, piecelen, 1000 * 1000 - left);
 
               gcry_mac_write (hd, aaa, piecelen);
 
               left -= piecelen;
 
               if (piecelen == sizeof(aaa))
                 piecelen = ++startlen;
               else
                 piecelen = piecelen * 2 - ((piecelen != startlen) ? startlen : 0);
             }
         }
       else
         {
           err = gcry_mac_write (hd, data, datalen);
         }
 
       if (err)
         fail("algo %d, mac gcry_mac_write failed: %s\n", algo, gpg_strerror (err));
       if (err)
         goto out;
     }
 
   err = gcry_mac_verify (hd, expect, maclen);
   if (err)
     fail("algo %d, mac gcry_mac_verify failed: %s\n", algo, gpg_strerror (err));
 
   macoutlen = maclen;
   err = gcry_mac_read (hd, p, &macoutlen);
   if (err)
     fail("algo %d, mac gcry_mac_read failed: %s\n", algo, gpg_strerror (err));
   if (err)
     goto out;
 
   if (memcmp (p, expect, maclen))
     {
       printf ("computed: ");
       for (i = 0; i < maclen; i++)
 	printf ("%02x ", p[i] & 0xFF);
       printf ("\nexpected: ");
       for (i = 0; i < maclen; i++)
 	printf ("%02x ", expect[i] & 0xFF);
       printf ("\n");
 
       fail ("algo %d, digest mismatch\n", algo);
     }
   if (err)
     goto out;
 
 out:
   free (p);
   gcry_mac_close (hd);
 }
 
 static void
 check_mac (void)
 {
   static const struct algos
   {
     int algo;
     const char *data;
     const char *key;
     const char *expect;
     const char *iv;
     unsigned int dlen;
     unsigned int klen;
   } algos[] =
     {
       { GCRY_MAC_HMAC_MD5, "what do ya want for nothing?", "Jefe",
         "\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7\x38" },
       { GCRY_MAC_HMAC_MD5,
         "Hi There",
         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
         "\x92\x94\x72\x7a\x36\x38\xbb\x1c\x13\xf4\x8e\xf8\x15\x8b\xfc\x9d" },
       { GCRY_MAC_HMAC_MD5,
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd",
         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA",
         "\x56\xbe\x34\x52\x1d\x14\x4c\x88\xdb\xb8\xc7\x33\xf0\xe8\xb3\xf6" },
       { GCRY_MAC_HMAC_MD5,
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd",
         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
         "\x69\x7e\xaf\x0a\xca\x3a\x3a\xea\x3a\x75\x16\x47\x46\xff\xaa\x79" },
       { GCRY_MAC_HMAC_MD5, "Test With Truncation",
         "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c",
         "\x56\x46\x1e\xf2\x34\x2e\xdc\x00\xf9\xba\xb9\x95\x69\x0e\xfd\x4c" },
       { GCRY_MAC_HMAC_MD5, "Test Using Larger Than Block-Size Key - Hash Key First",
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa",
         "\x6b\x1a\xb7\xfe\x4b\xd7\xbf\x8f\x0b\x62\xe6\xce\x61\xb9\xd0\xcd" },
       { GCRY_MAC_HMAC_MD5,
         "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa",
         "\x6f\x63\x0f\xad\x67\xcd\xa0\xee\x1f\xb1\xf5\x62\xdb\x3a\xa5\x3e", },
       { GCRY_MAC_HMAC_MD5, "?", "????????????????",
         "\x7e\x28\xf8\x8e\xf4\x6c\x48\x30\xa2\x0c\xe3\xe1\x42\xd4\xb5\x6b" },
       { GCRY_MAC_HMAC_SHA256, "what do ya want for nothing?", "Jefe",
         "\x5b\xdc\xc1\x46\xbf\x60\x75\x4e\x6a\x04\x24\x26\x08\x95\x75\xc7\x5a"
         "\x00\x3f\x08\x9d\x27\x39\x83\x9d\xec\x58\xb9\x64\xec\x38\x43" },
       { GCRY_MAC_HMAC_SHA256,
         "Hi There",
         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
         "\x0b\x0b\x0b",
         "\xb0\x34\x4c\x61\xd8\xdb\x38\x53\x5c\xa8\xaf\xce\xaf\x0b\xf1\x2b\x88"
         "\x1d\xc2\x00\xc9\x83\x3d\xa7\x26\xe9\x37\x6c\x2e\x32\xcf\xf7" },
       { GCRY_MAC_HMAC_SHA256,
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd",
         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
         "\xAA\xAA\xAA\xAA",
         "\x77\x3e\xa9\x1e\x36\x80\x0e\x46\x85\x4d\xb8\xeb\xd0\x91\x81\xa7"
         "\x29\x59\x09\x8b\x3e\xf8\xc1\x22\xd9\x63\x55\x14\xce\xd5\x65\xfe" },
       { GCRY_MAC_HMAC_SHA256,
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd",
         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
         "\x82\x55\x8a\x38\x9a\x44\x3c\x0e\xa4\xcc\x81\x98\x99\xf2\x08"
         "\x3a\x85\xf0\xfa\xa3\xe5\x78\xf8\x07\x7a\x2e\x3f\xf4\x67\x29\x66\x5b" },
       { GCRY_MAC_HMAC_SHA256,
         "Test Using Larger Than Block-Size Key - Hash Key First",
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa",
         "\x60\xe4\x31\x59\x1e\xe0\xb6\x7f\x0d\x8a\x26\xaa\xcb\xf5\xb7\x7f"
         "\x8e\x0b\xc6\x21\x37\x28\xc5\x14\x05\x46\x04\x0f\x0e\xe3\x7f\x54" },
       { GCRY_MAC_HMAC_SHA256,
         "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.",
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa",
         "\x9b\x09\xff\xa7\x1b\x94\x2f\xcb\x27\x63\x5f\xbc\xd5\xb0\xe9\x44"
         "\xbf\xdc\x63\x64\x4f\x07\x13\x93\x8a\x7f\x51\x53\x5c\x3a\x35\xe2" },
       { GCRY_MAC_HMAC_SHA256, "?", "????????????????",
         "\x1c\x0e\x57\xad\x4a\x02\xd2\x30\xce\x7e\xf8\x08\x23\x25\x71\x5e"
         "\x16\x9b\x30\xca\xc3\xf4\x99\xc5\x1d\x4c\x25\x32\xa9\xf2\x15\x28" },
       { GCRY_MAC_HMAC_SHA224, "what do ya want for nothing?", "Jefe",
         "\xa3\x0e\x01\x09\x8b\xc6\xdb\xbf\x45\x69\x0f\x3a\x7e\x9e\x6d\x0f"
         "\x8b\xbe\xa2\xa3\x9e\x61\x48\x00\x8f\xd0\x5e\x44" },
       { GCRY_MAC_HMAC_SHA224,
         "Hi There",
         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
         "\x0b\x0b\x0b",
         "\x89\x6f\xb1\x12\x8a\xbb\xdf\x19\x68\x32\x10\x7c\xd4\x9d\xf3\x3f\x47"
         "\xb4\xb1\x16\x99\x12\xba\x4f\x53\x68\x4b\x22" },
       { GCRY_MAC_HMAC_SHA224,
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd",
         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
         "\xAA\xAA\xAA\xAA",
         "\x7f\xb3\xcb\x35\x88\xc6\xc1\xf6\xff\xa9\x69\x4d\x7d\x6a\xd2\x64"
         "\x93\x65\xb0\xc1\xf6\x5d\x69\xd1\xec\x83\x33\xea" },
       { GCRY_MAC_HMAC_SHA224,
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd",
         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
         "\x6c\x11\x50\x68\x74\x01\x3c\xac\x6a\x2a\xbc\x1b\xb3\x82\x62"
         "\x7c\xec\x6a\x90\xd8\x6e\xfc\x01\x2d\xe7\xaf\xec\x5a" },
       { GCRY_MAC_HMAC_SHA224,
         "Test Using Larger Than Block-Size Key - Hash Key First",
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa",
         "\x95\xe9\xa0\xdb\x96\x20\x95\xad\xae\xbe\x9b\x2d\x6f\x0d\xbc\xe2"
         "\xd4\x99\xf1\x12\xf2\xd2\xb7\x27\x3f\xa6\x87\x0e" },
       { GCRY_MAC_HMAC_SHA224,
         "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.",
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa",
         "\x3a\x85\x41\x66\xac\x5d\x9f\x02\x3f\x54\xd5\x17\xd0\xb3\x9d\xbd"
         "\x94\x67\x70\xdb\x9c\x2b\x95\xc9\xf6\xf5\x65\xd1" },
       { GCRY_MAC_HMAC_SHA224, "?", "????????????????",
         "\xc1\x88\xaf\xcf\xce\x51\xa2\x14\x3d\xc1\xaf\x93\xcc\x2b\xe9\x4d"
         "\x39\x55\x90\x4c\x46\x70\xfc\xc2\x04\xcf\xab\xfa" },
       { GCRY_MAC_HMAC_SHA384, "what do ya want for nothing?", "Jefe",
         "\xaf\x45\xd2\xe3\x76\x48\x40\x31\x61\x7f\x78\xd2\xb5\x8a\x6b\x1b"
         "\x9c\x7e\xf4\x64\xf5\xa0\x1b\x47\xe4\x2e\xc3\x73\x63\x22\x44\x5e"
         "\x8e\x22\x40\xca\x5e\x69\xe2\xc7\x8b\x32\x39\xec\xfa\xb2\x16\x49" },
       { GCRY_MAC_HMAC_SHA384,
         "Hi There",
         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
         "\x0b\x0b\x0b",
         "\xaf\xd0\x39\x44\xd8\x48\x95\x62\x6b\x08\x25\xf4\xab\x46\x90\x7f\x15"
         "\xf9\xda\xdb\xe4\x10\x1e\xc6\x82\xaa\x03\x4c\x7c\xeb\xc5\x9c\xfa\xea"
         "\x9e\xa9\x07\x6e\xde\x7f\x4a\xf1\x52\xe8\xb2\xfa\x9c\xb6" },
       { GCRY_MAC_HMAC_SHA384,
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd",
         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
         "\xAA\xAA\xAA\xAA",
         "\x88\x06\x26\x08\xd3\xe6\xad\x8a\x0a\xa2\xac\xe0\x14\xc8\xa8\x6f"
         "\x0a\xa6\x35\xd9\x47\xac\x9f\xeb\xe8\x3e\xf4\xe5\x59\x66\x14\x4b"
         "\x2a\x5a\xb3\x9d\xc1\x38\x14\xb9\x4e\x3a\xb6\xe1\x01\xa3\x4f\x27" },
       { GCRY_MAC_HMAC_SHA384,
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd",
         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
         "\x3e\x8a\x69\xb7\x78\x3c\x25\x85\x19\x33\xab\x62\x90\xaf\x6c\xa7"
         "\x7a\x99\x81\x48\x08\x50\x00\x9c\xc5\x57\x7c\x6e\x1f\x57\x3b\x4e"
         "\x68\x01\xdd\x23\xc4\xa7\xd6\x79\xcc\xf8\xa3\x86\xc6\x74\xcf\xfb" },
       { GCRY_MAC_HMAC_SHA384,
         "Test Using Larger Than Block-Size Key - Hash Key First",
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa",
         "\x4e\xce\x08\x44\x85\x81\x3e\x90\x88\xd2\xc6\x3a\x04\x1b\xc5\xb4"
         "\x4f\x9e\xf1\x01\x2a\x2b\x58\x8f\x3c\xd1\x1f\x05\x03\x3a\xc4\xc6"
         "\x0c\x2e\xf6\xab\x40\x30\xfe\x82\x96\x24\x8d\xf1\x63\xf4\x49\x52" },
       { GCRY_MAC_HMAC_SHA384,
         "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.",
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa",
         "\x66\x17\x17\x8e\x94\x1f\x02\x0d\x35\x1e\x2f\x25\x4e\x8f\xd3\x2c"
         "\x60\x24\x20\xfe\xb0\xb8\xfb\x9a\xdc\xce\xbb\x82\x46\x1e\x99\xc5"
         "\xa6\x78\xcc\x31\xe7\x99\x17\x6d\x38\x60\xe6\x11\x0c\x46\x52\x3e" },
       { GCRY_MAC_HMAC_SHA384, "?", "????????????????",
         "\xe7\x96\x29\xa3\x40\x5f\x1e\x6e\x92\xa5\xdb\xa5\xc6\xe9\x60\xa8"
         "\xf5\xd1\x6d\xcb\x10\xec\x30\x2f\x6b\x9c\x37\xe0\xea\xf1\x53\x28"
         "\x08\x01\x9b\xe3\x4a\x43\xc6\xc2\x2b\x0c\xd9\x43\x64\x35\x25\x78" },
       { GCRY_MAC_HMAC_SHA512, "what do ya want for nothing?", "Jefe",
         "\x16\x4b\x7a\x7b\xfc\xf8\x19\xe2\xe3\x95\xfb\xe7\x3b\x56\xe0\xa3"
         "\x87\xbd\x64\x22\x2e\x83\x1f\xd6\x10\x27\x0c\xd7\xea\x25\x05\x54"
         "\x97\x58\xbf\x75\xc0\x5a\x99\x4a\x6d\x03\x4f\x65\xf8\xf0\xe6\xfd"
         "\xca\xea\xb1\xa3\x4d\x4a\x6b\x4b\x63\x6e\x07\x0a\x38\xbc\xe7\x37" },
       { GCRY_MAC_HMAC_SHA512,
         "Hi There",
         "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
         "\x0b\x0b\x0b",
         "\x87\xaa\x7c\xde\xa5\xef\x61\x9d\x4f\xf0\xb4\x24\x1a\x1d\x6c\xb0"
         "\x23\x79\xf4\xe2\xce\x4e\xc2\x78\x7a\xd0\xb3\x05\x45\xe1\x7c\xde"
         "\xda\xa8\x33\xb7\xd6\xb8\xa7\x02\x03\x8b\x27\x4e\xae\xa3\xf4\xe4"
         "\xbe\x9d\x91\x4e\xeb\x61\xf1\x70\x2e\x69\x6c\x20\x3a\x12\x68\x54" },
       { GCRY_MAC_HMAC_SHA512,
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
         "\xdd\xdd\xdd\xdd\xdd",
         "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
         "\xAA\xAA\xAA\xAA",
         "\xfa\x73\xb0\x08\x9d\x56\xa2\x84\xef\xb0\xf0\x75\x6c\x89\x0b\xe9"
         "\xb1\xb5\xdb\xdd\x8e\xe8\x1a\x36\x55\xf8\x3e\x33\xb2\x27\x9d\x39"
         "\xbf\x3e\x84\x82\x79\xa7\x22\xc8\x06\xb4\x85\xa4\x7e\x67\xc8\x07"
         "\xb9\x46\xa3\x37\xbe\xe8\x94\x26\x74\x27\x88\x59\xe1\x32\x92\xfb"  },
       { GCRY_MAC_HMAC_SHA512,
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
         "\xcd\xcd\xcd\xcd\xcd",
         "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
         "\xb0\xba\x46\x56\x37\x45\x8c\x69\x90\xe5\xa8\xc5\xf6\x1d\x4a\xf7"
         "\xe5\x76\xd9\x7f\xf9\x4b\x87\x2d\xe7\x6f\x80\x50\x36\x1e\xe3\xdb"
         "\xa9\x1c\xa5\xc1\x1a\xa2\x5e\xb4\xd6\x79\x27\x5c\xc5\x78\x80\x63"
         "\xa5\xf1\x97\x41\x12\x0c\x4f\x2d\xe2\xad\xeb\xeb\x10\xa2\x98\xdd" },
       { GCRY_MAC_HMAC_SHA512,
         "Test Using Larger Than Block-Size Key - Hash Key First",
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa",
         "\x80\xb2\x42\x63\xc7\xc1\xa3\xeb\xb7\x14\x93\xc1\xdd\x7b\xe8\xb4"
         "\x9b\x46\xd1\xf4\x1b\x4a\xee\xc1\x12\x1b\x01\x37\x83\xf8\xf3\x52"
         "\x6b\x56\xd0\x37\xe0\x5f\x25\x98\xbd\x0f\xd2\x21\x5d\x6a\x1e\x52"
         "\x95\xe6\x4f\x73\xf6\x3f\x0a\xec\x8b\x91\x5a\x98\x5d\x78\x65\x98" },
       { GCRY_MAC_HMAC_SHA512,
         "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.",
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
         "\xaa\xaa\xaa",
         "\xe3\x7b\x6a\x77\x5d\xc8\x7d\xba\xa4\xdf\xa9\xf9\x6e\x5e\x3f\xfd"
         "\xde\xbd\x71\xf8\x86\x72\x89\x86\x5d\xf5\xa3\x2d\x20\xcd\xc9\x44"
         "\xb6\x02\x2c\xac\x3c\x49\x82\xb1\x0d\x5e\xeb\x55\xc3\xe4\xde\x15"
         "\x13\x46\x76\xfb\x6d\xe0\x44\x60\x65\xc9\x74\x40\xfa\x8c\x6a\x58" },
       { GCRY_MAC_HMAC_SHA512, "?", "????????????????",
         "\xd4\x43\x61\xfa\x3d\x3d\x57\xd6\xac\xc3\x9f\x1c\x3d\xd9\x26\x84"
         "\x1f\xfc\x4d\xf2\xbf\x78\x87\x72\x5e\x6c\x3e\x00\x6d\x39\x5f\xfa"
         "\xd7\x3a\xf7\x83\xb7\xb5\x61\xbd\xfb\x33\xe0\x03\x97\xa7\x72\x79"
         "\x66\x66\xbf\xbd\x44\xfa\x04\x01\x1b\xc1\x48\x1d\x9e\xde\x5b\x8e" },
       /* HMAC-SHA3 test vectors from
        * http://wolfgang-ehrhardt.de/hmac-sha3-testvectors.html */
       { GCRY_MAC_HMAC_SHA3_224,
 	"Hi There",
 	"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
 	"\x0b\x0b\x0b",
 	"\x3b\x16\x54\x6b\xbc\x7b\xe2\x70\x6a\x03\x1d\xca\xfd\x56\x37\x3d"
 	"\x98\x84\x36\x76\x41\xd8\xc5\x9a\xf3\xc8\x60\xf7" },
       { GCRY_MAC_HMAC_SHA3_256,
 	"Hi There",
 	"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
 	"\x0b\x0b\x0b",
 	"\xba\x85\x19\x23\x10\xdf\xfa\x96\xe2\xa3\xa4\x0e\x69\x77\x43\x51"
 	"\x14\x0b\xb7\x18\x5e\x12\x02\xcd\xcc\x91\x75\x89\xf9\x5e\x16\xbb" },
       { GCRY_MAC_HMAC_SHA3_512,
 	"Hi There",
 	"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
 	"\x0b\x0b\x0b",
 	"\xeb\x3f\xbd\x4b\x2e\xaa\xb8\xf5\xc5\x04\xbd\x3a\x41\x46\x5a\xac"
 	"\xec\x15\x77\x0a\x7c\xab\xac\x53\x1e\x48\x2f\x86\x0b\x5e\xc7\xba"
 	"\x47\xcc\xb2\xc6\xf2\xaf\xce\x8f\x88\xd2\x2b\x6d\xc6\x13\x80\xf2"
 	"\x3a\x66\x8f\xd3\x88\x8b\xb8\x05\x37\xc0\xa0\xb8\x64\x07\x68\x9e" },
       { GCRY_MAC_HMAC_SHA3_224, "what do ya want for nothing?", "Jefe",
 	"\x7f\xdb\x8d\xd8\x8b\xd2\xf6\x0d\x1b\x79\x86\x34\xad\x38\x68\x11"
 	"\xc2\xcf\xc8\x5b\xfa\xf5\xd5\x2b\xba\xce\x5e\x66" },
       { GCRY_MAC_HMAC_SHA3_256, "what do ya want for nothing?", "Jefe",
 	"\xc7\xd4\x07\x2e\x78\x88\x77\xae\x35\x96\xbb\xb0\xda\x73\xb8\x87"
 	"\xc9\x17\x1f\x93\x09\x5b\x29\x4a\xe8\x57\xfb\xe2\x64\x5e\x1b\xa5" },
       { GCRY_MAC_HMAC_SHA3_384, "what do ya want for nothing?", "Jefe",
 	"\xf1\x10\x1f\x8c\xbf\x97\x66\xfd\x67\x64\xd2\xed\x61\x90\x3f\x21"
 	"\xca\x9b\x18\xf5\x7c\xf3\xe1\xa2\x3c\xa1\x35\x08\xa9\x32\x43\xce"
 	"\x48\xc0\x45\xdc\x00\x7f\x26\xa2\x1b\x3f\x5e\x0e\x9d\xf4\xc2\x0a" },
       { GCRY_MAC_HMAC_SHA3_512, "what do ya want for nothing?", "Jefe",
 	"\x5a\x4b\xfe\xab\x61\x66\x42\x7c\x7a\x36\x47\xb7\x47\x29\x2b\x83"
 	"\x84\x53\x7c\xdb\x89\xaf\xb3\xbf\x56\x65\xe4\xc5\xe7\x09\x35\x0b"
 	"\x28\x7b\xae\xc9\x21\xfd\x7c\xa0\xee\x7a\x0c\x31\xd0\x22\xa9\x5e"
 	"\x1f\xc9\x2b\xa9\xd7\x7d\xf8\x83\x96\x02\x75\xbe\xb4\xe6\x20\x24" },
       { GCRY_MAC_HMAC_SHA3_224,
 	"Test Using Larger Than Block-Size Key - Hash Key First",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\xb9\x6d\x73\x0c\x14\x8c\x2d\xaa\xd8\x64\x9d\x83\xde\xfa\xa3\x71"
 	"\x97\x38\xd3\x47\x75\x39\x7b\x75\x71\xc3\x85\x15" },
       { GCRY_MAC_HMAC_SHA3_256,
 	"Test Using Larger Than Block-Size Key - Hash Key First",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\xa6\x07\x2f\x86\xde\x52\xb3\x8b\xb3\x49\xfe\x84\xcd\x6d\x97\xfb"
 	"\x6a\x37\xc4\xc0\xf6\x2a\xae\x93\x98\x11\x93\xa7\x22\x9d\x34\x67" },
       { GCRY_MAC_HMAC_SHA3_384,
 	"Test Using Larger Than Block-Size Key - Hash Key First",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\x71\x3d\xff\x03\x02\xc8\x50\x86\xec\x5a\xd0\x76\x8d\xd6\x5a\x13"
 	"\xdd\xd7\x90\x68\xd8\xd4\xc6\x21\x2b\x71\x2e\x41\x64\x94\x49\x11"
 	"\x14\x80\x23\x00\x44\x18\x5a\x99\x10\x3e\xd8\x20\x04\xdd\xbf\xcc" },
       { GCRY_MAC_HMAC_SHA3_512,
 	"Test Using Larger Than Block-Size Key - Hash Key First",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\xb1\x48\x35\xc8\x19\xa2\x90\xef\xb0\x10\xac\xe6\xd8\x56\x8d\xc6"
 	"\xb8\x4d\xe6\x0b\xc4\x9b\x00\x4c\x3b\x13\xed\xa7\x63\x58\x94\x51"
 	"\xe5\xdd\x74\x29\x28\x84\xd1\xbd\xce\x64\xe6\xb9\x19\xdd\x61\xdc"
 	"\x9c\x56\xa2\x82\xa8\x1c\x0b\xd1\x4f\x1f\x36\x5b\x49\xb8\x3a\x5b" },
       { GCRY_MAC_HMAC_SHA3_224,
 	"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.",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\xc7\x9c\x9b\x09\x34\x24\xe5\x88\xa9\x87\x8b\xbc\xb0\x89\xe0\x18"
 	"\x27\x00\x96\xe9\xb4\xb1\xa9\xe8\x22\x0c\x86\x6a" },
       { GCRY_MAC_HMAC_SHA3_256,
 	"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.",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\xe6\xa3\x6d\x9b\x91\x5f\x86\xa0\x93\xca\xc7\xd1\x10\xe9\xe0\x4c"
 	"\xf1\xd6\x10\x0d\x30\x47\x55\x09\xc2\x47\x5f\x57\x1b\x75\x8b\x5a" },
       { GCRY_MAC_HMAC_SHA3_384,
 	"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.",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\xca\xd1\x8a\x8f\xf6\xc4\xcc\x3a\xd4\x87\xb9\x5f\x97\x69\xe9\xb6"
 	"\x1c\x06\x2a\xef\xd6\x95\x25\x69\xe6\xe6\x42\x18\x97\x05\x4c\xfc"
 	"\x70\xb5\xfd\xc6\x60\x5c\x18\x45\x71\x12\xfc\x6a\xaa\xd4\x55\x85" },
       { GCRY_MAC_HMAC_SHA3_512,
 	"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.",
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
 	"\xaa\xaa\xaa",
 	"\xdc\x03\x0e\xe7\x88\x70\x34\xf3\x2c\xf4\x02\xdf\x34\x62\x2f\x31"
 	"\x1f\x3e\x6c\xf0\x48\x60\xc6\xbb\xd7\xfa\x48\x86\x74\x78\x2b\x46"
 	"\x59\xfd\xbd\xf3\xfd\x87\x78\x52\x88\x5c\xfe\x6e\x22\x18\x5f\xe7"
 	"\xb2\xee\x95\x20\x43\x62\x9b\xc9\xd5\xf3\x29\x8a\x41\xd0\x2c\x66" },
       { GCRY_MAC_HMAC_SHA3_224, "?", "????????????????",
         "\x80\x2b\x3c\x84\xfe\x3e\x01\x22\x14\xf8\xba\x74\x79\xfd\xb5\x02"
 	"\xea\x0c\x06\xa4\x7e\x01\xe3\x2c\xc7\x24\x89\xc3" },
       { GCRY_MAC_HMAC_SHA3_256, "?", "????????????????",
         "\x6c\x7c\x96\x5b\x19\xba\xcd\x61\x69\x8a\x2c\x7a\x2b\x96\xa1\xc3"
 	"\x33\xa0\x3c\x5d\x54\x87\x37\x60\xc8\x2f\xa2\xa6\x12\x38\x8d\x1b" },
       { GCRY_MAC_HMAC_SHA3_384, "?", "????????????????",
         "\xc0\x20\xd0\x9b\xa7\xb9\xd5\xb8\xa6\xa4\xba\x20\x55\xd9\x0b\x35"
 	"\x8b\xe0\xb7\xec\x1e\x9f\xe6\xb9\xbd\xd5\xe9\x9b\xfc\x0a\x11\x3a"
 	"\x15\x41\xed\xfd\xef\x30\x8d\x03\xb8\xca\x3a\xa8\xc7\x2d\x89\x32" },
       { GCRY_MAC_HMAC_SHA3_512, "?", "????????????????",
         "\xb4\xef\x24\xd2\x07\xa7\x01\xb3\xe1\x81\x11\x22\x93\x83\x64\xe0"
 	"\x5e\xad\x03\xb7\x43\x4f\x87\xa1\x14\x8e\x17\x8f\x2a\x97\x7d\xe8"
 	"\xbd\xb0\x37\x3b\x67\xb9\x97\x36\xa5\x82\x9b\xdc\x0d\xe4\x5a\x8c"
 	"\x5e\xda\xb5\xca\xea\xa9\xb4\x6e\xba\xca\x25\xc8\xbf\xa1\x0e\xb0" },
       { GCRY_MAC_HMAC_STRIBOG256,
         "\x01\x26\xbd\xb8\x78\x00\xaf\x21\x43\x41\x45\x65\x63\x78\x01\x00",
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",
         "\xa1\xaa\x5f\x7d\xe4\x02\xd7\xb3\xd3\x23\xf2\x99\x1c\x8d\x45\x34"
         "\x01\x31\x37\x01\x0a\x83\x75\x4f\xd0\xaf\x6d\x7c\xd4\x92\x2e\xd9",
         NULL, 16, 32 },
       { GCRY_MAC_HMAC_STRIBOG512,
         "\x01\x26\xbd\xb8\x78\x00\xaf\x21\x43\x41\x45\x65\x63\x78\x01\x00",
         "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",
         "\xa5\x9b\xab\x22\xec\xae\x19\xc6\x5f\xbd\xe6\xe5\xf4\xe9\xf5\xd8"
         "\x54\x9d\x31\xf0\x37\xf9\xdf\x9b\x90\x55\x00\xe1\x71\x92\x3a\x77"
         "\x3d\x5f\x15\x30\xf2\xed\x7e\x96\x4c\xb2\xee\xdc\x29\xe9\xad\x2f"
         "\x3a\xfe\x93\xb2\x81\x4f\x79\xf5\x00\x0f\xfc\x03\x66\xc2\x51\xe6",
         NULL, 16, 32 },
       /* CMAC AES and DES test vectors from
          http://web.archive.org/web/20130930212819/http://csrc.nist.gov/publica\
          tions/nistpubs/800-38B/Updated_CMAC_Examples.pdf */
       { GCRY_MAC_CMAC_AES,
         "",
         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
         "\xbb\x1d\x69\x29\xe9\x59\x37\x28\x7f\xa3\x7d\x12\x9b\x75\x67\x46" },
       { GCRY_MAC_CMAC_AES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
         "\x07\x0a\x16\xb4\x6b\x4d\x41\x44\xf7\x9b\xdd\x9d\xd0\x4a\x28\x7c" },
       { GCRY_MAC_CMAC_AES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51"
         "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11",
         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
         "\xdf\xa6\x67\x47\xde\x9a\xe6\x30\x30\xca\x32\x61\x14\x97\xc8\x27" },
       { GCRY_MAC_CMAC_AES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51"
         "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef"
         "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
         "\x51\xf0\xbe\xbf\x7e\x3b\x9d\x92\xfc\x49\x74\x17\x79\x36\x3c\xfe" },
       { GCRY_MAC_CMAC_AES,
         "",
         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b\x80\x90\x79\xe5"
         "\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
         "\xd1\x7d\xdf\x46\xad\xaa\xcd\xe5\x31\xca\xc4\x83\xde\x7a\x93\x67" },
       { GCRY_MAC_CMAC_AES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b\x80\x90\x79\xe5"
         "\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
         "\x9e\x99\xa7\xbf\x31\xe7\x10\x90\x06\x62\xf6\x5e\x61\x7c\x51\x84" },
       { GCRY_MAC_CMAC_AES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51"
         "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11",
         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b\x80\x90\x79\xe5"
         "\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
         "\x8a\x1d\xe5\xbe\x2e\xb3\x1a\xad\x08\x9a\x82\xe6\xee\x90\x8b\x0e" },
       { GCRY_MAC_CMAC_AES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51"
         "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef"
         "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
         "\x8e\x73\xb0\xf7\xda\x0e\x64\x52\xc8\x10\xf3\x2b\x80\x90\x79\xe5"
         "\x62\xf8\xea\xd2\x52\x2c\x6b\x7b",
         "\xa1\xd5\xdf\x0e\xed\x79\x0f\x79\x4d\x77\x58\x96\x59\xf3\x9a\x11" },
       { GCRY_MAC_CMAC_AES,
         "",
         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
         "\x02\x89\x62\xf6\x1b\x7b\xf8\x9e\xfc\x6b\x55\x1f\x46\x67\xd9\x83" },
       { GCRY_MAC_CMAC_AES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
         "\x28\xa7\x02\x3f\x45\x2e\x8f\x82\xbd\x4b\xf2\x8d\x8c\x37\xc3\x5c" },
       { GCRY_MAC_CMAC_AES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51"
         "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11",
         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
         "\xaa\xf3\xd8\xf1\xde\x56\x40\xc2\x32\xf5\xb1\x69\xb9\xc9\x11\xe6" },
       { GCRY_MAC_CMAC_AES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51"
         "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef"
         "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
         "\x60\x3d\xeb\x10\x15\xca\x71\xbe\x2b\x73\xae\xf0\x85\x7d\x77\x81"
         "\x1f\x35\x2c\x07\x3b\x61\x08\xd7\x2d\x98\x10\xa3\x09\x14\xdf\xf4",
         "\xe1\x99\x21\x90\x54\x9f\x6e\xd5\x69\x6a\x2c\x05\x6c\x31\x54\x10" },
       { GCRY_MAC_CMAC_AES, "?", "????????????????????????????????",
         "\x9f\x72\x73\x68\xb0\x49\x2e\xb1\x35\xa0\x1d\xf9\xa8\x0a\xf6\xee" },
       { GCRY_MAC_CMAC_3DES,
         "",
         "\x8a\xa8\x3b\xf8\xcb\xda\x10\x62\x0b\xc1\xbf\x19\xfb\xb6\xcd\x58"
         "\xbc\x31\x3d\x4a\x37\x1c\xa8\xb5",
         "\xb7\xa6\x88\xe1\x22\xff\xaf\x95" },
       { GCRY_MAC_CMAC_3DES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96",
         "\x8a\xa8\x3b\xf8\xcb\xda\x10\x62\x0b\xc1\xbf\x19\xfb\xb6\xcd\x58"
         "\xbc\x31\x3d\x4a\x37\x1c\xa8\xb5",
         "\x8e\x8f\x29\x31\x36\x28\x37\x97" },
       { GCRY_MAC_CMAC_3DES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57",
         "\x8a\xa8\x3b\xf8\xcb\xda\x10\x62\x0b\xc1\xbf\x19\xfb\xb6\xcd\x58"
         "\xbc\x31\x3d\x4a\x37\x1c\xa8\xb5",
         "\x74\x3d\xdb\xe0\xce\x2d\xc2\xed" },
       { GCRY_MAC_CMAC_3DES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
         "\x8a\xa8\x3b\xf8\xcb\xda\x10\x62\x0b\xc1\xbf\x19\xfb\xb6\xcd\x58"
         "\xbc\x31\x3d\x4a\x37\x1c\xa8\xb5",
         "\x33\xe6\xb1\x09\x24\x00\xea\xe5" },
       { GCRY_MAC_CMAC_3DES,
         "",
         "\x4c\xf1\x51\x34\xa2\x85\x0d\xd5\x8a\x3d\x10\xba\x80\x57\x0d\x38"
         "\x4c\xf1\x51\x34\xa2\x85\x0d\xd5",
         "\xbd\x2e\xbf\x9a\x3b\xa0\x03\x61" },
       { GCRY_MAC_CMAC_3DES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96",
         "\x4c\xf1\x51\x34\xa2\x85\x0d\xd5\x8a\x3d\x10\xba\x80\x57\x0d\x38"
         "\x4c\xf1\x51\x34\xa2\x85\x0d\xd5",
         "\x4f\xf2\xab\x81\x3c\x53\xce\x83" },
       { GCRY_MAC_CMAC_3DES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57",
         "\x4c\xf1\x51\x34\xa2\x85\x0d\xd5\x8a\x3d\x10\xba\x80\x57\x0d\x38"
         "\x4c\xf1\x51\x34\xa2\x85\x0d\xd5",
         "\x62\xdd\x1b\x47\x19\x02\xbd\x4e" },
       { GCRY_MAC_CMAC_3DES,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51",
         "\x4c\xf1\x51\x34\xa2\x85\x0d\xd5\x8a\x3d\x10\xba\x80\x57\x0d\x38"
         "\x4c\xf1\x51\x34\xa2\x85\x0d\xd5",
         "\x31\xb1\xe4\x31\xda\xbc\x4e\xb8" },
       { GCRY_MAC_CMAC_3DES, "?", "????????????????????????",
         "\xc1\x38\x13\xb2\x31\x8f\x3a\xdf" },
       /* CMAC Camellia test vectors from
          http://tools.ietf.org/html/draft-kato-ipsec-camellia-cmac96and128-05 */
       { GCRY_MAC_CMAC_CAMELLIA,
         "",
         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
         "\xba\x92\x57\x82\xaa\xa1\xf5\xd9\xa0\x0f\x89\x64\x80\x94\xfc\x71" },
       { GCRY_MAC_CMAC_CAMELLIA,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a",
         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
         "\x6d\x96\x28\x54\xa3\xb9\xfd\xa5\x6d\x7d\x45\xa9\x5e\xe1\x79\x93" },
       { GCRY_MAC_CMAC_CAMELLIA,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51"
         "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11",
         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
         "\x5c\x18\xd1\x19\xcc\xd6\x76\x61\x44\xac\x18\x66\x13\x1d\x9f\x22" },
       { GCRY_MAC_CMAC_CAMELLIA,
         "\x6b\xc1\xbe\xe2\x2e\x40\x9f\x96\xe9\x3d\x7e\x11\x73\x93\x17\x2a"
         "\xae\x2d\x8a\x57\x1e\x03\xac\x9c\x9e\xb7\x6f\xac\x45\xaf\x8e\x51"
         "\x30\xc8\x1c\x46\xa3\x5c\xe4\x11\xe5\xfb\xc1\x19\x1a\x0a\x52\xef"
         "\xf6\x9f\x24\x45\xdf\x4f\x9b\x17\xad\x2b\x41\x7b\xe6\x6c\x37\x10",
         "\x2b\x7e\x15\x16\x28\xae\xd2\xa6\xab\xf7\x15\x88\x09\xcf\x4f\x3c",
         "\xc2\x69\x9a\x6e\xba\x55\xce\x9d\x93\x9a\x8a\x4e\x19\x46\x6e\xe9" },
       { GCRY_MAC_CMAC_CAMELLIA, "?", "????????????????????????????????",
         "\xba\x8a\x5a\x8d\xa7\x54\x26\x83\x3e\xb1\x20\xb5\x45\xd0\x9f\x4e" },
       /* http://csrc.nist.gov/groups/STM/cavp/documents/mac/gcmtestvectors.zip */
       { GCRY_MAC_GMAC_AES,
         "",
         "\x11\x75\x4c\xd7\x2a\xec\x30\x9b\xf5\x2f\x76\x87\x21\x2e\x89\x57",
         "\x25\x03\x27\xc6\x74\xaa\xf4\x77\xae\xf2\x67\x57\x48\xcf\x69\x71",
         "\x3c\x81\x9d\x9a\x9b\xed\x08\x76\x15\x03\x0b\x65" },
       { GCRY_MAC_GMAC_AES,
         "\x2b\x63\x26\x64\x29\x67\x4a\xb5\xe2\xea\xff\x63\x9c\x23\x14\x66"
         "\x2f\x92\x57\x4b\x29\x8f\x57\x7a\xcf\x7d\x6f\x99\x1a\x87\x92\x1f"
         "\xc2\x32\xea\xfc\xc7\xb1\x46\x48\x96\x63\x2d\x6c\x8a\xbe\x88\xc2"
         "\xcc\xa4\x04\xdb\xf8\x7c\x20\x6a\x19\xd3\x73\xed\x99\x50\x17\x34"
         "\x69\x13\x4d\x7c\x14\xc2\x84\x7d\xf2\x4a\x88\xc1\xc5\x3b\x4d\xe4"
         "\x9d\xb3\x66\x39\x2b\x6d\xc6\x51\x27\x6e",
         "\x0f\x3b\x17\xde\xae\x62\x13\x64\x55\x4a\xe5\x39\xdb\x09\xde\x11",
         "\xff\xb0\xbb\x6d\xfc\x23\x58\x75\x4f\x17\x78\x48\x5b\x59\x65\x7f",
         "\xa7\xf6\x07\x4c\xda\x56\x1c\xd2\xaa\x15\xba\x8c\x2f\xa6\x39\x42"
         "\x59\x3e\x7c\xcf\x45\xc2\x9a\x57\xda\xd8\xa6\xe2\xea\x63\x54\xce"
         "\x8a\xde\x39\xdd\xde\x4a\xc4\x5b\xbd\xc6\x63\xf0\xa5\x37\xc9\x48"
         "\x18\x23\x5a\x73\xd8\xa0\x8b\xd8\x98\xab\xd0\x99\xe1\x5c\x08\x8c"
         "\x6e\x21\x17\x5a\xf4\xe9\xa4\x99\x70\x12\x82\xed\x32\x81\x50\xa6"
         "\xd9\x90\xe8\xec\x87\x85\xce\x26\x1b\xe1\xb8\x3f\xd8\x59\x1e\x57"
         "\x76\x5f\x3d\xc1\x11\x3f\xd0\x2a\x40\xf5\x01\x6a\xd0\xd0\xed\xc4"
         "\x92\x9a\x02\xe0\x17\xb2\xc5\xf4\x18\xd2\x96\xab\xd6\xc2\xea\x2e" },
       { GCRY_MAC_GMAC_AES,
         "\x61\x14\x60\x11\x90\xf6\xef\x5e\x59\x23\x5d\xc0\x42\x8c\x09\xe3"
         "\x27\x0b\x19\xea",
         "\x15\xa4\x14\x46\x6a\x7f\x90\xea\x32\xbf\xd7\xf6\xe5\x8b\xfa\x06"
         "\xe9\x07\xfc\x41\x66\x89\xd9\x60\x39\x45\xd7\x94\x54\xd4\x23\x17",
         "\x19\x6e\x0e\x01\x0f\x08\x56\xf9\x82\xb4\x08\x92\x41\xd6\x24\x84",
         "\xab" },
       { GCRY_MAC_GMAC_AES,
         "\x8b\x5c\x12\x4b\xef\x6e\x2f\x0f\xe4\xd8\xc9\x5c\xd5\xfa\x4c\xf1",
         "\x41\xc5\xda\x86\x67\xef\x72\x52\x20\xff\xe3\x9a\xe0\xac\x59\x0a"
         "\xc9\xfc\xa7\x29\xab\x60\xad\xa0",
         "\x20\x4b\xdb\x1b\xd6\x21\x54\xbf\x08\x92\x2a\xaa\x54\xee\xd7\x05",
         "\x05\xad\x13\xa5\xe2\xc2\xab\x66\x7e\x1a\x6f\xbc" },
       { GCRY_MAC_GMAC_AES, "?", "????????????????????????????????",
         "\x84\x37\xc3\x42\xae\xf5\xd0\x40\xd3\x73\x90\xa9\x36\xed\x8a\x12" },
       /* from NaCl */
       { GCRY_MAC_POLY1305,
         "\x8e\x99\x3b\x9f\x48\x68\x12\x73\xc2\x96\x50\xba\x32\xfc\x76\xce"
         "\x48\x33\x2e\xa7\x16\x4d\x96\xa4\x47\x6f\xb8\xc5\x31\xa1\x18\x6a"
         "\xc0\xdf\xc1\x7c\x98\xdc\xe8\x7b\x4d\xa7\xf0\x11\xec\x48\xc9\x72"
         "\x71\xd2\xc2\x0f\x9b\x92\x8f\xe2\x27\x0d\x6f\xb8\x63\xd5\x17\x38"
         "\xb4\x8e\xee\xe3\x14\xa7\xcc\x8a\xb9\x32\x16\x45\x48\xe5\x26\xae"
         "\x90\x22\x43\x68\x51\x7a\xcf\xea\xbd\x6b\xb3\x73\x2b\xc0\xe9\xda"
         "\x99\x83\x2b\x61\xca\x01\xb6\xde\x56\x24\x4a\x9e\x88\xd5\xf9\xb3"
         "\x79\x73\xf6\x22\xa4\x3d\x14\xa6\x59\x9b\x1f\x65\x4c\xb4\x5a\x74"
         "\xe3\x55\xa5",
         "\xee\xa6\xa7\x25\x1c\x1e\x72\x91\x6d\x11\xc2\xcb\x21\x4d\x3c\x25"
         "\x25\x39\x12\x1d\x8e\x23\x4e\x65\x2d\x65\x1f\xa4\xc8\xcf\xf8\x80",
         "\xf3\xff\xc7\x70\x3f\x94\x00\xe5\x2a\x7d\xfb\x4b\x3d\x33\x05\xd9" },
       /* from draft-nir-cfrg-chacha20-poly1305-03 */
       { GCRY_MAC_POLY1305,
         "Cryptographic Forum Research Group",
         "\x85\xd6\xbe\x78\x57\x55\x6d\x33\x7f\x44\x52\xfe\x42\xd5\x06\xa8"
         "\x01\x03\x80\x8a\xfb\x0d\xb2\xfd\x4a\xbf\xf6\xaf\x41\x49\xf5\x1b",
         "\xa8\x06\x1d\xc1\x30\x51\x36\xc6\xc2\x2b\x8b\xaf\x0c\x01\x27\xa9" },
       { GCRY_MAC_POLY1305,
         "'Twas brillig, and the slithy toves\n"
         "Did gyre and gimble in the wabe:\n"
         "All mimsy were the borogoves,\n"
         "And the mome raths outgrabe.",
         "\x1c\x92\x40\xa5\xeb\x55\xd3\x8a\xf3\x33\x88\x86\x04\xf6\xb5\xf0"
         "\x47\x39\x17\xc1\x40\x2b\x80\x09\x9d\xca\x5c\xbc\x20\x70\x75\xc0",
         "\x45\x41\x66\x9a\x7e\xaa\xee\x61\xe7\x08\xdc\x7c\xbc\xc5\xeb\x62" },
       { GCRY_MAC_POLY1305,
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         NULL,
         191, 32 },
       { GCRY_MAC_POLY1305,
         "Any submission to the IETF intended by the Contributor for "
         "publication as all or part of an IETF Internet-Draft or RFC and "
         "any statement made within the context of an IETF activity is "
         "considered an \"IETF Contribution\". Such statements include "
         "oral statements in IETF sessions, as well as written and "
         "electronic communications made at any time or place, which are "
         "addressed to",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x36\xe5\xf6\xb5\xc5\xe0\x60\x70\xf0\xef\xca\x96\x22\x7a\x86\x3e",
         "\x36\xe5\xf6\xb5\xc5\xe0\x60\x70\xf0\xef\xca\x96\x22\x7a\x86\x3e",
         NULL,
         0, 32 },
       { GCRY_MAC_POLY1305,
         "Any submission to the IETF intended by the Contributor for "
         "publication as all or part of an IETF Internet-Draft or RFC and "
         "any statement made within the context of an IETF activity is "
         "considered an \"IETF Contribution\". Such statements include "
         "oral statements in IETF sessions, as well as written and "
         "electronic communications made at any time or place, which are "
         "addressed to",
         "\x36\xe5\xf6\xb5\xc5\xe0\x60\x70\xf0\xef\xca\x96\x22\x7a\x86\x3e"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\xf3\x47\x7e\x7c\xd9\x54\x17\xaf\x89\xa6\xb8\x79\x4c\x31\x0c\xf0",
         NULL,
         0, 32 },
       /* draft-irtf-cfrg-chacha20-poly1305-01 */
       /* TV#5 */
       { GCRY_MAC_POLY1305,
         "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
         "\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         NULL,
         16, 32 },
       /* TV#6 */
       { GCRY_MAC_POLY1305,
         "\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
         "\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         NULL,
         16, 32 },
       /* TV#7 */
       { GCRY_MAC_POLY1305,
         "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
         "\xF0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
         "\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         NULL,
         48, 32 },
       /* TV#8 */
       { GCRY_MAC_POLY1305,
         "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
         "\xFB\xFE\xFE\xFE\xFE\xFE\xFE\xFE\xFE\xFE\xFE\xFE\xFE\xFE\xFE\xFE"
         "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01",
         "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         NULL,
         48, 32 },
       /* TV#9 */
       { GCRY_MAC_POLY1305,
         "\xFD\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
         "\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\xFA\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
         NULL,
         16, 32 },
       /* TV#10 */
       { GCRY_MAC_POLY1305,
         "\xE3\x35\x94\xD7\x50\x5E\x43\xB9\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x33\x94\xD7\x50\x5E\x43\x79\xCD\x01\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x01\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x14\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00",
         NULL,
         64, 32 },
       /* TV#11 */
       { GCRY_MAC_POLY1305,
         "\xE3\x35\x94\xD7\x50\x5E\x43\xB9\x00\x00\x00\x00\x00\x00\x00\x00"
         "\x33\x94\xD7\x50\x5E\x43\x79\xCD\x01\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x01\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00"
         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         "\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         NULL,
         48, 32 },
       /* from http://cr.yp.to/mac/poly1305-20050329.pdf */
       { GCRY_MAC_POLY1305,
         "\xf3\xf6",
         "\x85\x1f\xc4\x0c\x34\x67\xac\x0b\xe0\x5c\xc2\x04\x04\xf3\xf7\x00"
         "\x58\x0b\x3b\x0f\x94\x47\xbb\x1e\x69\xd0\x95\xb5\x92\x8b\x6d\xbc",
         "\xf4\xc6\x33\xc3\x04\x4f\xc1\x45\xf8\x4f\x33\x5c\xb8\x19\x53\xde",
         NULL,
         0, 32 },
       { GCRY_MAC_POLY1305,
         "",
         "\xa0\xf3\x08\x00\x00\xf4\x64\x00\xd0\xc7\xe9\x07\x6c\x83\x44\x03"
         "\xdd\x3f\xab\x22\x51\xf1\x1a\xc7\x59\xf0\x88\x71\x29\xcc\x2e\xe7",
         "\xdd\x3f\xab\x22\x51\xf1\x1a\xc7\x59\xf0\x88\x71\x29\xcc\x2e\xe7",
         NULL,
         0, 32 },
       { GCRY_MAC_POLY1305,
         "\x66\x3c\xea\x19\x0f\xfb\x83\xd8\x95\x93\xf3\xf4\x76\xb6\xbc\x24"
         "\xd7\xe6\x79\x10\x7e\xa2\x6a\xdb\x8c\xaf\x66\x52\xd0\x65\x61\x36",
         "\x48\x44\x3d\x0b\xb0\xd2\x11\x09\xc8\x9a\x10\x0b\x5c\xe2\xc2\x08"
         "\x83\x14\x9c\x69\xb5\x61\xdd\x88\x29\x8a\x17\x98\xb1\x07\x16\xef",
         "\x0e\xe1\xc1\x6b\xb7\x3f\x0f\x4f\xd1\x98\x81\x75\x3c\x01\xcd\xbe",
         NULL,
         0, 32 },
       { GCRY_MAC_POLY1305,
         "\xab\x08\x12\x72\x4a\x7f\x1e\x34\x27\x42\xcb\xed\x37\x4d\x94\xd1"
         "\x36\xc6\xb8\x79\x5d\x45\xb3\x81\x98\x30\xf2\xc0\x44\x91\xfa\xf0"
         "\x99\x0c\x62\xe4\x8b\x80\x18\xb2\xc3\xe4\xa0\xfa\x31\x34\xcb\x67"
         "\xfa\x83\xe1\x58\xc9\x94\xd9\x61\xc4\xcb\x21\x09\x5c\x1b\xf9",
         "\x12\x97\x6a\x08\xc4\x42\x6d\x0c\xe8\xa8\x24\x07\xc4\xf4\x82\x07"
         "\x80\xf8\xc2\x0a\xa7\x12\x02\xd1\xe2\x91\x79\xcb\xcb\x55\x5a\x57",
         "\x51\x54\xad\x0d\x2c\xb2\x6e\x01\x27\x4f\xc5\x11\x48\x49\x1f\x1b" },
       { GCRY_MAC_POLY1305, "?", "????????????????????????????????",
         "\xc3\x88\xce\x8a\x52\xd6\xe7\x21\x86\xfa\xaa\x5d\x2d\x16\xf9\xa3" },
       /* from http://cr.yp.to/mac/poly1305-20050329.pdf */
       { GCRY_MAC_POLY1305_AES,
         "\xf3\xf6",
         "\xec\x07\x4c\x83\x55\x80\x74\x17\x01\x42\x5b\x62\x32\x35\xad\xd6"
         "\x85\x1f\xc4\x0c\x34\x67\xac\x0b\xe0\x5c\xc2\x04\x04\xf3\xf7\x00",
         "\xf4\xc6\x33\xc3\x04\x4f\xc1\x45\xf8\x4f\x33\x5c\xb8\x19\x53\xde",
         "\xfb\x44\x73\x50\xc4\xe8\x68\xc5\x2a\xc3\x27\x5c\xf9\xd4\x32\x7e",
         0, 32 },
       { GCRY_MAC_POLY1305_AES,
         "",
         "\x75\xde\xaa\x25\xc0\x9f\x20\x8e\x1d\xc4\xce\x6b\x5c\xad\x3f\xbf"
         "\xa0\xf3\x08\x00\x00\xf4\x64\x00\xd0\xc7\xe9\x07\x6c\x83\x44\x03",
         "\xdd\x3f\xab\x22\x51\xf1\x1a\xc7\x59\xf0\x88\x71\x29\xcc\x2e\xe7",
         "\x61\xee\x09\x21\x8d\x29\xb0\xaa\xed\x7e\x15\x4a\x2c\x55\x09\xcc",
         0, 32 },
       { GCRY_MAC_POLY1305_AES,
         "\x66\x3c\xea\x19\x0f\xfb\x83\xd8\x95\x93\xf3\xf4\x76\xb6\xbc\x24"
         "\xd7\xe6\x79\x10\x7e\xa2\x6a\xdb\x8c\xaf\x66\x52\xd0\x65\x61\x36",
         "\x6a\xcb\x5f\x61\xa7\x17\x6d\xd3\x20\xc5\xc1\xeb\x2e\xdc\xdc\x74"
         "\x48\x44\x3d\x0b\xb0\xd2\x11\x09\xc8\x9a\x10\x0b\x5c\xe2\xc2\x08",
         "\x0e\xe1\xc1\x6b\xb7\x3f\x0f\x4f\xd1\x98\x81\x75\x3c\x01\xcd\xbe",
         "\xae\x21\x2a\x55\x39\x97\x29\x59\x5d\xea\x45\x8b\xc6\x21\xff\x0e",
         0, 32 },
       { GCRY_MAC_POLY1305_AES,
         "\xab\x08\x12\x72\x4a\x7f\x1e\x34\x27\x42\xcb\xed\x37\x4d\x94\xd1"
         "\x36\xc6\xb8\x79\x5d\x45\xb3\x81\x98\x30\xf2\xc0\x44\x91\xfa\xf0"
         "\x99\x0c\x62\xe4\x8b\x80\x18\xb2\xc3\xe4\xa0\xfa\x31\x34\xcb\x67"
         "\xfa\x83\xe1\x58\xc9\x94\xd9\x61\xc4\xcb\x21\x09\x5c\x1b\xf9",
         "\xe1\xa5\x66\x8a\x4d\x5b\x66\xa5\xf6\x8c\xc5\x42\x4e\xd5\x98\x2d"
         "\x12\x97\x6a\x08\xc4\x42\x6d\x0c\xe8\xa8\x24\x07\xc4\xf4\x82\x07",
         "\x51\x54\xad\x0d\x2c\xb2\x6e\x01\x27\x4f\xc5\x11\x48\x49\x1f\x1b",
 	"\x9a\xe8\x31\xe7\x43\x97\x8d\x3a\x23\x52\x7c\x71\x28\x14\x9e\x3a",
         0, 32 },
       { GCRY_MAC_POLY1305_AES, "?", "????????????????????????????????",
         "\x9d\xeb\xb0\xcd\x24\x90\xd3\x9b\x47\x78\x37\x0a\x81\xf2\x83\x2a",
         "\x61\xee\x09\x21\x8d\x29\xb0\xaa\xed\x7e\x15\x4a\x2c\x55\x09\xcc",
         0, 32 },
       { 0 },
     };
   int i;
 
   if (verbose)
     fprintf (stderr, "Starting MAC checks.\n");
 
   for (i = 0; algos[i].algo; i++)
     {
       size_t klen, dlen;
 
       if (gcry_mac_test_algo (algos[i].algo))
         {
           show_mac_not_available (algos[i].algo);
           continue;
         }
       if (gcry_mac_test_algo (algos[i].algo) && in_fips_mode)
         {
           if (verbose)
             fprintf (stderr, "  algorithm %d not available in fips mode\n",
 		     algos[i].algo);
           continue;
         }
       if (verbose)
 	fprintf (stderr,
                  "  checking %s [%i] for %d byte key and %d byte data\n",
 		 gcry_mac_algo_name (algos[i].algo),
 		 algos[i].algo, (int)strlen(algos[i].key),
                  (!strcmp(algos[i].data, "!") || !strcmp(algos[i].data, "?"))
                    ? 1000000 : (int)strlen(algos[i].data));
 
       klen = algos[i].klen ? algos[i].klen : strlen(algos[i].key);
       dlen = algos[i].dlen ? algos[i].dlen : strlen (algos[i].data);
 
       check_one_mac (algos[i].algo, algos[i].data, dlen, algos[i].key, klen,
 		     algos[i].iv, algos[i].iv ? strlen(algos[i].iv) : 0,
 		     algos[i].expect, 0);
       check_one_mac (algos[i].algo, algos[i].data, dlen, algos[i].key, klen,
 		     algos[i].iv, algos[i].iv ? strlen(algos[i].iv) : 0,
 		     algos[i].expect, 1);
     }
 
   if (verbose)
     fprintf (stderr, "Completed MAC checks.\n");
 }
 
 /* Check that the signature SIG matches the hash HASH. PKEY is the
    public key used for the verification. BADHASH is a hash value which
    should result in a bad signature status. */
 static void
 verify_one_signature (gcry_sexp_t pkey, gcry_sexp_t hash,
 		      gcry_sexp_t badhash, gcry_sexp_t sig)
 {
   gcry_error_t rc;
 
   rc = gcry_pk_verify (sig, hash, pkey);
   if (rc)
     fail ("gcry_pk_verify failed: %s\n", gpg_strerror (rc));
   rc = gcry_pk_verify (sig, badhash, pkey);
   if (gcry_err_code (rc) != GPG_ERR_BAD_SIGNATURE)
     fail ("gcry_pk_verify failed to detect a bad signature: %s\n",
 	  gpg_strerror (rc));
 }
 
 
 /* Test the public key sign function using the private ket SKEY. PKEY
    is used for verification. */
 static void
 check_pubkey_sign (int n, gcry_sexp_t skey, gcry_sexp_t pkey, int algo)
 {
   gcry_error_t rc;
   gcry_sexp_t sig, badhash, hash;
   int dataidx;
   static const char baddata[] =
     "(data\n (flags pkcs1)\n"
     " (hash sha1 #11223344556677889900AABBCCDDEEFF10203041#))\n";
   static const struct
   {
     const char *data;
     int algo;
     int expected_rc;
   } datas[] =
     {
       { "(data\n (flags pkcs1)\n"
 	" (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
 	GCRY_PK_RSA,
 	0 },
       { "(data\n (flags pkcs1-raw)\n"
 	" (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
 	GCRY_PK_RSA,
 	GPG_ERR_CONFLICT },
       { "(data\n (flags oaep)\n"
 	" (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
 	0,
 	GPG_ERR_CONFLICT },
       /* This test is to see whether hash algorithms not hard wired in
          pubkey.c are detected:  */
       { "(data\n (flags pkcs1)\n"
 	" (hash oid.1.3.14.3.2.29 "
         "       #11223344556677889900AABBCCDDEEFF10203040#))\n",
 	GCRY_PK_RSA,
 	0 },
       {	"(data\n (flags )\n"
 	" (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
 	0,
 	GPG_ERR_CONFLICT },
       {	"(data\n (flags pkcs1)\n"
 	" (hash foo #11223344556677889900AABBCCDDEEFF10203040#))\n",
 	GCRY_PK_RSA,
 	GPG_ERR_DIGEST_ALGO },
       {	"(data\n (flags )\n" " (value #11223344556677889900AA#))\n",
 	0,
 	0 },
       {	"(data\n (flags )\n" " (value #0090223344556677889900AA#))\n",
 	0,
 	0 },
       { "(data\n (flags raw)\n" " (value #11223344556677889900AA#))\n",
 	0,
 	0 },
       {	"(data\n (flags pkcs1)\n"
 	" (value #11223344556677889900AA#))\n",
 	GCRY_PK_RSA,
 	GPG_ERR_CONFLICT },
       { "(data\n (flags pkcs1-raw)\n"
 	" (value #11223344556677889900AA#))\n",
 	GCRY_PK_RSA,
 	0 },
       { "(data\n (flags raw foo)\n"
 	" (value #11223344556677889900AA#))\n",
 	0,
 	GPG_ERR_INV_FLAG },
       { "(data\n (flags pss)\n"
 	" (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
 	GCRY_PK_RSA,
 	0 },
       { "(data\n (flags pss)\n"
 	" (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#)\n"
         " (random-override #4253647587980912233445566778899019283747#))\n",
 	GCRY_PK_RSA,
 	0 },
       { NULL }
     };
 
   rc = gcry_sexp_sscan (&badhash, NULL, baddata, strlen (baddata));
   if (rc)
     die ("converting data failed: %s\n", gpg_strerror (rc));
 
   for (dataidx = 0; datas[dataidx].data; dataidx++)
     {
       if (datas[dataidx].algo && datas[dataidx].algo != algo)
 	continue;
 
       if (verbose)
 	fprintf (stderr, "  test %d, signature test %d (%s)\n",
                  n, dataidx, gcry_pk_algo_name (algo));
 
       rc = gcry_sexp_sscan (&hash, NULL, datas[dataidx].data,
 			    strlen (datas[dataidx].data));
       if (rc)
 	die ("converting data failed: %s\n", gpg_strerror (rc));
 
       rc = gcry_pk_sign (&sig, hash, skey);
       if (gcry_err_code (rc) != datas[dataidx].expected_rc)
 	fail ("gcry_pk_sign failed: %s\n", gpg_strerror (rc));
 
       if (!rc)
 	verify_one_signature (pkey, hash, badhash, sig);
 
       gcry_sexp_release (sig);
       sig = NULL;
       gcry_sexp_release (hash);
       hash = NULL;
     }
 
   gcry_sexp_release (badhash);
 }
 
 
 /* Test the public key sign function using the private ket SKEY. PKEY
    is used for verification.  This variant is only used for ECDSA.  */
 static void
 check_pubkey_sign_ecdsa (int n, gcry_sexp_t skey, gcry_sexp_t pkey)
 {
   gcry_error_t rc;
   gcry_sexp_t sig, badhash, hash;
   unsigned int nbits;
   int dataidx;
   static const struct
   {
     unsigned int nbits;
     const char *data;
     int expected_rc;
     const char *baddata;
     int dummy;
   } datas[] =
     {
       { 192,
         "(data (flags raw)\n"
         " (value #00112233445566778899AABBCCDDEEFF0001020304050607#))",
         0,
         "(data (flags raw)\n"
         " (value #80112233445566778899AABBCCDDEEFF0001020304050607#))",
         0
       },
       { 256,
         "(data (flags raw)\n"
         " (value #00112233445566778899AABBCCDDEEFF"
         /* */    "000102030405060708090A0B0C0D0E0F#))",
         0,
         "(data (flags raw)\n"
         " (value #80112233445566778899AABBCCDDEEFF"
         /* */    "000102030405060708090A0B0C0D0E0F#))",
         0
       },
       { 256,
         "(data (flags raw)\n"
         " (hash sha256 #00112233445566778899AABBCCDDEEFF"
         /* */          "000102030405060708090A0B0C0D0E0F#))",
         0,
         "(data (flags raw)\n"
         " (hash sha256 #80112233445566778899AABBCCDDEEFF"
         /* */          "000102030405060708090A0B0C0D0E0F#))",
         0
       },
       { 256,
         "(data (flags gost)\n"
         " (value #00112233445566778899AABBCCDDEEFF"
         /* */    "000102030405060708090A0B0C0D0E0F#))",
         0,
         "(data (flags gost)\n"
         " (value #80112233445566778899AABBCCDDEEFF"
         /* */    "000102030405060708090A0B0C0D0E0F#))",
         0
       },
       { 512,
         "(data (flags gost)\n"
         " (value #00112233445566778899AABBCCDDEEFF"
         /* */    "000102030405060708090A0B0C0D0E0F"
         /* */    "000102030405060708090A0B0C0D0E0F"
         /* */    "000102030405060708090A0B0C0D0E0F#))",
         0,
         "(data (flags gost)\n"
         " (value #80112233445566778899AABBCCDDEEFF"
         /* */    "000102030405060708090A0B0C0D0E0F"
         /* */    "000102030405060708090A0B0C0D0E0F"
         /* */    "000102030405060708090A0B0C0D0E0F#))",
         0
       },
       { 0, NULL }
     };
 
   nbits = gcry_pk_get_nbits (skey);
 
   for (dataidx = 0; datas[dataidx].data; dataidx++)
     {
       if (datas[dataidx].nbits != nbits)
 	continue;
 
       if (verbose)
 	fprintf (stderr, "  test %d, signature test %d (%u bit ecdsa)\n",
                  n, dataidx, nbits);
 
       rc = gcry_sexp_sscan (&hash, NULL, datas[dataidx].data,
 			    strlen (datas[dataidx].data));
       if (rc)
 	die ("converting data failed: %s\n", gpg_strerror (rc));
       rc = gcry_sexp_sscan (&badhash, NULL, datas[dataidx].baddata,
                             strlen (datas[dataidx].baddata));
       if (rc)
         die ("converting data failed: %s\n", gpg_strerror (rc));
 
       rc = gcry_pk_sign (&sig, hash, skey);
       if (gcry_err_code (rc) != datas[dataidx].expected_rc)
 	fail ("gcry_pk_sign failed: %s\n", gpg_strerror (rc));
 
       if (!rc && verbose > 1)
         show_sexp ("ECDSA signature:\n", sig);
 
       if (!rc)
         verify_one_signature (pkey, hash, badhash, sig);
 
       gcry_sexp_release (sig);
       sig = NULL;
       gcry_sexp_release (badhash);
       badhash = NULL;
       gcry_sexp_release (hash);
       hash = NULL;
     }
 }
 
 
 static void
 check_pubkey_crypt (int n, gcry_sexp_t skey, gcry_sexp_t pkey, int algo)
 {
   gcry_error_t rc;
   gcry_sexp_t plain = NULL;
   gcry_sexp_t ciph = NULL;
   gcry_sexp_t data = NULL;
   int dataidx;
   static const struct
   {
     int algo;    /* If not 0 run test only if ALGO matches.  */
     const char *data;
     const char *hint;
     int unpadded;
     int encrypt_expected_rc;
     int decrypt_expected_rc;
     int special;
   } datas[] =
     {
       {	GCRY_PK_RSA,
         "(data\n (flags pkcs1)\n"
 	" (value #11223344556677889900AA#))\n",
 	NULL,
 	0,
 	0,
 	0 },
       {	GCRY_PK_RSA,
         "(data\n (flags pkcs1)\n"
 	" (value #11223344556677889900AA#))\n",
 	"(flags pkcs1)",
 	1,
 	0,
 	0 },
       { GCRY_PK_RSA,
         "(data\n (flags oaep)\n"
 	" (value #11223344556677889900AA#))\n",
 	"(flags oaep)",
 	1,
 	0,
 	0 },
       { GCRY_PK_RSA,
         "(data\n (flags oaep)\n (hash-algo sha1)\n"
 	" (value #11223344556677889900AA#))\n",
 	"(flags oaep)(hash-algo sha1)",
 	1,
 	0,
 	0 },
       { GCRY_PK_RSA,
         "(data\n (flags oaep)\n (hash-algo sha1)\n (label \"test\")\n"
 	" (value #11223344556677889900AA#))\n",
 	"(flags oaep)(hash-algo sha1)(label \"test\")",
 	1,
 	0,
 	0 },
       { GCRY_PK_RSA,
         "(data\n (flags oaep)\n (hash-algo sha1)\n (label \"test\")\n"
 	" (value #11223344556677889900AA#)\n"
         " (random-override #4253647587980912233445566778899019283747#))\n",
 	"(flags oaep)(hash-algo sha1)(label \"test\")",
 	1,
 	0,
 	0 },
       {	0,
         "(data\n (flags )\n" " (value #11223344556677889900AA#))\n",
 	NULL,
 	1,
 	0,
 	0 },
       {	0,
         "(data\n (flags )\n" " (value #0090223344556677889900AA#))\n",
 	NULL,
 	1,
 	0,
 	0 },
       { 0,
         "(data\n (flags raw)\n" " (value #11223344556677889900AA#))\n",
 	NULL,
 	1,
 	0,
 	0 },
       { GCRY_PK_RSA,
         "(data\n (flags pkcs1)\n"
 	" (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
 	NULL,
 	0,
 	GPG_ERR_CONFLICT,
 	0},
       { 0,
         "(data\n (flags raw foo)\n"
 	" (hash sha1 #11223344556677889900AABBCCDDEEFF10203040#))\n",
 	NULL,
 	0,
 	GPG_ERR_INV_FLAG,
 	0},
       { 0,
         "(data\n (flags raw)\n"
 	" (value #11223344556677889900AA#))\n",
 	"(flags oaep)",
 	1,
 	0,
 	GPG_ERR_ENCODING_PROBLEM, 1 },
       { GCRY_PK_RSA,
         "(data\n (flags oaep)\n"
 	" (value #11223344556677889900AA#))\n",
 	"(flags pkcs1)",
 	1,
 	0,
 	GPG_ERR_ENCODING_PROBLEM, 1 },
       {	0,
         "(data\n (flags pss)\n"
 	" (value #11223344556677889900AA#))\n",
 	NULL,
 	0,
 	GPG_ERR_CONFLICT },
       { 0, NULL }
     };
 
   (void)n;
 
   for (dataidx = 0; datas[dataidx].data; dataidx++)
     {
       if (datas[dataidx].algo && datas[dataidx].algo != algo)
 	continue;
 
       if (verbose)
 	fprintf (stderr, "  encryption/decryption test %d (algo %d)\n",
                  dataidx, algo);
 
       rc = gcry_sexp_sscan (&data, NULL, datas[dataidx].data,
 			    strlen (datas[dataidx].data));
       if (rc)
 	die ("converting data failed: %s\n", gpg_strerror (rc));
 
       rc = gcry_pk_encrypt (&ciph, data, pkey);
       if (gcry_err_code (rc) != datas[dataidx].encrypt_expected_rc)
 	fail ("gcry_pk_encrypt failed: %s\n", gpg_strerror (rc));
 
       if (!rc)
 	{
           int expect_mismatch = 0;
 
 	  /* Insert decoding hint to CIPH. */
 	  if (datas[dataidx].hint)
 	    {
 	      size_t hint_len, len;
 	      char *hint, *buf;
 	      gcry_sexp_t list;
 
 	      /* Convert decoding hint into canonical sexp. */
 	      hint_len = gcry_sexp_new (&list, datas[dataidx].hint,
 					strlen (datas[dataidx].hint), 1);
 	      hint_len = gcry_sexp_sprint (list, GCRYSEXP_FMT_CANON, NULL, 0);
 	      hint = gcry_malloc (hint_len);
 	      if (!hint)
 		die ("can't allocate memory\n");
 	      hint_len = gcry_sexp_sprint (list, GCRYSEXP_FMT_CANON, hint,
 					   hint_len);
 	      gcry_sexp_release (list);
 
 	      /* Convert CIPH into canonical sexp. */
 	      len = gcry_sexp_sprint (ciph, GCRYSEXP_FMT_CANON, NULL, 0);
 	      buf = gcry_malloc (len + hint_len);
 	      if (!buf)
 		die ("can't allocate memory\n");
 	      len = gcry_sexp_sprint (ciph, GCRYSEXP_FMT_CANON, buf, len);
 	      /* assert (!strcmp (buf, "(7:enc-val", 10)); */
 
 	      /* Copy decoding hint into CIPH. */
 	      memmove (buf + 10 + hint_len, buf + 10, len - 10);
 	      memcpy (buf + 10, hint, hint_len);
 	      gcry_free (hint);
 	      gcry_sexp_new (&list, buf, len + hint_len, 1);
 	      gcry_free (buf);
 	      gcry_sexp_release (ciph);
 	      ciph = list;
 	    }
 	  rc = gcry_pk_decrypt (&plain, ciph, skey);
           if (!rc && datas[dataidx].special == 1)
             {
               /* It may happen that OAEP formatted data which is
                  decrypted as pkcs#1 data returns a valid pkcs#1
                  frame.  However, the returned value will not be
                  identical - thus we expect a mismatch and test further on
                  whether this mismatch actually happened.  */
               expect_mismatch = 1;
             }
 	  else if (gcry_err_code (rc) != datas[dataidx].decrypt_expected_rc)
             {
               if (verbose)
                 {
                   show_sexp ("  data:\n", data);
                   show_sexp ("  ciph:\n", ciph);
                   show_sexp ("   key:\n", skey);
                 }
               fail ("gcry_pk_decrypt failed: expected %d (%s), got %d (%s)\n",
                     datas[dataidx].decrypt_expected_rc,
                     gpg_strerror (datas[dataidx].decrypt_expected_rc),
                     rc, gpg_strerror (rc));
             }
 
 	  if (!rc && datas[dataidx].unpadded)
 	    {
 	      gcry_sexp_t p1, p2;
 
 	      p1 = gcry_sexp_find_token (data, "value", 0);
 	      p2 = gcry_sexp_find_token (plain, "value", 0);
 	      if (p1 && p2)
 		{
 		  const char *s1, *s2;
 		  size_t n1, n2;
 
 		  s1 = gcry_sexp_nth_data (p1, 1, &n1);
 		  s2 = gcry_sexp_nth_data (p2, 1, &n2);
 		  if (n1 != n2 || memcmp (s1, s2, n1))
                     {
                       if (expect_mismatch)
                         expect_mismatch = 0;
                       else
                         fail ("gcry_pk_encrypt/gcry_pk_decrypt "
                               "do not roundtrip\n");
                     }
 		}
 
               if (expect_mismatch)
                 fail ("gcry_pk_encrypt/gcry_pk_decrypt "
                       "expected mismatch did not happen\n");
 
 	      gcry_sexp_release (p1);
 	      gcry_sexp_release (p2);
 	    }
 	}
 
       gcry_sexp_release (plain);
       plain = NULL;
       gcry_sexp_release (ciph);
       ciph = NULL;
       gcry_sexp_release (data);
       data = NULL;
     }
 }
 
 static void
 check_pubkey_grip (int n, const unsigned char *grip,
 		   gcry_sexp_t skey, gcry_sexp_t pkey, int algo)
 {
   unsigned char sgrip[20], pgrip[20];
 
   (void)algo;
 
   if (!gcry_pk_get_keygrip (skey, sgrip))
     die ("get keygrip for private RSA key failed\n");
   if (!gcry_pk_get_keygrip (pkey, pgrip))
     die ("[%i] get keygrip for public RSA key failed\n", n);
   if (memcmp (sgrip, pgrip, 20))
     fail ("[%i] keygrips don't match\n", n);
   if (memcmp (sgrip, grip, 20))
     fail ("wrong keygrip for RSA key\n");
 }
 
 static void
 do_check_one_pubkey (int n, gcry_sexp_t skey, gcry_sexp_t pkey,
 		     const unsigned char *grip, int algo, int flags)
 {
  if (flags & FLAG_SIGN)
    {
      if (algo == GCRY_PK_ECDSA)
        check_pubkey_sign_ecdsa (n, skey, pkey);
      else
        check_pubkey_sign (n, skey, pkey, algo);
    }
  if (flags & FLAG_CRYPT)
    check_pubkey_crypt (n, skey, pkey, algo);
  if (grip && (flags & FLAG_GRIP))
    check_pubkey_grip (n, grip, skey, pkey, algo);
 }
 
 static void
 check_one_pubkey (int n, test_spec_pubkey_t spec)
 {
   gcry_error_t err = GPG_ERR_NO_ERROR;
   gcry_sexp_t skey, pkey;
 
   err = gcry_sexp_sscan (&skey, NULL, spec.key.secret,
 			 strlen (spec.key.secret));
   if (!err)
     err = gcry_sexp_sscan (&pkey, NULL, spec.key.public,
 			   strlen (spec.key.public));
   if (err)
     die ("converting sample key failed: %s\n", gpg_strerror (err));
 
   do_check_one_pubkey (n, skey, pkey,
                        (const unsigned char*)spec.key.grip,
 		       spec.id, spec.flags);
 
   gcry_sexp_release (skey);
   gcry_sexp_release (pkey);
 }
 
 static void
 get_keys_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
 {
   gcry_sexp_t key_spec, key, pub_key, sec_key;
   int rc;
   if (verbose)
     fprintf (stderr, "  generating RSA key:");
   rc = gcry_sexp_new (&key_spec,
 		      in_fips_mode ? "(genkey (rsa (nbits 4:2048)))"
                       : "(genkey (rsa (nbits 4:1024)(transient-key)))",
                       0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, key_spec);
   gcry_sexp_release (key_spec);
   if (rc)
     die ("error generating RSA key: %s\n", gpg_strerror (rc));
 
   pub_key = gcry_sexp_find_token (key, "public-key", 0);
   if (! pub_key)
     die ("public part missing in key\n");
 
   sec_key = gcry_sexp_find_token (key, "private-key", 0);
   if (! sec_key)
     die ("private part missing in key\n");
 
   gcry_sexp_release (key);
   *pkey = pub_key;
   *skey = sec_key;
 }
 
 static void
 check_one_pubkey_new (int n)
 {
   gcry_sexp_t skey, pkey;
 
   get_keys_new (&pkey, &skey);
   do_check_one_pubkey (n, skey, pkey, NULL,
 		       GCRY_PK_RSA, FLAG_SIGN | FLAG_CRYPT);
   gcry_sexp_release (pkey);
   gcry_sexp_release (skey);
 }
 
 /* Run all tests for the public key functions. */
 static void
 check_pubkey (void)
 {
   static const test_spec_pubkey_t pubkeys[] = {
   {
     GCRY_PK_RSA, FLAG_CRYPT | FLAG_SIGN,
     {
       "(private-key\n"
       " (rsa\n"
       "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
       "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
       "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
       "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea2"
       "      51#)\n"
       "  (e #010001#)\n"
       "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
       "      7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
       "      C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
       "      C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781"
       "      #)\n"
       "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
       "      fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424"
       "      f1#)\n"
       "  (q #00f7a7ca5367c661f8e62df34f0d05c10c88e5492348dd7bddc942c9a8f369f9"
       "      35a07785d2db805215ed786e4285df1658eed3ce84f469b81b50d358407b4ad3"
       "      61#)\n"
       "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
       "      ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b"
       "      #)))\n",
 
       "(public-key\n"
       " (rsa\n"
       "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
       "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
       "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
       "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea2"
       "      51#)\n"
       "  (e #010001#)))\n",
 
       "\x32\x10\x0c\x27\x17\x3e\xf6\xe9\xc4\xe9"
       "\xa2\x5d\x3d\x69\xf8\x6d\x37\xa4\xf9\x39"}
   },
   {
     GCRY_PK_DSA, FLAG_SIGN,
     {
       "(private-key\n"
       " (DSA\n"
       "  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
       "      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
       "      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
       "      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D877"
       "      7B#)\n"
       "  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)\n"
       "  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
       "      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
       "      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
       "      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15"
       "      #)\n"
       "  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
       "      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
       "      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
       "      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB"
       "      #)\n"
       "  (x #11D54E4ADBD3034160F2CED4B7CD292A4EBF3EC0#)))\n",
 
       "(public-key\n"
       " (DSA\n"
       "  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
       "      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
       "      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
       "      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D877"
       "      7B#)\n"
       "  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)\n"
       "  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
       "      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
       "      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
       "      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15"
       "      #)\n"
       "  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
       "      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
       "      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
       "      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB"
       "      #)))\n",
 
       "\xc6\x39\x83\x1a\x43\xe5\x05\x5d\xc6\xd8"
       "\x4a\xa6\xf9\xeb\x23\xbf\xa9\x12\x2d\x5b" }
   },
   {
     GCRY_PK_ELG, FLAG_SIGN | FLAG_CRYPT,
     {
       "(private-key\n"
       " (ELG\n"
       "  (p #00B93B93386375F06C2D38560F3B9C6D6D7B7506B20C1773F73F8DE56E6CD65D"
       "      F48DFAAA1E93F57A2789B168362A0F787320499F0B2461D3A4268757A7B27517"
       "      B7D203654A0CD484DEC6AF60C85FEB84AAC382EAF2047061FE5DAB81A20A0797"
       "      6E87359889BAE3B3600ED718BE61D4FC993CC8098A703DD0DC942E965E8F18D2"
       "      A7#)\n"
       "  (g #05#)\n"
       "  (y #72DAB3E83C9F7DD9A931FDECDC6522C0D36A6F0A0FEC955C5AC3C09175BBFF2B"
       "      E588DB593DC2E420201BEB3AC17536918417C497AC0F8657855380C1FCF11C5B"
       "      D20DB4BEE9BDF916648DE6D6E419FA446C513AAB81C30CB7B34D6007637BE675"
       "      56CE6473E9F9EE9B9FADD275D001563336F2186F424DEC6199A0F758F6A00FF4"
       "      #)\n"
       "  (x #03C28900087B38DABF4A0AB98ACEA39BB674D6557096C01D72E31C16BDD32214"
       "      #)))\n",
 
       "(public-key\n"
       " (ELG\n"
       "  (p #00B93B93386375F06C2D38560F3B9C6D6D7B7506B20C1773F73F8DE56E6CD65D"
       "      F48DFAAA1E93F57A2789B168362A0F787320499F0B2461D3A4268757A7B27517"
       "      B7D203654A0CD484DEC6AF60C85FEB84AAC382EAF2047061FE5DAB81A20A0797"
       "      6E87359889BAE3B3600ED718BE61D4FC993CC8098A703DD0DC942E965E8F18D2"
       "      A7#)\n"
       "  (g #05#)\n"
       "  (y #72DAB3E83C9F7DD9A931FDECDC6522C0D36A6F0A0FEC955C5AC3C09175BBFF2B"
       "      E588DB593DC2E420201BEB3AC17536918417C497AC0F8657855380C1FCF11C5B"
       "      D20DB4BEE9BDF916648DE6D6E419FA446C513AAB81C30CB7B34D6007637BE675"
       "      56CE6473E9F9EE9B9FADD275D001563336F2186F424DEC6199A0F758F6A00FF4"
       "      #)))\n",
 
       "\xa7\x99\x61\xeb\x88\x83\xd2\xf4\x05\xc8"
       "\x4f\xba\x06\xf8\x78\x09\xbc\x1e\x20\xe5" }
   },
   { /* ECDSA test.  */
     GCRY_PK_ECDSA, FLAG_SIGN,
     {
       "(private-key\n"
       " (ecdsa\n"
       "  (curve nistp192)\n"
       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
 
       "(public-key\n"
       " (ecdsa\n"
       "  (curve nistp192)\n"
       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
 
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
   },
   { /* ECDSA test with the public key algorithm given as "ecc".  */
     GCRY_PK_ECDSA, FLAG_SIGN,
     {
       "(private-key\n"
       " (ecdsa\n"
       "  (curve nistp192)\n"
       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
 
       "(public-key\n"
       " (ecc\n"
       "  (curve nistp192)\n"
       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
 
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
   },
   { /* ECDSA test with the private key algorithm given as "ecc".  */
     GCRY_PK_ECDSA, FLAG_SIGN,
     {
       "(private-key\n"
       " (ecc\n"
       "  (curve nistp192)\n"
       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
 
       "(public-key\n"
       " (ecdsa\n"
       "  (curve nistp192)\n"
       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
 
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
   },
   { /* ECDSA test with the key algorithms given as "ecc".  */
     GCRY_PK_ECDSA, FLAG_SIGN,
     {
       "(private-key\n"
       " (ecc\n"
       "  (curve nistp192)\n"
       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)\n"
       "  (d #00D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D#)))\n",
 
       "(public-key\n"
       " (ecc\n"
       "  (curve nistp192)\n"
       "  (q #048532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE"
       "        C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966#)))\n",
 
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
   },
   { /* ECDSA test 256 bit.  */
     GCRY_PK_ECDSA, FLAG_SIGN,
     {
       "(private-key\n"
       " (ecc\n"
       "  (curve nistp256)\n"
       "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2B"
       "      EB6644D3609FC781B71F9A8072F58CB66AE2F89BB1245187"
       "      3ABF7D91F9E1FBF96BF2F70E73AAC9A283#)\n"
       "  (d #5A1EF0035118F19F3110FB81813D3547BCE1E5BCE77D1F74"
       "      4715E1D5BBE70378#)))\n",
 
       "(public-key\n"
       " (ecc\n"
       "  (curve nistp256)\n"
       "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2B"
       "      EB6644D3609FC781B71F9A8072F58CB66AE2F89BB1245187"
       "      3ABF7D91F9E1FBF96BF2F70E73AAC9A283#)))\n",
 
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
   },
   { /* GOST R 34.10-2001/2012 test 256 bit.  */
     GCRY_PK_ECDSA, FLAG_SIGN,
     {
       "(private-key\n"
       " (ecc\n"
       "  (curve GOST2001-test)\n"
       "  (q #047F2B49E270DB6D90D8595BEC458B50C58585BA1D4E9B78"
       "      8F6689DBD8E56FD80B26F1B489D6701DD185C8413A977B3C"
       "      BBAF64D1C593D26627DFFB101A87FF77DA#)\n"
       "  (d #7A929ADE789BB9BE10ED359DD39A72C11B60961F49397EEE"
       "      1D19CE9891EC3B28#)))\n",
 
       "(public-key\n"
       " (ecc\n"
       "  (curve GOST2001-test)\n"
       "  (q #047F2B49E270DB6D90D8595BEC458B50C58585BA1D4E9B78"
       "      8F6689DBD8E56FD80B26F1B489D6701DD185C8413A977B3C"
       "      BBAF64D1C593D26627DFFB101A87FF77DA#)))\n",
 
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
   },
   { /* GOST R 34.10-2012 test 512 bit.  */
     GCRY_PK_ECDSA, FLAG_SIGN,
     {
       "(private-key\n"
       " (ecc\n"
       "  (curve GOST2012-test)\n"
       "  (q #04115DC5BC96760C7B48598D8AB9E740D4C4A85A65BE33C1"
       "        815B5C320C854621DD5A515856D13314AF69BC5B924C8B"
       "        4DDFF75C45415C1D9DD9DD33612CD530EFE137C7C90CD4"
       "        0B0F5621DC3AC1B751CFA0E2634FA0503B3D52639F5D7F"
       "        B72AFD61EA199441D943FFE7F0C70A2759A3CDB84C114E"
       "        1F9339FDF27F35ECA93677BEEC#)\n"
       "  (d #0BA6048AADAE241BA40936D47756D7C93091A0E851466970"
       "      0EE7508E508B102072E8123B2200A0563322DAD2827E2714"
       "      A2636B7BFD18AADFC62967821FA18DD4#)))\n",
 
       "(public-key\n"
       " (ecc\n"
       "  (curve GOST2012-test)\n"
       "  (q #04115DC5BC96760C7B48598D8AB9E740D4C4A85A65BE33C1"
       "        815B5C320C854621DD5A515856D13314AF69BC5B924C8B"
       "        4DDFF75C45415C1D9DD9DD33612CD530EFE137C7C90CD4"
       "        0B0F5621DC3AC1B751CFA0E2634FA0503B3D52639F5D7F"
       "        B72AFD61EA199441D943FFE7F0C70A2759A3CDB84C114E"
       "        1F9339FDF27F35ECA93677BEEC#)))\n"
 
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
   },
   { /* secp256k1 test 256 bit.  */
     GCRY_PK_ECDSA, FLAG_SIGN,
     {
       "(private-key\n"
       " (ecc\n"
       "  (curve secp256k1)\n"
       "  (q #0439A36013301597DAEF41FBE593A02CC513D0B55527EC2D"
       "      F1050E2E8FF49C85C23CBE7DED0E7CE6A594896B8F62888F"
       "      DBC5C8821305E2EA42BF01E37300116281#)\n"
       "  (d #E8F32E723DECF4051AEFAC8E2C93C9C5B214313817CDB01A"
       "      1494B917C8436B35#)))\n",
 
       "(public-key\n"
       " (ecc\n"
       "  (curve secp256k1)\n"
       "  (q #0439A36013301597DAEF41FBE593A02CC513D0B55527EC2D"
       "      F1050E2E8FF49C85C23CBE7DED0E7CE6A594896B8F62888F"
       "      DBC5C8821305E2EA42BF01E37300116281#)))\n"
 
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
     }
   };
   int i;
 
   if (verbose)
     fprintf (stderr, "Starting public key checks.\n");
   for (i = 0; i < sizeof (pubkeys) / sizeof (*pubkeys); i++)
     if (pubkeys[i].id)
       {
         if (gcry_pk_test_algo (pubkeys[i].id) && in_fips_mode)
           {
             if (verbose)
               fprintf (stderr, "  algorithm %d not available in fips mode\n",
                        pubkeys[i].id);
             continue;
           }
         check_one_pubkey (i, pubkeys[i]);
       }
   if (verbose)
     fprintf (stderr, "Completed public key checks.\n");
 
   if (verbose)
     fprintf (stderr, "Starting additional public key checks.\n");
   for (i = 0; i < sizeof (pubkeys) / sizeof (*pubkeys); i++)
     if (pubkeys[i].id)
       {
         if (gcry_pk_test_algo (pubkeys[i].id) && in_fips_mode)
           {
             if (verbose)
               fprintf (stderr, "  algorithm %d not available in fips mode\n",
                        pubkeys[i].id);
             continue;
           }
         check_one_pubkey_new (i);
       }
   if (verbose)
     fprintf (stderr, "Completed additional public key checks.\n");
 
 }
 
 int
 main (int argc, char **argv)
 {
   gpg_error_t err;
   int last_argc = -1;
   int use_fips = 0;
   int selftest_only = 0;
   int pubkey_only = 0;
   int cipher_modes_only = 0;
   int loop = 0;
   unsigned int loopcount = 0;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose = debug = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--fips"))
         {
           use_fips = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--selftest"))
         {
           selftest_only = 1;
           verbose += 2;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--pubkey"))
         {
           pubkey_only = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--cipher-modes"))
         {
           cipher_modes_only = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--die"))
         {
           die_on_error = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--loop"))
         {
           argc--; argv++;
           if (argc)
             {
               loop = atoi (*argv);
               argc--; argv++;
             }
         }
       else if (!strcmp (*argv, "--disable-hwf"))
         {
           argc--;
           argv++;
           if (argc)
             {
               if (gcry_control (GCRYCTL_DISABLE_HWF, *argv, NULL))
                 fprintf (stderr,
                         PGM
                         ": unknown hardware feature `%s' - option ignored\n",
                         *argv);
               argc--;
               argv++;
             }
         }
     }
 
-  xgcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
+  xgcry_control ((GCRYCTL_SET_VERBOSITY, (int)verbose));
 
   if (use_fips)
-    xgcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
+    xgcry_control ((GCRYCTL_FORCE_FIPS_MODE, 0));
 
   /* Check that we test exactly our version - including the patchlevel.  */
   if (strcmp (GCRYPT_VERSION, gcry_check_version (NULL)))
     die ("version mismatch; pgm=%s, library=%s\n",
          GCRYPT_VERSION,gcry_check_version (NULL));
 
   if ( gcry_fips_mode_active () )
     in_fips_mode = 1;
 
   if (!in_fips_mode)
-    xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+    xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
 
   if (verbose)
     gcry_set_progress_handler (progress_handler, NULL);
 
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
   /* No valuable keys are create, so we can speed up our RNG. */
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
 
   do
     {
       if (pubkey_only)
         check_pubkey ();
       else if (cipher_modes_only)
         {
           check_ciphers ();
           check_cipher_modes ();
         }
       else if (!selftest_only)
         {
           check_ciphers ();
           check_cipher_modes ();
           check_bulk_cipher_modes ();
           check_digests ();
           check_hmac ();
           check_mac ();
           check_pubkey ();
         }
       loopcount++;
       if (loop)
         {
           fprintf (stderr, "Test iteration %u completed.\n", loopcount);
           if (loop != -1)
             loop--;
         }
     }
   while (loop);
 
   if (in_fips_mode && !selftest_only)
     {
       /* If we are in fips mode do some more tests. */
       gcry_md_hd_t md;
 
       /* First trigger a self-test.  */
-      xgcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
+      xgcry_control ((GCRYCTL_FORCE_FIPS_MODE, 0));
       if (!gcry_control (GCRYCTL_OPERATIONAL_P, 0))
         fail ("not in operational state after self-test\n");
 
       /* Get us into the error state.  */
       err = gcry_md_open (&md, GCRY_MD_SHA1, 0);
       if (err)
         fail ("failed to open SHA-1 hash context: %s\n", gpg_strerror (err));
       else
         {
           err = gcry_md_enable (md, GCRY_MD_SHA256);
           if (err)
             fail ("failed to add SHA-256 hash context: %s\n",
                   gpg_strerror (err));
           else
             {
               /* gcry_md_get_algo is only defined for a context with
                  just one digest algorithm.  With our setup it should
                  put the oibrary intoerror state.  */
               fputs ("Note: Two lines with error messages follow "
                      "- this is expected\n", stderr);
               gcry_md_get_algo (md);
               gcry_md_close (md);
               if (gcry_control (GCRYCTL_OPERATIONAL_P, 0))
                 fail ("expected error state but still in operational state\n");
               else
                 {
                   /* Now run a self-test and to get back into
                      operational state.  */
-                  xgcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
+                  xgcry_control ((GCRYCTL_FORCE_FIPS_MODE, 0));
                   if (!gcry_control (GCRYCTL_OPERATIONAL_P, 0))
                     fail ("did not reach operational after error "
                           "and self-test\n");
                 }
             }
         }
 
     }
   else
     {
       /* If in standard mode, run selftests.  */
       if (gcry_control (GCRYCTL_SELFTEST, 0))
         fail ("running self-test failed\n");
     }
 
   if (verbose)
     fprintf (stderr, "\nAll tests completed. Errors: %i\n", error_count);
 
   if (in_fips_mode && !gcry_fips_mode_active ())
     fprintf (stderr, "FIPS mode is not anymore active\n");
 
   return error_count ? 1 : 0;
 }
diff --git a/tests/bench-slope.c b/tests/bench-slope.c
index 2ead3c9e..63f8f7ae 100644
--- a/tests/bench-slope.c
+++ b/tests/bench-slope.c
@@ -1,2363 +1,2363 @@
 /* bench-slope.c - for libgcrypt
  * Copyright (C) 2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser general Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <assert.h>
 #include <time.h>
 
 #ifdef _GCRYPT_IN_LIBGCRYPT
 # include "../src/gcrypt-int.h"
 # include "../compat/libcompat.h"
 #else
 # include <gcrypt.h>
 #endif
 
 #ifndef STR
 #define STR(v) #v
 #define STR2(v) STR(v)
 #endif
 
 #define PGM "bench-slope"
 #include "t-common.h"
 
 static int verbose;
 static int csv_mode;
 static int unaligned_mode;
 static int num_measurement_repetitions;
 
 /* CPU Ghz value provided by user, allows constructing cycles/byte and other
    results.  */
 static double cpu_ghz = -1;
 
 /* Attempt to autodetect CPU Ghz. */
 static int auto_ghz;
 
 /* Whether we are running as part of the regression test suite.  */
 static int in_regression_test;
 
 /* The name of the currently printed section.  */
 static char *current_section_name;
 /* The name of the currently printed algorithm.  */
 static char *current_algo_name;
 /* The name of the currently printed mode.  */
 static char *current_mode_name;
 
 
 /* Currently used CPU Ghz (either user input or auto-detected. */
 static double bench_ghz;
 
 /* Current accuracy of auto-detected CPU Ghz. */
 static double bench_ghz_diff;
 
 
 /*************************************** Default parameters for measurements. */
 
 /* Start at small buffer size, to get reasonable timer calibration for fast
  * implementations (AES-NI etc). Sixteen selected to support the largest block
  * size of current set cipher blocks. */
 #define BUF_START_SIZE			16
 
 /* From ~0 to ~4kbytes give comparable results with results from academia
  * (SUPERCOP). */
 #define BUF_END_SIZE			(BUF_START_SIZE + 4096)
 
 /* With 128 byte steps, we get (4096)/64 = 64 data points. */
 #define BUF_STEP_SIZE			64
 
 /* Number of repeated measurements at each data point. The median of these
  * measurements is selected as data point further analysis. */
 #define NUM_MEASUREMENT_REPETITIONS	64
 
 /* Target accuracy for auto-detected CPU Ghz. */
 #define AUTO_GHZ_TARGET_DIFF		(5e-5)
 
 /**************************************************** High-resolution timers. */
 
 /* This benchmarking module needs needs high resolution timer.  */
 #undef NO_GET_NSEC_TIME
 #if defined(_WIN32)
 struct nsec_time
 {
   LARGE_INTEGER perf_count;
 };
 
 static void
 get_nsec_time (struct nsec_time *t)
 {
   BOOL ok;
 
   ok = QueryPerformanceCounter (&t->perf_count);
   assert (ok);
 }
 
 static double
 get_time_nsec_diff (struct nsec_time *start, struct nsec_time *end)
 {
   static double nsecs_per_count = 0.0;
   double nsecs;
 
   if (nsecs_per_count == 0.0)
     {
       LARGE_INTEGER perf_freq;
       BOOL ok;
 
       /* Get counts per second. */
       ok = QueryPerformanceFrequency (&perf_freq);
       assert (ok);
 
       nsecs_per_count = 1.0 / perf_freq.QuadPart;
       nsecs_per_count *= 1000000.0 * 1000.0;	/* sec => nsec */
 
       assert (nsecs_per_count > 0.0);
     }
 
   nsecs = end->perf_count.QuadPart - start->perf_count.QuadPart;	/* counts */
   nsecs *= nsecs_per_count;	/* counts * (nsecs / count) => nsecs */
 
   return nsecs;
 }
 #elif defined(HAVE_CLOCK_GETTIME)
 struct nsec_time
 {
   struct timespec ts;
 };
 
 static void
 get_nsec_time (struct nsec_time *t)
 {
   int err;
 
   err = clock_gettime (CLOCK_REALTIME, &t->ts);
   assert (err == 0);
 }
 
 static double
 get_time_nsec_diff (struct nsec_time *start, struct nsec_time *end)
 {
   double nsecs;
 
   nsecs = end->ts.tv_sec - start->ts.tv_sec;
   nsecs *= 1000000.0 * 1000.0;	/* sec => nsec */
 
   /* This way we don't have to care if tv_nsec unsigned or signed. */
   if (end->ts.tv_nsec >= start->ts.tv_nsec)
     nsecs += end->ts.tv_nsec - start->ts.tv_nsec;
   else
     nsecs -= start->ts.tv_nsec - end->ts.tv_nsec;
 
   return nsecs;
 }
 #elif defined(HAVE_GETTIMEOFDAY)
 struct nsec_time
 {
   struct timeval tv;
 };
 
 static void
 get_nsec_time (struct nsec_time *t)
 {
   int err;
 
   err = gettimeofday (&t->tv, NULL);
   assert (err == 0);
 }
 
 static double
 get_time_nsec_diff (struct nsec_time *start, struct nsec_time *end)
 {
   double nsecs;
 
   nsecs = end->tv.tv_sec - start->tv.tv_sec;
   nsecs *= 1000000;		/* sec => µsec */
 
   /* This way we don't have to care if tv_usec unsigned or signed. */
   if (end->tv.tv_usec >= start->tv.tv_usec)
     nsecs += end->tv.tv_usec - start->tv.tv_usec;
   else
     nsecs -= start->tv.tv_usec - end->tv.tv_usec;
 
   nsecs *= 1000;		/* µsec => nsec */
 
   return nsecs;
 }
 #else
 #define NO_GET_NSEC_TIME 1
 #endif
 
 
 /* If no high resolution timer found, provide dummy bench-slope.  */
 #ifdef NO_GET_NSEC_TIME
 
 
 int
 main (void)
 {
   /* No nsec timer => SKIP test. */
   return 77;
 }
 
 
 #else /* !NO_GET_NSEC_TIME */
 
 
 /********************************************** Slope benchmarking framework. */
 
 struct bench_obj
 {
   const struct bench_ops *ops;
 
   unsigned int num_measure_repetitions;
   unsigned int min_bufsize;
   unsigned int max_bufsize;
   unsigned int step_size;
 
   void *priv;
   void *hd;
 };
 
 typedef int (*const bench_initialize_t) (struct bench_obj * obj);
 typedef void (*const bench_finalize_t) (struct bench_obj * obj);
 typedef void (*const bench_do_run_t) (struct bench_obj * obj, void *buffer,
 				      size_t buflen);
 
 struct bench_ops
 {
   bench_initialize_t initialize;
   bench_finalize_t finalize;
   bench_do_run_t do_run;
 };
 
 
 double
 get_slope (double (*const get_x) (unsigned int idx, void *priv),
 	   void *get_x_priv, double y_points[], unsigned int npoints,
 	   double *overhead)
 {
   double sumx, sumy, sumx2, sumy2, sumxy;
   unsigned int i;
   double b, a;
 
   sumx = sumy = sumx2 = sumy2 = sumxy = 0;
 
   for (i = 0; i < npoints; i++)
     {
       double x, y;
 
       x = get_x (i, get_x_priv);	/* bytes */
       y = y_points[i];		/* nsecs */
 
       sumx += x;
       sumy += y;
       sumx2 += x * x;
       /*sumy2 += y * y;*/
       sumxy += x * y;
     }
 
   b = (npoints * sumxy - sumx * sumy) / (npoints * sumx2 - sumx * sumx);
   a = (sumy - b * sumx) / npoints;
 
   if (overhead)
     *overhead = a;		/* nsecs */
 
   return b;			/* nsecs per byte */
 }
 
 
 double
 get_bench_obj_point_x (unsigned int idx, void *priv)
 {
   struct bench_obj *obj = priv;
   return (double) (obj->min_bufsize + (idx * obj->step_size));
 }
 
 
 unsigned int
 get_num_measurements (struct bench_obj *obj)
 {
   unsigned int buf_range = obj->max_bufsize - obj->min_bufsize;
   unsigned int num = buf_range / obj->step_size + 1;
 
   while (obj->min_bufsize + (num * obj->step_size) > obj->max_bufsize)
     num--;
 
   return num + 1;
 }
 
 
 static int
 double_cmp (const void *_a, const void *_b)
 {
   const double *a, *b;
 
   a = _a;
   b = _b;
 
   if (*a > *b)
     return 1;
   if (*a < *b)
     return -1;
   return 0;
 }
 
 
 double
 do_bench_obj_measurement (struct bench_obj *obj, void *buffer, size_t buflen,
 			  double *measurement_raw,
 			  unsigned int loop_iterations)
 {
   const unsigned int num_repetitions = obj->num_measure_repetitions;
   const bench_do_run_t do_run = obj->ops->do_run;
   struct nsec_time start, end;
   unsigned int rep, loop;
   double res;
 
   if (num_repetitions < 1 || loop_iterations < 1)
     return 0.0;
 
   for (rep = 0; rep < num_repetitions; rep++)
     {
       get_nsec_time (&start);
 
       for (loop = 0; loop < loop_iterations; loop++)
 	do_run (obj, buffer, buflen);
 
       get_nsec_time (&end);
 
       measurement_raw[rep] = get_time_nsec_diff (&start, &end);
     }
 
   /* Return median of repeated measurements. */
   qsort (measurement_raw, num_repetitions, sizeof (measurement_raw[0]),
 	 double_cmp);
 
   if (num_repetitions % 2 == 1)
     return measurement_raw[num_repetitions / 2];
 
   res = measurement_raw[num_repetitions / 2]
     + measurement_raw[num_repetitions / 2 - 1];
   return res / 2;
 }
 
 
 unsigned int
 adjust_loop_iterations_to_timer_accuracy (struct bench_obj *obj, void *buffer,
 					  double *measurement_raw)
 {
   const double increase_thres = 3.0;
   double tmp, nsecs;
   unsigned int loop_iterations;
   unsigned int test_bufsize;
 
   test_bufsize = obj->min_bufsize;
   if (test_bufsize == 0)
     test_bufsize += obj->step_size;
 
   loop_iterations = 0;
   do
     {
       /* Increase loop iterations until we get other results than zero.  */
       nsecs =
 	do_bench_obj_measurement (obj, buffer, test_bufsize,
 				  measurement_raw, ++loop_iterations);
     }
   while (nsecs < 1.0 - 0.1);
   do
     {
       /* Increase loop iterations until we get reasonable increase for elapsed time.  */
       tmp =
 	do_bench_obj_measurement (obj, buffer, test_bufsize,
 				  measurement_raw, ++loop_iterations);
     }
   while (tmp < nsecs * (increase_thres - 0.1));
 
   return loop_iterations;
 }
 
 
 /* Benchmark and return linear regression slope in nanoseconds per byte.  */
 double
 slope_benchmark (struct bench_obj *obj)
 {
   unsigned int num_measurements;
   double *measurements = NULL;
   double *measurement_raw = NULL;
   double slope, overhead;
   unsigned int loop_iterations, midx, i;
   unsigned char *real_buffer = NULL;
   unsigned char *buffer;
   size_t cur_bufsize;
   int err;
 
   err = obj->ops->initialize (obj);
   if (err < 0)
     return -1;
 
   num_measurements = get_num_measurements (obj);
   measurements = calloc (num_measurements, sizeof (*measurements));
   if (!measurements)
     goto err_free;
 
   measurement_raw =
     calloc (obj->num_measure_repetitions, sizeof (*measurement_raw));
   if (!measurement_raw)
     goto err_free;
 
   if (num_measurements < 1 || obj->num_measure_repetitions < 1 ||
       obj->max_bufsize < 1 || obj->min_bufsize > obj->max_bufsize)
     goto err_free;
 
   real_buffer = malloc (obj->max_bufsize + 128 + unaligned_mode);
   if (!real_buffer)
     goto err_free;
   /* Get aligned buffer */
   buffer = real_buffer;
   buffer += 128 - ((real_buffer - (unsigned char *) 0) & (128 - 1));
   if (unaligned_mode)
     buffer += unaligned_mode; /* Make buffer unaligned */
 
   for (i = 0; i < obj->max_bufsize; i++)
     buffer[i] = 0x55 ^ (-i);
 
   /* Adjust number of loop iterations up to timer accuracy.  */
   loop_iterations = adjust_loop_iterations_to_timer_accuracy (obj, buffer,
 							      measurement_raw);
 
   /* Perform measurements */
   for (midx = 0, cur_bufsize = obj->min_bufsize;
        cur_bufsize <= obj->max_bufsize; cur_bufsize += obj->step_size, midx++)
     {
       measurements[midx] =
 	do_bench_obj_measurement (obj, buffer, cur_bufsize, measurement_raw,
 				  loop_iterations);
       measurements[midx] /= loop_iterations;
     }
 
   assert (midx == num_measurements);
 
   slope =
     get_slope (&get_bench_obj_point_x, obj, measurements, num_measurements,
 	       &overhead);
 
   free (measurement_raw);
   free (measurements);
   free (real_buffer);
   obj->ops->finalize (obj);
 
   return slope;
 
 err_free:
   if (measurement_raw)
     free (measurement_raw);
   if (measurements)
     free (measurements);
   if (real_buffer)
     free (real_buffer);
   obj->ops->finalize (obj);
 
   return -1;
 }
 
 /********************************************* CPU frequency auto-detection. */
 
 static int
 auto_ghz_init (struct bench_obj *obj)
 {
   obj->min_bufsize = 16;
   obj->max_bufsize = 64 + obj->min_bufsize;
   obj->step_size = 8;
   obj->num_measure_repetitions = 16;
 
   return 0;
 }
 
 static void
 auto_ghz_free (struct bench_obj *obj)
 {
   (void)obj;
 }
 
 static void
 auto_ghz_bench (struct bench_obj *obj, void *buf, size_t buflen)
 {
   (void)obj;
   (void)buf;
 
   buflen *= 1024;
 
   /* Turbo frequency detection benchmark. Without CPU turbo-boost, this
    * function will give cycles/iteration result 1024.0 on high-end CPUs.
    * With turbo, result will be less and can be used detect turbo-clock. */
 
   do
     {
 #ifdef HAVE_GCC_ASM_VOLATILE_MEMORY
       /* Use memory barrier to prevent compiler from optimizing this loop
        * away. */
 
       asm volatile ("":::"memory");
 #else
       /* TODO: Needs alternative way. */
 #endif
     }
   while (--buflen);
 }
 
 static struct bench_ops auto_ghz_detect_ops = {
   &auto_ghz_init,
   &auto_ghz_free,
   &auto_ghz_bench
 };
 
 
 double
 get_auto_ghz (void)
 {
   struct bench_obj obj = { 0 };
   double nsecs_per_iteration;
   double cycles_per_iteration;
 
   obj.ops = &auto_ghz_detect_ops;
 
   nsecs_per_iteration = slope_benchmark (&obj);
 
   cycles_per_iteration = nsecs_per_iteration * cpu_ghz;
 
   /* Adjust CPU Ghz so that cycles per iteration would give '1024.0'. */
 
   return cpu_ghz * 1024 / cycles_per_iteration;
 }
 
 
 double
 do_slope_benchmark (struct bench_obj *obj)
 {
   double ret;
 
   if (!auto_ghz)
     {
       /* Perform measurement without autodetection of CPU frequency. */
 
       ret = slope_benchmark (obj);
 
       bench_ghz = cpu_ghz;
       bench_ghz_diff = 0;
     }
   else
     {
       double target_diff = AUTO_GHZ_TARGET_DIFF;
       double cpu_auto_ghz_before;
       double cpu_auto_ghz_after;
       double nsecs_per_iteration;
       double diff;
       unsigned int try_count = 0;
 
       /* Perform measurement with CPU frequency autodetection. */
 
       do
         {
           /* Repeat measurement until CPU turbo frequency has stabilized. */
 
 	  if (try_count++ > 4)
 	    {
 	      /* Too much frequency instability on the system, relax target
 	       * accuracy. */
 
 	      try_count = 0;
 	      target_diff *= 2;
 	    }
 
           cpu_auto_ghz_before = get_auto_ghz ();
 
           nsecs_per_iteration = slope_benchmark (obj);
 
           cpu_auto_ghz_after = get_auto_ghz ();
 
           diff = 1.0 - (cpu_auto_ghz_before / cpu_auto_ghz_after);
           diff = diff < 0 ? -diff : diff;
         }
       while (diff > target_diff);
 
       ret = nsecs_per_iteration;
 
       bench_ghz = (cpu_auto_ghz_before + cpu_auto_ghz_after) / 2;
       bench_ghz_diff = diff;
     }
 
   return ret;
 }
 
 
 /********************************************************** Printing results. */
 
 static void
 double_to_str (char *out, size_t outlen, double value)
 {
   const char *fmt;
 
   if (value < 1.0)
     fmt = "%.3f";
   else if (value < 100.0)
     fmt = "%.2f";
   else if (value < 1000.0)
     fmt = "%.1f";
   else
     fmt = "%.0f";
 
   snprintf (out, outlen, fmt, value);
 }
 
 static void
 bench_print_result_csv (double nsecs_per_byte)
 {
   double cycles_per_byte, mbytes_per_sec;
   char nsecpbyte_buf[16];
   char mbpsec_buf[16];
   char cpbyte_buf[16];
   char mhz_buf[16];
   char mhz_diff_buf[32];
 
   strcpy (mhz_diff_buf, "");
   *cpbyte_buf = 0;
   *mhz_buf = 0;
 
   double_to_str (nsecpbyte_buf, sizeof (nsecpbyte_buf), nsecs_per_byte);
 
   /* If user didn't provide CPU speed, we cannot show cycles/byte results.  */
   if (bench_ghz > 0.0)
     {
       cycles_per_byte = nsecs_per_byte * bench_ghz;
       double_to_str (cpbyte_buf, sizeof (cpbyte_buf), cycles_per_byte);
       double_to_str (mhz_buf, sizeof (mhz_buf), bench_ghz * 1000);
       if (auto_ghz && bench_ghz_diff * 1000 >= 1)
 	{
 	  snprintf(mhz_diff_buf, sizeof(mhz_diff_buf), ",%.0f,Mhz-diff",
 		   bench_ghz_diff * 1000);
 	}
     }
 
   mbytes_per_sec =
     (1000.0 * 1000.0 * 1000.0) / (nsecs_per_byte * 1024 * 1024);
   double_to_str (mbpsec_buf, sizeof (mbpsec_buf), mbytes_per_sec);
 
   /* We print two empty fields to allow for future enhancements.  */
   if (auto_ghz)
     {
       printf ("%s,%s,%s,,,%s,ns/B,%s,MiB/s,%s,c/B,%s,Mhz%s\n",
               current_section_name,
               current_algo_name? current_algo_name : "",
               current_mode_name? current_mode_name : "",
               nsecpbyte_buf,
               mbpsec_buf,
               cpbyte_buf,
               mhz_buf,
               mhz_diff_buf);
     }
   else
     {
       printf ("%s,%s,%s,,,%s,ns/B,%s,MiB/s,%s,c/B\n",
               current_section_name,
               current_algo_name? current_algo_name : "",
               current_mode_name? current_mode_name : "",
               nsecpbyte_buf,
               mbpsec_buf,
               cpbyte_buf);
     }
 }
 
 static void
 bench_print_result_std (double nsecs_per_byte)
 {
   double cycles_per_byte, mbytes_per_sec;
   char nsecpbyte_buf[16];
   char mbpsec_buf[16];
   char cpbyte_buf[16];
   char mhz_buf[16];
   char mhz_diff_buf[32];
 
   strcpy (mhz_diff_buf, "");
 
   double_to_str (nsecpbyte_buf, sizeof (nsecpbyte_buf), nsecs_per_byte);
 
   /* If user didn't provide CPU speed, we cannot show cycles/byte results.  */
   if (bench_ghz > 0.0)
     {
       cycles_per_byte = nsecs_per_byte * bench_ghz;
       double_to_str (cpbyte_buf, sizeof (cpbyte_buf), cycles_per_byte);
       double_to_str (mhz_buf, sizeof (mhz_buf), bench_ghz * 1000);
       if (auto_ghz && bench_ghz_diff * 1000 >= 0.5)
 	{
 	  snprintf(mhz_diff_buf, sizeof(mhz_diff_buf), "±%.0f",
 		   bench_ghz_diff * 1000);
 	}
     }
   else
     {
       strcpy (cpbyte_buf, "-");
       strcpy (mhz_buf, "-");
     }
 
   mbytes_per_sec =
     (1000.0 * 1000.0 * 1000.0) / (nsecs_per_byte * 1024 * 1024);
   double_to_str (mbpsec_buf, sizeof (mbpsec_buf), mbytes_per_sec);
 
   if (auto_ghz)
     {
       printf ("%9s ns/B %9s MiB/s %9s c/B %9s%s\n",
               nsecpbyte_buf, mbpsec_buf, cpbyte_buf, mhz_buf, mhz_diff_buf);
     }
   else
     {
       printf ("%9s ns/B %9s MiB/s %9s c/B\n",
               nsecpbyte_buf, mbpsec_buf, cpbyte_buf);
     }
 }
 
 static void
 bench_print_result (double nsecs_per_byte)
 {
   if (csv_mode)
     bench_print_result_csv (nsecs_per_byte);
   else
     bench_print_result_std (nsecs_per_byte);
 }
 
 static void
 bench_print_section (const char *section_name, const char *print_name)
 {
   if (csv_mode)
     {
       gcry_free (current_section_name);
       current_section_name = gcry_xstrdup (section_name);
     }
   else
     printf ("%s:\n", print_name);
 }
 
 static void
 bench_print_header (int algo_width, const char *algo_name)
 {
   if (csv_mode)
     {
       gcry_free (current_algo_name);
       current_algo_name = gcry_xstrdup (algo_name);
     }
   else
     {
       if (algo_width < 0)
         printf (" %-*s | ", -algo_width, algo_name);
       else
         printf (" %-*s | ", algo_width, algo_name);
 
       if (auto_ghz)
         printf ("%14s %15s %13s %9s\n", "nanosecs/byte", "mebibytes/sec",
                 "cycles/byte", "auto Mhz");
       else
         printf ("%14s %15s %13s\n", "nanosecs/byte", "mebibytes/sec",
                 "cycles/byte");
     }
 }
 
 static void
 bench_print_algo (int algo_width, const char *algo_name)
 {
   if (csv_mode)
     {
       gcry_free (current_algo_name);
       current_algo_name = gcry_xstrdup (algo_name);
     }
   else
     {
       if (algo_width < 0)
         printf (" %-*s | ", -algo_width, algo_name);
       else
         printf (" %-*s | ", algo_width, algo_name);
     }
 }
 
 static void
 bench_print_mode (int width, const char *mode_name)
 {
   if (csv_mode)
     {
       gcry_free (current_mode_name);
       current_mode_name = gcry_xstrdup (mode_name);
     }
   else
     {
       if (width < 0)
         printf (" %-*s | ", -width, mode_name);
       else
         printf (" %*s | ", width, mode_name);
       fflush (stdout);
     }
 }
 
 static void
 bench_print_footer (int algo_width)
 {
   if (!csv_mode)
     printf (" %-*s =\n", algo_width, "");
 }
 
 
 /********************************************************* Cipher benchmarks. */
 
 struct bench_cipher_mode
 {
   int mode;
   const char *name;
   struct bench_ops *ops;
 
   int algo;
 };
 
 
 static int
 bench_encrypt_init (struct bench_obj *obj)
 {
   struct bench_cipher_mode *mode = obj->priv;
   gcry_cipher_hd_t hd;
   int err, keylen;
 
   obj->min_bufsize = BUF_START_SIZE;
   obj->max_bufsize = BUF_END_SIZE;
   obj->step_size = BUF_STEP_SIZE;
   obj->num_measure_repetitions = num_measurement_repetitions;
 
   err = gcry_cipher_open (&hd, mode->algo, mode->mode, 0);
   if (err)
     {
       fprintf (stderr, PGM ": error opening cipher `%s'\n",
 	       gcry_cipher_algo_name (mode->algo));
       exit (1);
     }
 
   keylen = gcry_cipher_get_algo_keylen (mode->algo);
   if (keylen)
     {
       char key[keylen];
       int i;
 
       for (i = 0; i < keylen; i++)
 	key[i] = 0x33 ^ (11 - i);
 
       err = gcry_cipher_setkey (hd, key, keylen);
       if (err)
 	{
 	  fprintf (stderr, PGM ": gcry_cipher_setkey failed: %s\n",
 		   gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  exit (1);
 	}
     }
   else
     {
       fprintf (stderr, PGM ": failed to get key length for algorithm `%s'\n",
 	       gcry_cipher_algo_name (mode->algo));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   obj->hd = hd;
 
   return 0;
 }
 
 static void
 bench_encrypt_free (struct bench_obj *obj)
 {
   gcry_cipher_hd_t hd = obj->hd;
 
   gcry_cipher_close (hd);
 }
 
 static void
 bench_encrypt_do_bench (struct bench_obj *obj, void *buf, size_t buflen)
 {
   gcry_cipher_hd_t hd = obj->hd;
   int err;
 
   err = gcry_cipher_reset (hd);
   if (!err)
     err = gcry_cipher_encrypt (hd, buf, buflen, buf, buflen);
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_encrypt failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 }
 
 static void
 bench_decrypt_do_bench (struct bench_obj *obj, void *buf, size_t buflen)
 {
   gcry_cipher_hd_t hd = obj->hd;
   int err;
 
   err = gcry_cipher_reset (hd);
   if (!err)
     err = gcry_cipher_decrypt (hd, buf, buflen, buf, buflen);
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_encrypt failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 }
 
 static struct bench_ops encrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_encrypt_do_bench
 };
 
 static struct bench_ops decrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_decrypt_do_bench
 };
 
 
 static int
 bench_xts_encrypt_init (struct bench_obj *obj)
 {
   struct bench_cipher_mode *mode = obj->priv;
   gcry_cipher_hd_t hd;
   int err, keylen;
 
   /* For XTS, benchmark with typical data-unit size (512 byte sectors). */
   obj->min_bufsize = 512;
   obj->max_bufsize = 16 * obj->min_bufsize;
   obj->step_size = obj->min_bufsize;
   obj->num_measure_repetitions = num_measurement_repetitions;
 
   err = gcry_cipher_open (&hd, mode->algo, mode->mode, 0);
   if (err)
     {
       fprintf (stderr, PGM ": error opening cipher `%s'\n",
 	       gcry_cipher_algo_name (mode->algo));
       exit (1);
     }
 
   /* Double key-length for XTS. */
   keylen = gcry_cipher_get_algo_keylen (mode->algo) * 2;
   if (keylen)
     {
       char key[keylen];
       int i;
 
       for (i = 0; i < keylen; i++)
 	key[i] = 0x33 ^ (11 - i);
 
       err = gcry_cipher_setkey (hd, key, keylen);
       if (err)
 	{
 	  fprintf (stderr, PGM ": gcry_cipher_setkey failed: %s\n",
 		   gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  exit (1);
 	}
     }
   else
     {
       fprintf (stderr, PGM ": failed to get key length for algorithm `%s'\n",
 	       gcry_cipher_algo_name (mode->algo));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   obj->hd = hd;
 
   return 0;
 }
 
 static void
 bench_xts_encrypt_do_bench (struct bench_obj *obj, void *buf, size_t buflen)
 {
   gcry_cipher_hd_t hd = obj->hd;
   unsigned int pos;
   static const char tweak[16] = { 0xff, 0xff, 0xfe, };
   size_t sectorlen = obj->step_size;
   char *cbuf = buf;
   int err;
 
   gcry_cipher_setiv (hd, tweak, sizeof (tweak));
 
   /* Process each sector separately. */
 
   for (pos = 0; pos < buflen; pos += sectorlen, cbuf += sectorlen)
     {
       err = gcry_cipher_encrypt (hd, cbuf, sectorlen, cbuf, sectorlen);
       if (err)
 	{
 	  fprintf (stderr, PGM ": gcry_cipher_encrypt failed: %s\n",
 		  gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  exit (1);
 	}
     }
 }
 
 static void
 bench_xts_decrypt_do_bench (struct bench_obj *obj, void *buf, size_t buflen)
 {
   gcry_cipher_hd_t hd = obj->hd;
   unsigned int pos;
   static const char tweak[16] = { 0xff, 0xff, 0xfe, };
   size_t sectorlen = obj->step_size;
   char *cbuf = buf;
   int err;
 
   gcry_cipher_setiv (hd, tweak, sizeof (tweak));
 
   /* Process each sector separately. */
 
   for (pos = 0; pos < buflen; pos += sectorlen, cbuf += sectorlen)
     {
       err = gcry_cipher_decrypt (hd, cbuf, sectorlen, cbuf, sectorlen);
       if (err)
 	{
 	  fprintf (stderr, PGM ": gcry_cipher_encrypt failed: %s\n",
 		  gpg_strerror (err));
 	  gcry_cipher_close (hd);
 	  exit (1);
 	}
     }
 }
 
 static struct bench_ops xts_encrypt_ops = {
   &bench_xts_encrypt_init,
   &bench_encrypt_free,
   &bench_xts_encrypt_do_bench
 };
 
 static struct bench_ops xts_decrypt_ops = {
   &bench_xts_encrypt_init,
   &bench_encrypt_free,
   &bench_xts_decrypt_do_bench
 };
 
 
 static void
 bench_ccm_encrypt_do_bench (struct bench_obj *obj, void *buf, size_t buflen)
 {
   gcry_cipher_hd_t hd = obj->hd;
   int err;
   char tag[8];
   char nonce[11] = { 0x80, 0x01, };
   u64 params[3];
 
   gcry_cipher_setiv (hd, nonce, sizeof (nonce));
 
   /* Set CCM lengths */
   params[0] = buflen;
   params[1] = 0;		/*aadlen */
   params[2] = sizeof (tag);
   err =
     gcry_cipher_ctl (hd, GCRYCTL_SET_CCM_LENGTHS, params, sizeof (params));
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_ctl failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   err = gcry_cipher_encrypt (hd, buf, buflen, buf, buflen);
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_encrypt failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   err = gcry_cipher_gettag (hd, tag, sizeof (tag));
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_gettag failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 }
 
 static void
 bench_ccm_decrypt_do_bench (struct bench_obj *obj, void *buf, size_t buflen)
 {
   gcry_cipher_hd_t hd = obj->hd;
   int err;
   char tag[8] = { 0, };
   char nonce[11] = { 0x80, 0x01, };
   u64 params[3];
 
   gcry_cipher_setiv (hd, nonce, sizeof (nonce));
 
   /* Set CCM lengths */
   params[0] = buflen;
   params[1] = 0;		/*aadlen */
   params[2] = sizeof (tag);
   err =
     gcry_cipher_ctl (hd, GCRYCTL_SET_CCM_LENGTHS, params, sizeof (params));
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_ctl failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   err = gcry_cipher_decrypt (hd, buf, buflen, buf, buflen);
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_encrypt failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   err = gcry_cipher_checktag (hd, tag, sizeof (tag));
   if (gpg_err_code (err) == GPG_ERR_CHECKSUM)
     err = gpg_error (GPG_ERR_NO_ERROR);
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_gettag failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 }
 
 static void
 bench_ccm_authenticate_do_bench (struct bench_obj *obj, void *buf,
 				 size_t buflen)
 {
   gcry_cipher_hd_t hd = obj->hd;
   int err;
   char tag[8] = { 0, };
   char nonce[11] = { 0x80, 0x01, };
   u64 params[3];
   char data = 0xff;
 
   gcry_cipher_setiv (hd, nonce, sizeof (nonce));
 
   /* Set CCM lengths */
   params[0] = sizeof (data);	/*datalen */
   params[1] = buflen;		/*aadlen */
   params[2] = sizeof (tag);
   err =
     gcry_cipher_ctl (hd, GCRYCTL_SET_CCM_LENGTHS, params, sizeof (params));
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_ctl failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   err = gcry_cipher_authenticate (hd, buf, buflen);
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_authenticate failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   err = gcry_cipher_encrypt (hd, &data, sizeof (data), &data, sizeof (data));
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_encrypt failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   err = gcry_cipher_gettag (hd, tag, sizeof (tag));
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_gettag failed: %s\n",
 	       gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 }
 
 static struct bench_ops ccm_encrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_ccm_encrypt_do_bench
 };
 
 static struct bench_ops ccm_decrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_ccm_decrypt_do_bench
 };
 
 static struct bench_ops ccm_authenticate_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_ccm_authenticate_do_bench
 };
 
 
 static void
 bench_aead_encrypt_do_bench (struct bench_obj *obj, void *buf, size_t buflen,
 			     const char *nonce, size_t noncelen)
 {
   gcry_cipher_hd_t hd = obj->hd;
   int err;
   char tag[16];
 
   gcry_cipher_setiv (hd, nonce, noncelen);
 
   gcry_cipher_final (hd);
   err = gcry_cipher_encrypt (hd, buf, buflen, buf, buflen);
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_encrypt failed: %s\n",
            gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   err = gcry_cipher_gettag (hd, tag, sizeof (tag));
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_gettag failed: %s\n",
            gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 }
 
 static void
 bench_aead_decrypt_do_bench (struct bench_obj *obj, void *buf, size_t buflen,
 			     const char *nonce, size_t noncelen)
 {
   gcry_cipher_hd_t hd = obj->hd;
   int err;
   char tag[16] = { 0, };
 
   gcry_cipher_setiv (hd, nonce, noncelen);
 
   gcry_cipher_final (hd);
   err = gcry_cipher_decrypt (hd, buf, buflen, buf, buflen);
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_encrypt failed: %s\n",
            gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   err = gcry_cipher_checktag (hd, tag, sizeof (tag));
   if (gpg_err_code (err) == GPG_ERR_CHECKSUM)
     err = gpg_error (GPG_ERR_NO_ERROR);
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_gettag failed: %s\n",
            gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 }
 
 static void
 bench_aead_authenticate_do_bench (struct bench_obj *obj, void *buf,
 				  size_t buflen, const char *nonce,
 				  size_t noncelen)
 {
   gcry_cipher_hd_t hd = obj->hd;
   int err;
   char tag[16] = { 0, };
   char data = 0xff;
 
   err = gcry_cipher_setiv (hd, nonce, noncelen);
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_setiv failed: %s\n",
            gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   err = gcry_cipher_authenticate (hd, buf, buflen);
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_authenticate failed: %s\n",
            gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   gcry_cipher_final (hd);
   err = gcry_cipher_encrypt (hd, &data, sizeof (data), &data, sizeof (data));
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_encrypt failed: %s\n",
            gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   err = gcry_cipher_gettag (hd, tag, sizeof (tag));
   if (err)
     {
       fprintf (stderr, PGM ": gcry_cipher_gettag failed: %s\n",
            gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 }
 
 
 static void
 bench_gcm_encrypt_do_bench (struct bench_obj *obj, void *buf,
 			    size_t buflen)
 {
   char nonce[12] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce,
                      0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88 };
   bench_aead_encrypt_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static void
 bench_gcm_decrypt_do_bench (struct bench_obj *obj, void *buf,
 			    size_t buflen)
 {
   char nonce[12] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce,
                      0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88 };
   bench_aead_decrypt_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static void
 bench_gcm_authenticate_do_bench (struct bench_obj *obj, void *buf,
 				 size_t buflen)
 {
   char nonce[12] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce,
                      0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88 };
   bench_aead_authenticate_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static struct bench_ops gcm_encrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_gcm_encrypt_do_bench
 };
 
 static struct bench_ops gcm_decrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_gcm_decrypt_do_bench
 };
 
 static struct bench_ops gcm_authenticate_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_gcm_authenticate_do_bench
 };
 
 
 static void
 bench_ocb_encrypt_do_bench (struct bench_obj *obj, void *buf,
 			    size_t buflen)
 {
   char nonce[15] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce,
                      0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88,
                      0x00, 0x00, 0x01 };
   bench_aead_encrypt_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static void
 bench_ocb_decrypt_do_bench (struct bench_obj *obj, void *buf,
 			    size_t buflen)
 {
   char nonce[15] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce,
                      0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88,
                      0x00, 0x00, 0x01 };
   bench_aead_decrypt_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static void
 bench_ocb_authenticate_do_bench (struct bench_obj *obj, void *buf,
 				 size_t buflen)
 {
   char nonce[15] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce,
                      0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88,
                      0x00, 0x00, 0x01 };
   bench_aead_authenticate_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static struct bench_ops ocb_encrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_ocb_encrypt_do_bench
 };
 
 static struct bench_ops ocb_decrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_ocb_decrypt_do_bench
 };
 
 static struct bench_ops ocb_authenticate_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_ocb_authenticate_do_bench
 };
 
 static void
 bench_eax_encrypt_do_bench (struct bench_obj *obj, void *buf,
 			    size_t buflen)
 {
   char nonce[16] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce,
                      0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88,
                      0x00, 0x00, 0x01, 0x00 };
   bench_aead_encrypt_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static void
 bench_eax_decrypt_do_bench (struct bench_obj *obj, void *buf,
 			    size_t buflen)
 {
   char nonce[16] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce,
                      0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88,
                      0x00, 0x00, 0x01, 0x00 };
   bench_aead_decrypt_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static void
 bench_eax_authenticate_do_bench (struct bench_obj *obj, void *buf,
 				 size_t buflen)
 {
   char nonce[16] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce,
                      0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88,
                      0x00, 0x00, 0x01, 0x00 };
   bench_aead_authenticate_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static struct bench_ops eax_encrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_eax_encrypt_do_bench
 };
 
 static struct bench_ops eax_decrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_eax_decrypt_do_bench
 };
 
 static struct bench_ops eax_authenticate_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_eax_authenticate_do_bench
 };
 
 static void
 bench_poly1305_encrypt_do_bench (struct bench_obj *obj, void *buf,
 				 size_t buflen)
 {
   char nonce[8] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad };
   bench_aead_encrypt_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static void
 bench_poly1305_decrypt_do_bench (struct bench_obj *obj, void *buf,
 				 size_t buflen)
 {
   char nonce[8] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad };
   bench_aead_decrypt_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static void
 bench_poly1305_authenticate_do_bench (struct bench_obj *obj, void *buf,
 				      size_t buflen)
 {
   char nonce[8] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad };
   bench_aead_authenticate_do_bench (obj, buf, buflen, nonce, sizeof(nonce));
 }
 
 static struct bench_ops poly1305_encrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_poly1305_encrypt_do_bench
 };
 
 static struct bench_ops poly1305_decrypt_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_poly1305_decrypt_do_bench
 };
 
 static struct bench_ops poly1305_authenticate_ops = {
   &bench_encrypt_init,
   &bench_encrypt_free,
   &bench_poly1305_authenticate_do_bench
 };
 
 
 static struct bench_cipher_mode cipher_modes[] = {
   {GCRY_CIPHER_MODE_ECB, "ECB enc", &encrypt_ops},
   {GCRY_CIPHER_MODE_ECB, "ECB dec", &decrypt_ops},
   {GCRY_CIPHER_MODE_CBC, "CBC enc", &encrypt_ops},
   {GCRY_CIPHER_MODE_CBC, "CBC dec", &decrypt_ops},
   {GCRY_CIPHER_MODE_CFB, "CFB enc", &encrypt_ops},
   {GCRY_CIPHER_MODE_CFB, "CFB dec", &decrypt_ops},
   {GCRY_CIPHER_MODE_OFB, "OFB enc", &encrypt_ops},
   {GCRY_CIPHER_MODE_OFB, "OFB dec", &decrypt_ops},
   {GCRY_CIPHER_MODE_CTR, "CTR enc", &encrypt_ops},
   {GCRY_CIPHER_MODE_CTR, "CTR dec", &decrypt_ops},
   {GCRY_CIPHER_MODE_XTS, "XTS enc", &xts_encrypt_ops},
   {GCRY_CIPHER_MODE_XTS, "XTS dec", &xts_decrypt_ops},
   {GCRY_CIPHER_MODE_CCM, "CCM enc", &ccm_encrypt_ops},
   {GCRY_CIPHER_MODE_CCM, "CCM dec", &ccm_decrypt_ops},
   {GCRY_CIPHER_MODE_CCM, "CCM auth", &ccm_authenticate_ops},
   {GCRY_CIPHER_MODE_EAX, "EAX enc",  &eax_encrypt_ops},
   {GCRY_CIPHER_MODE_EAX, "EAX dec",  &eax_decrypt_ops},
   {GCRY_CIPHER_MODE_EAX, "EAX auth", &eax_authenticate_ops},
   {GCRY_CIPHER_MODE_GCM, "GCM enc", &gcm_encrypt_ops},
   {GCRY_CIPHER_MODE_GCM, "GCM dec", &gcm_decrypt_ops},
   {GCRY_CIPHER_MODE_GCM, "GCM auth", &gcm_authenticate_ops},
   {GCRY_CIPHER_MODE_OCB, "OCB enc",  &ocb_encrypt_ops},
   {GCRY_CIPHER_MODE_OCB, "OCB dec",  &ocb_decrypt_ops},
   {GCRY_CIPHER_MODE_OCB, "OCB auth", &ocb_authenticate_ops},
   {GCRY_CIPHER_MODE_POLY1305, "POLY1305 enc", &poly1305_encrypt_ops},
   {GCRY_CIPHER_MODE_POLY1305, "POLY1305 dec", &poly1305_decrypt_ops},
   {GCRY_CIPHER_MODE_POLY1305, "POLY1305 auth", &poly1305_authenticate_ops},
   {0},
 };
 
 
 static void
 cipher_bench_one (int algo, struct bench_cipher_mode *pmode)
 {
   struct bench_cipher_mode mode = *pmode;
   struct bench_obj obj = { 0 };
   double result;
   unsigned int blklen;
 
   mode.algo = algo;
 
   /* Check if this mode is ok */
   blklen = gcry_cipher_get_algo_blklen (algo);
   if (!blklen)
     return;
 
   /* Stream cipher? Only test with "ECB" and POLY1305. */
   if (blklen == 1 && (mode.mode != GCRY_CIPHER_MODE_ECB &&
 		      mode.mode != GCRY_CIPHER_MODE_POLY1305))
     return;
   if (blklen == 1 && mode.mode == GCRY_CIPHER_MODE_ECB)
     {
       mode.mode = GCRY_CIPHER_MODE_STREAM;
       mode.name = mode.ops == &encrypt_ops ? "STREAM enc" : "STREAM dec";
     }
 
   /* Poly1305 has restriction for cipher algorithm */
   if (mode.mode == GCRY_CIPHER_MODE_POLY1305 && algo != GCRY_CIPHER_CHACHA20)
     return;
 
   /* CCM has restrictions for block-size */
   if (mode.mode == GCRY_CIPHER_MODE_CCM && blklen != GCRY_CCM_BLOCK_LEN)
     return;
 
   /* GCM has restrictions for block-size */
   if (mode.mode == GCRY_CIPHER_MODE_GCM && blklen != GCRY_GCM_BLOCK_LEN)
     return;
 
   /* XTS has restrictions for block-size */
   if (mode.mode == GCRY_CIPHER_MODE_XTS && blklen != GCRY_XTS_BLOCK_LEN)
     return;
 
   /* Our OCB implementation has restrictions for block-size.  */
   if (mode.mode == GCRY_CIPHER_MODE_OCB && blklen != GCRY_OCB_BLOCK_LEN)
     return;
 
   bench_print_mode (14, mode.name);
 
   obj.ops = mode.ops;
   obj.priv = &mode;
 
   result = do_slope_benchmark (&obj);
 
   bench_print_result (result);
 }
 
 
 static void
 _cipher_bench (int algo)
 {
   const char *algoname;
   int i;
 
   algoname = gcry_cipher_algo_name (algo);
 
   bench_print_header (14, algoname);
 
   for (i = 0; cipher_modes[i].mode; i++)
     cipher_bench_one (algo, &cipher_modes[i]);
 
   bench_print_footer (14);
 }
 
 
 void
 cipher_bench (char **argv, int argc)
 {
   int i, algo;
 
   bench_print_section ("cipher", "Cipher");
 
   if (argv && argc)
     {
       for (i = 0; i < argc; i++)
         {
           algo = gcry_cipher_map_name (argv[i]);
           if (algo)
             _cipher_bench (algo);
         }
     }
   else
     {
       for (i = 1; i < 400; i++)
         if (!gcry_cipher_test_algo (i))
           _cipher_bench (i);
     }
 }
 
 
 /*********************************************************** Hash benchmarks. */
 
 struct bench_hash_mode
 {
   const char *name;
   struct bench_ops *ops;
 
   int algo;
 };
 
 
 static int
 bench_hash_init (struct bench_obj *obj)
 {
   struct bench_hash_mode *mode = obj->priv;
   gcry_md_hd_t hd;
   int err;
 
   obj->min_bufsize = BUF_START_SIZE;
   obj->max_bufsize = BUF_END_SIZE;
   obj->step_size = BUF_STEP_SIZE;
   obj->num_measure_repetitions = num_measurement_repetitions;
 
   err = gcry_md_open (&hd, mode->algo, 0);
   if (err)
     {
       fprintf (stderr, PGM ": error opening hash `%s'\n",
 	       gcry_md_algo_name (mode->algo));
       exit (1);
     }
 
   obj->hd = hd;
 
   return 0;
 }
 
 static void
 bench_hash_free (struct bench_obj *obj)
 {
   gcry_md_hd_t hd = obj->hd;
 
   gcry_md_close (hd);
 }
 
 static void
 bench_hash_do_bench (struct bench_obj *obj, void *buf, size_t buflen)
 {
   gcry_md_hd_t hd = obj->hd;
 
   gcry_md_reset (hd);
   gcry_md_write (hd, buf, buflen);
   gcry_md_final (hd);
 }
 
 static struct bench_ops hash_ops = {
   &bench_hash_init,
   &bench_hash_free,
   &bench_hash_do_bench
 };
 
 
 static struct bench_hash_mode hash_modes[] = {
   {"", &hash_ops},
   {0},
 };
 
 
 static void
 hash_bench_one (int algo, struct bench_hash_mode *pmode)
 {
   struct bench_hash_mode mode = *pmode;
   struct bench_obj obj = { 0 };
   double result;
 
   mode.algo = algo;
 
   if (mode.name[0] == '\0')
     bench_print_algo (-14, gcry_md_algo_name (algo));
   else
     bench_print_algo (14, mode.name);
 
   obj.ops = mode.ops;
   obj.priv = &mode;
 
   result = do_slope_benchmark (&obj);
 
   bench_print_result (result);
 }
 
 static void
 _hash_bench (int algo)
 {
   int i;
 
   for (i = 0; hash_modes[i].name; i++)
     hash_bench_one (algo, &hash_modes[i]);
 }
 
 void
 hash_bench (char **argv, int argc)
 {
   int i, algo;
 
   bench_print_section ("hash", "Hash");
   bench_print_header (14, "");
 
   if (argv && argc)
     {
       for (i = 0; i < argc; i++)
 	{
 	  algo = gcry_md_map_name (argv[i]);
 	  if (algo)
 	    _hash_bench (algo);
 	}
     }
   else
     {
       for (i = 1; i < 400; i++)
 	if (!gcry_md_test_algo (i))
 	  _hash_bench (i);
     }
 
   bench_print_footer (14);
 }
 
 
 /************************************************************ MAC benchmarks. */
 
 struct bench_mac_mode
 {
   const char *name;
   struct bench_ops *ops;
 
   int algo;
 };
 
 
 static int
 bench_mac_init (struct bench_obj *obj)
 {
   struct bench_mac_mode *mode = obj->priv;
   gcry_mac_hd_t hd;
   int err;
   unsigned int keylen;
   void *key;
 
   obj->min_bufsize = BUF_START_SIZE;
   obj->max_bufsize = BUF_END_SIZE;
   obj->step_size = BUF_STEP_SIZE;
   obj->num_measure_repetitions = num_measurement_repetitions;
 
   keylen = gcry_mac_get_algo_keylen (mode->algo);
   if (keylen == 0)
     keylen = 32;
   key = malloc (keylen);
   if (!key)
     {
       fprintf (stderr, PGM ": couldn't allocate %d bytes\n", keylen);
       exit (1);
     }
   memset(key, 42, keylen);
 
   err = gcry_mac_open (&hd, mode->algo, 0, NULL);
   if (err)
     {
       fprintf (stderr, PGM ": error opening mac `%s'\n",
 	       gcry_mac_algo_name (mode->algo));
       free (key);
       exit (1);
     }
 
   err = gcry_mac_setkey (hd, key, keylen);
   if (err)
     {
       fprintf (stderr, PGM ": error setting key for mac `%s'\n",
 	       gcry_mac_algo_name (mode->algo));
       free (key);
       exit (1);
     }
 
   switch (mode->algo)
     {
     default:
       break;
     case GCRY_MAC_POLY1305_AES:
     case GCRY_MAC_POLY1305_CAMELLIA:
     case GCRY_MAC_POLY1305_TWOFISH:
     case GCRY_MAC_POLY1305_SERPENT:
     case GCRY_MAC_POLY1305_SEED:
       gcry_mac_setiv (hd, key, 16);
       break;
     }
 
   obj->hd = hd;
 
   free (key);
   return 0;
 }
 
 static void
 bench_mac_free (struct bench_obj *obj)
 {
   gcry_mac_hd_t hd = obj->hd;
 
   gcry_mac_close (hd);
 }
 
 static void
 bench_mac_do_bench (struct bench_obj *obj, void *buf, size_t buflen)
 {
   gcry_mac_hd_t hd = obj->hd;
   size_t bs;
   char b;
 
   gcry_mac_reset (hd);
   gcry_mac_write (hd, buf, buflen);
   bs = sizeof(b);
   gcry_mac_read (hd, &b, &bs);
 }
 
 static struct bench_ops mac_ops = {
   &bench_mac_init,
   &bench_mac_free,
   &bench_mac_do_bench
 };
 
 
 static struct bench_mac_mode mac_modes[] = {
   {"", &mac_ops},
   {0},
 };
 
 
 static void
 mac_bench_one (int algo, struct bench_mac_mode *pmode)
 {
   struct bench_mac_mode mode = *pmode;
   struct bench_obj obj = { 0 };
   double result;
 
   mode.algo = algo;
 
   if (mode.name[0] == '\0')
     bench_print_algo (-18, gcry_mac_algo_name (algo));
   else
     bench_print_algo (18, mode.name);
 
   obj.ops = mode.ops;
   obj.priv = &mode;
 
   result = do_slope_benchmark (&obj);
 
   bench_print_result (result);
 }
 
 static void
 _mac_bench (int algo)
 {
   int i;
 
   for (i = 0; mac_modes[i].name; i++)
     mac_bench_one (algo, &mac_modes[i]);
 }
 
 void
 mac_bench (char **argv, int argc)
 {
   int i, algo;
 
   bench_print_section ("mac", "MAC");
   bench_print_header (18, "");
 
   if (argv && argc)
     {
       for (i = 0; i < argc; i++)
 	{
 	  algo = gcry_mac_map_name (argv[i]);
 	  if (algo)
 	    _mac_bench (algo);
 	}
     }
   else
     {
       for (i = 1; i < 600; i++)
 	if (!gcry_mac_test_algo (i))
 	  _mac_bench (i);
     }
 
   bench_print_footer (18);
 }
 
 
 /************************************************************ KDF benchmarks. */
 
 struct bench_kdf_mode
 {
   struct bench_ops *ops;
 
   int algo;
   int subalgo;
 };
 
 
 static int
 bench_kdf_init (struct bench_obj *obj)
 {
   struct bench_kdf_mode *mode = obj->priv;
 
   if (mode->algo == GCRY_KDF_PBKDF2)
     {
       obj->min_bufsize = 2;
       obj->max_bufsize = 2 * 32;
       obj->step_size = 2;
     }
 
   obj->num_measure_repetitions = num_measurement_repetitions;
 
   return 0;
 }
 
 static void
 bench_kdf_free (struct bench_obj *obj)
 {
   (void)obj;
 }
 
 static void
 bench_kdf_do_bench (struct bench_obj *obj, void *buf, size_t buflen)
 {
   struct bench_kdf_mode *mode = obj->priv;
   char keybuf[16];
 
   (void)buf;
 
   if (mode->algo == GCRY_KDF_PBKDF2)
     {
       gcry_kdf_derive("qwerty", 6, mode->algo, mode->subalgo, "01234567", 8,
 		      buflen, sizeof(keybuf), keybuf);
     }
 }
 
 static struct bench_ops kdf_ops = {
   &bench_kdf_init,
   &bench_kdf_free,
   &bench_kdf_do_bench
 };
 
 
 static void
 kdf_bench_one (int algo, int subalgo)
 {
   struct bench_kdf_mode mode = { &kdf_ops };
   struct bench_obj obj = { 0 };
   double nsecs_per_iteration;
   double cycles_per_iteration;
   char algo_name[32];
   char nsecpiter_buf[16];
   char cpiter_buf[16];
   char mhz_buf[16];
 
   mode.algo = algo;
   mode.subalgo = subalgo;
 
   switch (subalgo)
     {
     case GCRY_MD_CRC32:
     case GCRY_MD_CRC32_RFC1510:
     case GCRY_MD_CRC24_RFC2440:
     case GCRY_MD_MD4:
       /* Skip CRC32s. */
       return;
     }
 
   if (gcry_md_get_algo_dlen (subalgo) == 0)
     {
       /* Skip XOFs */
       return;
     }
 
   *algo_name = 0;
 
   if (algo == GCRY_KDF_PBKDF2)
     {
       snprintf (algo_name, sizeof(algo_name), "PBKDF2-HMAC-%s",
 		gcry_md_algo_name (subalgo));
     }
 
   bench_print_algo (-24, algo_name);
 
   obj.ops = mode.ops;
   obj.priv = &mode;
 
   nsecs_per_iteration = do_slope_benchmark (&obj);
 
   strcpy(cpiter_buf, csv_mode ? "" : "-");
   strcpy(mhz_buf, csv_mode ? "" : "-");
 
   double_to_str (nsecpiter_buf, sizeof (nsecpiter_buf), nsecs_per_iteration);
 
   /* If user didn't provide CPU speed, we cannot show cycles/iter results.  */
   if (bench_ghz > 0.0)
     {
       cycles_per_iteration = nsecs_per_iteration * bench_ghz;
       double_to_str (cpiter_buf, sizeof (cpiter_buf), cycles_per_iteration);
       double_to_str (mhz_buf, sizeof (mhz_buf), bench_ghz * 1000);
     }
 
   if (csv_mode)
     {
       if (auto_ghz)
         printf ("%s,%s,%s,,,,,,,,,%s,ns/iter,%s,c/iter,%s,Mhz\n",
                 current_section_name,
                 current_algo_name ? current_algo_name : "",
                 current_mode_name ? current_mode_name : "",
                 nsecpiter_buf,
                 cpiter_buf,
                 mhz_buf);
       else
         printf ("%s,%s,%s,,,,,,,,,%s,ns/iter,%s,c/iter\n",
                 current_section_name,
                 current_algo_name ? current_algo_name : "",
                 current_mode_name ? current_mode_name : "",
                 nsecpiter_buf,
                 cpiter_buf);
     }
   else
     {
       if (auto_ghz)
         printf ("%14s %13s %9s\n", nsecpiter_buf, cpiter_buf, mhz_buf);
       else
         printf ("%14s %13s\n", nsecpiter_buf, cpiter_buf);
     }
 }
 
 void
 kdf_bench (char **argv, int argc)
 {
   char algo_name[32];
   int i, j;
 
   bench_print_section ("kdf", "KDF");
 
   if (!csv_mode)
     {
       printf (" %-*s | ", 24, "");
       if (auto_ghz)
         printf ("%14s %13s %9s\n", "nanosecs/iter", "cycles/iter", "auto Mhz");
       else
         printf ("%14s %13s\n", "nanosecs/iter", "cycles/iter");
     }
 
   if (argv && argc)
     {
       for (i = 0; i < argc; i++)
 	{
 	  for (j = 1; j < 400; j++)
 	    {
 	      if (gcry_md_test_algo (j))
 		continue;
 
 	      snprintf (algo_name, sizeof(algo_name), "PBKDF2-HMAC-%s",
 			gcry_md_algo_name (j));
 
 	      if (!strcmp(argv[i], algo_name))
 		kdf_bench_one (GCRY_KDF_PBKDF2, j);
 	    }
 	}
     }
   else
     {
       for (i = 1; i < 400; i++)
 	if (!gcry_md_test_algo (i))
 	  kdf_bench_one (GCRY_KDF_PBKDF2, i);
     }
 
   bench_print_footer (24);
 }
 
 
 /************************************************************** Main program. */
 
 void
 print_help (void)
 {
   static const char *help_lines[] = {
     "usage: bench-slope [options] [hash|mac|cipher|kdf [algonames]]",
     "",
     " options:",
     "   --cpu-mhz <mhz>           Set CPU speed for calculating cycles",
     "                             per bytes results.  Set as \"auto\"",
     "                             for auto-detection of CPU speed.",
     "   --disable-hwf <features>  Disable hardware acceleration feature(s)",
     "                             for benchmarking.",
     "   --repetitions <n>         Use N repetitions (default "
                                      STR2(NUM_MEASUREMENT_REPETITIONS) ")",
     "   --unaligned               Use unaligned input buffers.",
     "   --csv                     Use CSV output format",
     NULL
   };
   const char **line;
 
   for (line = help_lines; *line; line++)
     fprintf (stdout, "%s\n", *line);
 }
 
 
 /* Warm up CPU.  */
 static void
 warm_up_cpu (void)
 {
   struct nsec_time start, end;
 
   get_nsec_time (&start);
   do
     {
       get_nsec_time (&end);
     }
   while (get_time_nsec_diff (&start, &end) < 1000.0 * 1000.0 * 1000.0);
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
 
   if (argc)
     {
       argc--;
       argv++;
     }
 
   /* We skip this test if we are running under the test suite (no args
      and srcdir defined) and GCRYPT_NO_BENCHMARKS is set.  */
   if (!argc && getenv ("srcdir") && getenv ("GCRYPT_NO_BENCHMARKS"))
     exit (77);
 
   if (getenv ("GCRYPT_IN_REGRESSION_TEST"))
     {
       in_regression_test = 1;
       num_measurement_repetitions = 2;
     }
   else
     num_measurement_repetitions = NUM_MEASUREMENT_REPETITIONS;
 
   while (argc && last_argc != argc)
     {
       last_argc = argc;
 
       if (!strcmp (*argv, "--"))
 	{
 	  argc--;
 	  argv++;
 	  break;
 	}
       else if (!strcmp (*argv, "--help"))
 	{
 	  print_help ();
 	  exit (0);
 	}
       else if (!strcmp (*argv, "--verbose"))
 	{
 	  verbose++;
 	  argc--;
 	  argv++;
 	}
       else if (!strcmp (*argv, "--debug"))
 	{
 	  verbose += 2;
 	  debug++;
 	  argc--;
 	  argv++;
 	}
       else if (!strcmp (*argv, "--csv"))
 	{
 	  csv_mode = 1;
 	  argc--;
 	  argv++;
 	}
       else if (!strcmp (*argv, "--unaligned"))
 	{
 	  unaligned_mode = 1;
 	  argc--;
 	  argv++;
 	}
       else if (!strcmp (*argv, "--disable-hwf"))
 	{
 	  argc--;
 	  argv++;
 	  if (argc)
 	    {
 	      if (gcry_control (GCRYCTL_DISABLE_HWF, *argv, NULL))
 		fprintf (stderr,
 			 PGM
 			 ": unknown hardware feature `%s' - option ignored\n",
 			 *argv);
 	      argc--;
 	      argv++;
 	    }
 	}
       else if (!strcmp (*argv, "--cpu-mhz"))
 	{
 	  argc--;
 	  argv++;
 	  if (argc)
 	    {
               if (!strcmp (*argv, "auto"))
                 {
                   auto_ghz = 1;
                 }
               else
                 {
                   cpu_ghz = atof (*argv);
                   cpu_ghz /= 1000;	/* Mhz => Ghz */
                 }
 
 	      argc--;
 	      argv++;
 	    }
 	}
       else if (!strcmp (*argv, "--repetitions"))
 	{
 	  argc--;
 	  argv++;
 	  if (argc)
 	    {
 	      num_measurement_repetitions = atof (*argv);
               if (num_measurement_repetitions < 2)
                 {
                   fprintf (stderr,
                            PGM
                            ": value for --repetitions too small - using %d\n",
                            NUM_MEASUREMENT_REPETITIONS);
                   num_measurement_repetitions = NUM_MEASUREMENT_REPETITIONS;
                 }
 	      argc--;
 	      argv++;
 	    }
 	}
     }
 
-  xgcry_control (GCRYCTL_SET_VERBOSITY, (int) verbose);
+  xgcry_control ((GCRYCTL_SET_VERBOSITY, (int) verbose));
 
   if (!gcry_check_version (GCRYPT_VERSION))
     {
       fprintf (stderr, PGM ": version mismatch; pgm=%s, library=%s\n",
 	       GCRYPT_VERSION, gcry_check_version (NULL));
       exit (1);
     }
 
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
 
   if (in_regression_test)
     fputs ("Note: " PGM " running in quick regression test mode.\n", stdout);
 
   if (!argc)
     {
       warm_up_cpu ();
       hash_bench (NULL, 0);
       mac_bench (NULL, 0);
       cipher_bench (NULL, 0);
       kdf_bench (NULL, 0);
     }
   else if (!strcmp (*argv, "hash"))
     {
       argc--;
       argv++;
 
       warm_up_cpu ();
       hash_bench ((argc == 0) ? NULL : argv, argc);
     }
   else if (!strcmp (*argv, "mac"))
     {
       argc--;
       argv++;
 
       warm_up_cpu ();
       mac_bench ((argc == 0) ? NULL : argv, argc);
     }
   else if (!strcmp (*argv, "cipher"))
     {
       argc--;
       argv++;
 
       warm_up_cpu ();
       cipher_bench ((argc == 0) ? NULL : argv, argc);
     }
   else if (!strcmp (*argv, "kdf"))
     {
       argc--;
       argv++;
 
       warm_up_cpu ();
       kdf_bench ((argc == 0) ? NULL : argv, argc);
     }
   else
     {
       fprintf (stderr, PGM ": unknown argument: %s\n", *argv);
       print_help ();
     }
 
   return 0;
 }
 
 #endif /* !NO_GET_NSEC_TIME */
diff --git a/tests/benchmark.c b/tests/benchmark.c
index 418f9291..0f15c0d8 100644
--- a/tests/benchmark.c
+++ b/tests/benchmark.c
@@ -1,2037 +1,2037 @@
 /* benchmark.c - for libgcrypt
  * Copyright (C) 2002, 2004, 2005, 2006, 2008 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser general Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 
 #ifdef _GCRYPT_IN_LIBGCRYPT
 # include "../src/gcrypt-int.h"
 # include "../compat/libcompat.h"
 #else
 # include <gcrypt.h>
 #endif
 
 #include "stopwatch.h"
 
 
 #define PGM "benchmark"
 #include "t-common.h"
 
 /* Do encryption tests with large buffers (100 KiB).  */
 static int large_buffers;
 
 /* Do encryption tests with huge buffers (256 MiB). */
 static int huge_buffers;
 
 /* Number of cipher repetitions.  */
 static int cipher_repetitions;
 
 /* Number of hash repetitions.  */
 static int hash_repetitions;
 
 /* Number of hash repetitions.  */
 static int mac_repetitions;
 
 /* Alignment of the buffers.  */
 static int buffer_alignment;
 
 /* Whether to include the keysetup in the cipher timings.  */
 static int cipher_with_keysetup;
 
 /* Whether fips mode was active at startup.  */
 static int in_fips_mode;
 
 /* Whether we are running as part of the regression test suite.  */
 static int in_regression_test;
 
 /* Whether --progress is in use.  */
 static int with_progress;
 
 /* Runtime flag to switch to a different progress output.  */
 static int single_char_progress;
 
 
 static const char sample_private_dsa_key_1024[] =
 "(private-key\n"
 "  (dsa\n"
 "   (p #00A126202D592214C5A8F6016E2C3F4256052ACB1CB17D88E64B1293FAF08F5E4685"
        "03E6F68366B326A56284370EB2103E92D8346A163E44A08FDC422AC8E9E44268557A"
        "853539A6AF39353A59CE5E78FD98B57D0F3E3A7EBC8A256AC9A775BA59689F3004BF"
        "C3035730C4C0C51626C5D7F5852637EC589BB29DAB46C161572E4B#)\n"
 "   (q #00DEB5A296421887179ECA1762884DE2AF8185AFC5#)\n"
 "   (g #3958B34AE7747194ECBD312F8FEE8CBE3918E94DF9FD11E2912E56318F33BDC38622"
        "B18DDFF393074BCA8BAACF50DF27AEE529F3E8AEECE55C398DAB3A5E04C2EA142312"
        "FACA2FE7F0A88884F8DAC3979EE67598F9A383B2A2325F035C796F352A5C3CDF2CB3"
        "85AD24EC52A6E55247E1BB37D260F79E617D2A4446415B6AD79A#)\n"
 "   (y #519E9FE9AB0545A6724E74603B7B04E48DC1437E0284A11EA605A7BA8AB1CF354FD4"
        "ECC93880AC293391C69B558AD84E7AAFA88F11D028CF3A378F241D6B056A90C588F6"
        "66F68D27262B4DA84657D15057D371BCEC1F6504032507D5B881E45FC93A1B973155"
        "D91C57219D090C3ACD75E7C2B9F1176A208AC03D6C12AC28A271#)\n"
 "   (x #4186F8A58C5DF46C5BCFC7006BEEBF05E93C0CA7#)\n"
 "))\n";
 
 static const char sample_public_dsa_key_1024[] =
 "(public-key\n"
 "  (dsa\n"
 "   (p #00A126202D592214C5A8F6016E2C3F4256052ACB1CB17D88E64B1293FAF08F5E4685"
        "03E6F68366B326A56284370EB2103E92D8346A163E44A08FDC422AC8E9E44268557A"
        "853539A6AF39353A59CE5E78FD98B57D0F3E3A7EBC8A256AC9A775BA59689F3004BF"
        "C3035730C4C0C51626C5D7F5852637EC589BB29DAB46C161572E4B#)\n"
 "   (q #00DEB5A296421887179ECA1762884DE2AF8185AFC5#)\n"
 "   (g #3958B34AE7747194ECBD312F8FEE8CBE3918E94DF9FD11E2912E56318F33BDC38622"
        "B18DDFF393074BCA8BAACF50DF27AEE529F3E8AEECE55C398DAB3A5E04C2EA142312"
        "FACA2FE7F0A88884F8DAC3979EE67598F9A383B2A2325F035C796F352A5C3CDF2CB3"
        "85AD24EC52A6E55247E1BB37D260F79E617D2A4446415B6AD79A#)\n"
 "   (y #519E9FE9AB0545A6724E74603B7B04E48DC1437E0284A11EA605A7BA8AB1CF354FD4"
        "ECC93880AC293391C69B558AD84E7AAFA88F11D028CF3A378F241D6B056A90C588F6"
        "66F68D27262B4DA84657D15057D371BCEC1F6504032507D5B881E45FC93A1B973155"
        "D91C57219D090C3ACD75E7C2B9F1176A208AC03D6C12AC28A271#)\n"
 "))\n";
 
 
 static const char sample_private_dsa_key_2048[] =
 "(private-key\n"
 "  (dsa\n"
 "   (p #00B54636673962B64F7DC23C71ACEF6E7331796F607560B194DFCC0CA370E858A365"
        "A413152FB6EB8C664BD171AC316FE5B381CD084D07377571599880A068EF1382D85C"
        "308B4E9DEAC12D66DE5C4A826EBEB5ED94A62E7301E18927E890589A2F230272A150"
        "C118BC3DC2965AE0D05BE4F65C6137B2BA7EDABB192C3070D202C10AA3F534574970"
        "71454DB8A73DDB6511A5BA98EF1450FD90DE5BAAFC9FD3AC22EBEA612DD075BB7405"
        "D56866D125E33982C046808F7CEBA8E5C0B9F19A6FE451461660A1CBA9EF68891179"
        "0256A573D3B8F35A5C7A0C6C31F2DB90E25A26845252AD9E485EF2D339E7B5890CD4"
        "2F9C9F315ED409171EC35CA04CC06B275577B3#)\n"
 "   (q #00DA67989167FDAC4AE3DF9247A716859A30C0CF9C5A6DBA01EABA3481#)\n"
 "   (g #48E35DA584A089D05142AA63603FDB00D131B07A0781E2D5A8F9614D2B33D3E40A78"
        "98A9E10CDBB612CF093F95A3E10D09566726F2C12823836B2D9CD974BB695665F3B3"
        "5D219A9724B87F380BD5207EDA0AE38C79E8F18122C3F76E4CEB0ABED3250914987F"
        "B30D4B9E19C04C28A5D4F45560AF586F6A1B41751EAD90AE7F044F4E2A4A50C1F508"
        "4FC202463F478F678B9A19392F0D2961C5391C546EF365368BB46410C9C1CEE96E9F"
        "0C953570C2ED06328B11C90E86E57CAA7FA5ABAA278E22A4C8C08E16EE59F484EC44"
        "2CF55535BAA2C6BEA8833A555372BEFE1E665D3C7DAEF58061D5136331EF4EB61BC3"
        "6EE4425A553AF8885FEA15A88135BE133520#)\n"
 "   (y #66E0D1A69D663466F8FEF2B7C0878DAC93C36A2FB2C05E0306A53B926021D4B92A1C"
        "2FA6860061E88E78CBBBA49B0E12700F07DBF86F72CEB2927EDAC0C7E3969C3A47BB"
        "4E0AE93D8BB3313E93CC7A72DFEEE442EFBC81B3B2AEC9D8DCBE21220FB760201D79"
        "328C41C773866587A44B6954767D022A88072900E964089D9B17133603056C985C4F"
        "8A0B648F297F8D2C3CB43E4371DC6002B5B12CCC085BDB2CFC5074A0587566187EE3"
        "E11A2A459BD94726248BB8D6CC62938E11E284C2C183576FBB51749EB238C4360923"
        "79C08CE1C8CD77EB57404CE9B4744395ACF721487450BADE3220576F2F816248B0A7"
        "14A264330AECCB24DE2A1107847B23490897#)\n"
 "   (x #477BD14676E22563C5ABA68025CEBA2A48D485F5B2D4AD4C0EBBD6D0#)\n"
 "))\n";
 
 
 static const char sample_public_dsa_key_2048[] =
 "(public-key\n"
 "  (dsa\n"
 "   (p #00B54636673962B64F7DC23C71ACEF6E7331796F607560B194DFCC0CA370E858A365"
        "A413152FB6EB8C664BD171AC316FE5B381CD084D07377571599880A068EF1382D85C"
        "308B4E9DEAC12D66DE5C4A826EBEB5ED94A62E7301E18927E890589A2F230272A150"
        "C118BC3DC2965AE0D05BE4F65C6137B2BA7EDABB192C3070D202C10AA3F534574970"
        "71454DB8A73DDB6511A5BA98EF1450FD90DE5BAAFC9FD3AC22EBEA612DD075BB7405"
        "D56866D125E33982C046808F7CEBA8E5C0B9F19A6FE451461660A1CBA9EF68891179"
        "0256A573D3B8F35A5C7A0C6C31F2DB90E25A26845252AD9E485EF2D339E7B5890CD4"
        "2F9C9F315ED409171EC35CA04CC06B275577B3#)\n"
 "   (q #00DA67989167FDAC4AE3DF9247A716859A30C0CF9C5A6DBA01EABA3481#)\n"
 "   (g #48E35DA584A089D05142AA63603FDB00D131B07A0781E2D5A8F9614D2B33D3E40A78"
        "98A9E10CDBB612CF093F95A3E10D09566726F2C12823836B2D9CD974BB695665F3B3"
        "5D219A9724B87F380BD5207EDA0AE38C79E8F18122C3F76E4CEB0ABED3250914987F"
        "B30D4B9E19C04C28A5D4F45560AF586F6A1B41751EAD90AE7F044F4E2A4A50C1F508"
        "4FC202463F478F678B9A19392F0D2961C5391C546EF365368BB46410C9C1CEE96E9F"
        "0C953570C2ED06328B11C90E86E57CAA7FA5ABAA278E22A4C8C08E16EE59F484EC44"
        "2CF55535BAA2C6BEA8833A555372BEFE1E665D3C7DAEF58061D5136331EF4EB61BC3"
        "6EE4425A553AF8885FEA15A88135BE133520#)\n"
 "   (y #66E0D1A69D663466F8FEF2B7C0878DAC93C36A2FB2C05E0306A53B926021D4B92A1C"
        "2FA6860061E88E78CBBBA49B0E12700F07DBF86F72CEB2927EDAC0C7E3969C3A47BB"
        "4E0AE93D8BB3313E93CC7A72DFEEE442EFBC81B3B2AEC9D8DCBE21220FB760201D79"
        "328C41C773866587A44B6954767D022A88072900E964089D9B17133603056C985C4F"
        "8A0B648F297F8D2C3CB43E4371DC6002B5B12CCC085BDB2CFC5074A0587566187EE3"
        "E11A2A459BD94726248BB8D6CC62938E11E284C2C183576FBB51749EB238C4360923"
        "79C08CE1C8CD77EB57404CE9B4744395ACF721487450BADE3220576F2F816248B0A7"
        "14A264330AECCB24DE2A1107847B23490897#)\n"
 "))\n";
 
 
 static const char sample_private_dsa_key_3072[] =
 "(private-key\n"
 "  (dsa\n"
 "   (p #00BA73E148AEA5E8B64878AF5BE712B8302B9671C5F3EEB7722A9D0D9868D048C938"
        "877C91C335C7819292E69C7D34264F1578E32EC2DA8408DF75D0EB76E0D3030B84B5"
        "62D8EF93AB53BAB6B8A5DE464F5CA87AEA43BDCF0FB0B7815AA3114CFC84FD916A83"
        "B3D5FD78390189332232E9D037D215313FD002FF46C048B66703F87FAE092AAA0988"
        "AC745336EBE672A01DEDBD52395783579B67CF3AE1D6F1602CCCB12154FA0E00AE46"
        "0D9B289CF709194625BCB919B11038DEFC50ADBBA20C3F320078E4E9529B4F6848E2"
        "AB5E6278DB961FE226F2EEBD201E071C48C5BEF98B4D9BEE42C1C7102D893EBF8902"
        "D7A91266340AFD6CE1D09E52282FFF5B97EAFA3886A3FCF84FF76D1E06538D0D8E60"
        "B3332145785E07D29A5965382DE3470D1D888447FA9C00A2373378FC3FA7B9F7D17E"
        "95A6A5AE1397BE46D976EF2C96E89913AC4A09351CA661BF6F67E30407DA846946C7"
        "62D9BAA6B77825097D3E7B886456BB32E3E74516BF3FD93D71B257AA8F723E01CE33"
        "8015353D3778B02B892AF7#)\n"
 "   (q #00BFF3F3CC18FA018A5B8155A8695E1E4939660D5E4759322C39D50F3B93E5F68B#)\n"
 "   (g #6CCFD8219F5FCE8EF2BEF3262929787140847E38674B1EF8DB20255E212CB6330EC4"
        "DFE8A26AB7ECC5760DEB9BBF59A2B2821D510F1868172222867558B8D204E889C474"
        "7CA30FBF9D8CF41AE5D5BD845174641101593849FF333E6C93A6550931B2B9D56B98"
        "9CAB01729D9D736FA6D24A74D2DDE1E9E648D141473E443DD6BBF0B3CAB64F9FE4FC"
        "134B2EB57437789F75C744DF1FA67FA8A64603E5441BC7ECE29E00BDF262BDC81E8C"
        "7330A18A412DE38E7546D342B89A0AF675A89E6BEF00540EB107A2FE74EA402B0D89"
        "F5C02918DEEEAF8B8737AC866B09B50810AB8D8668834A1B9E1E53866E2B0A926FAB"
        "120A0CDE5B3715FFFE6ACD1AB73588DCC1EC4CE9392FE57F8D1D35811200CB07A0E6"
        "374E2C4B0AEB7E3D077B8545C0E438DCC0F1AE81E186930E99EBC5B91B77E92803E0"
        "21602887851A4FFDB3A7896AC655A0901218C121C5CBB0931E7D5EAC243F37711B5F"
        "D5A62B1B38A83F03D8F6703D8B98DF367FC8A76990335F62173A5391836F0F2413EC"
        "4997AF9EB55C6660B01A#)\n"
 "   (y #2320B22434C5DB832B4EC267CC52E78DD5CCFA911E8F0804E7E7F32B186B2D4167AE"
        "4AA6869822E76400492D6A193B0535322C72B0B7AA4A87E33044FDC84BE24C64A053"
        "A37655EE9EABDCDC1FDF63F3F1C677CEB41595DF7DEFE9178D85A3D621B4E4775492"
        "8C0A58D2458D06F9562E4DE2FE6129A64063A99E88E54485B97484A28188C4D33F15"
        "DDC903B6CEA0135E3E3D27B4EA39319696305CE93D7BA7BE00367DBE3AAF43491E71"
        "CBF254744A5567F5D70090D6139E0C990239627B3A1C5B20B6F9F6374B8D8D8A8997"
        "437265BE1E3B4810D4B09254400DE287A0DFFBAEF339E48D422B1D41A37E642BC026"
        "73314701C8FA9792845C129351A87A945A03E6C895860E51D6FB8B7340A94D1A8A7B"
        "FA85AC83B4B14E73AB86CB96C236C8BFB0978B61B2367A7FE4F7891070F56C78D5DD"
        "F5576BFE5BE4F333A4E2664E79528B3294907AADD63F4F2E7AA8147B928D8CD69765"
        "3DB98C4297CB678046ED55C0DBE60BF7142C594603E4D705DC3D17270F9F086EC561"
        "2703D518D8D49FF0EBE6#)\n"
 "   (x #00A9FFFC88E67D6F7B810E291C050BAFEA7FC4A75E8D2F16CFED3416FD77607232#)\n"
 "))\n";
 
 static const char sample_public_dsa_key_3072[] =
 "(public-key\n"
 "  (dsa\n"
 "   (p #00BA73E148AEA5E8B64878AF5BE712B8302B9671C5F3EEB7722A9D0D9868D048C938"
        "877C91C335C7819292E69C7D34264F1578E32EC2DA8408DF75D0EB76E0D3030B84B5"
        "62D8EF93AB53BAB6B8A5DE464F5CA87AEA43BDCF0FB0B7815AA3114CFC84FD916A83"
        "B3D5FD78390189332232E9D037D215313FD002FF46C048B66703F87FAE092AAA0988"
        "AC745336EBE672A01DEDBD52395783579B67CF3AE1D6F1602CCCB12154FA0E00AE46"
        "0D9B289CF709194625BCB919B11038DEFC50ADBBA20C3F320078E4E9529B4F6848E2"
        "AB5E6278DB961FE226F2EEBD201E071C48C5BEF98B4D9BEE42C1C7102D893EBF8902"
        "D7A91266340AFD6CE1D09E52282FFF5B97EAFA3886A3FCF84FF76D1E06538D0D8E60"
        "B3332145785E07D29A5965382DE3470D1D888447FA9C00A2373378FC3FA7B9F7D17E"
        "95A6A5AE1397BE46D976EF2C96E89913AC4A09351CA661BF6F67E30407DA846946C7"
        "62D9BAA6B77825097D3E7B886456BB32E3E74516BF3FD93D71B257AA8F723E01CE33"
        "8015353D3778B02B892AF7#)\n"
 "   (q #00BFF3F3CC18FA018A5B8155A8695E1E4939660D5E4759322C39D50F3B93E5F68B#)\n"
 "   (g #6CCFD8219F5FCE8EF2BEF3262929787140847E38674B1EF8DB20255E212CB6330EC4"
        "DFE8A26AB7ECC5760DEB9BBF59A2B2821D510F1868172222867558B8D204E889C474"
        "7CA30FBF9D8CF41AE5D5BD845174641101593849FF333E6C93A6550931B2B9D56B98"
        "9CAB01729D9D736FA6D24A74D2DDE1E9E648D141473E443DD6BBF0B3CAB64F9FE4FC"
        "134B2EB57437789F75C744DF1FA67FA8A64603E5441BC7ECE29E00BDF262BDC81E8C"
        "7330A18A412DE38E7546D342B89A0AF675A89E6BEF00540EB107A2FE74EA402B0D89"
        "F5C02918DEEEAF8B8737AC866B09B50810AB8D8668834A1B9E1E53866E2B0A926FAB"
        "120A0CDE5B3715FFFE6ACD1AB73588DCC1EC4CE9392FE57F8D1D35811200CB07A0E6"
        "374E2C4B0AEB7E3D077B8545C0E438DCC0F1AE81E186930E99EBC5B91B77E92803E0"
        "21602887851A4FFDB3A7896AC655A0901218C121C5CBB0931E7D5EAC243F37711B5F"
        "D5A62B1B38A83F03D8F6703D8B98DF367FC8A76990335F62173A5391836F0F2413EC"
        "4997AF9EB55C6660B01A#)\n"
 "   (y #2320B22434C5DB832B4EC267CC52E78DD5CCFA911E8F0804E7E7F32B186B2D4167AE"
        "4AA6869822E76400492D6A193B0535322C72B0B7AA4A87E33044FDC84BE24C64A053"
        "A37655EE9EABDCDC1FDF63F3F1C677CEB41595DF7DEFE9178D85A3D621B4E4775492"
        "8C0A58D2458D06F9562E4DE2FE6129A64063A99E88E54485B97484A28188C4D33F15"
        "DDC903B6CEA0135E3E3D27B4EA39319696305CE93D7BA7BE00367DBE3AAF43491E71"
        "CBF254744A5567F5D70090D6139E0C990239627B3A1C5B20B6F9F6374B8D8D8A8997"
        "437265BE1E3B4810D4B09254400DE287A0DFFBAEF339E48D422B1D41A37E642BC026"
        "73314701C8FA9792845C129351A87A945A03E6C895860E51D6FB8B7340A94D1A8A7B"
        "FA85AC83B4B14E73AB86CB96C236C8BFB0978B61B2367A7FE4F7891070F56C78D5DD"
        "F5576BFE5BE4F333A4E2664E79528B3294907AADD63F4F2E7AA8147B928D8CD69765"
        "3DB98C4297CB678046ED55C0DBE60BF7142C594603E4D705DC3D17270F9F086EC561"
        "2703D518D8D49FF0EBE6#)\n"
 "))\n";
 
 
 static const char sample_public_elg_key_1024[] =
 "(public-key"
 "  (elg"
 "   (p #00F7CC7C08AF096B620C545C9353B1140D698FF8BE2D97A3515C17C7F8DABCDB8FB6"
        "64A46416C90C530C18DF5ABB6C1DDE3AE2FA9DDC9CE40DF644CDE2E759F6DE43F31A"
        "EEEBC136A460B3E4B0A8F99326A335145B19F4C81B13804894B7D2A30F78A8A7D7F4"
        "52B83836FDB0DE90BE327FB5E5318757BEF5FE0FC3A5461CBEA0D3#)"
 "   (g #06#)"
 "   (y #36B38FB63E3340A0DD8A0468E9FAA512A32DA010BF7110201D0A3DF1B8FEA0E16F3C"
        "80374584E554804B96EAA8C270FE531F75D0DBD81BA65640EDB1F76D46C27D2925B7"
        "3EC3B295CDAEEF242904A84D74FB2879425F82D4C5B59BB49A992F85D574168DED85"
        "D227600BBEF7AF0B8F0DEB785528370E4C4B3E4D65C536122A5A#)"
 "   ))";
 static const char sample_private_elg_key_1024[] =
 "(private-key"
 "  (elg"
 "   (p #00F7CC7C08AF096B620C545C9353B1140D698FF8BE2D97A3515C17C7F8DABCDB8FB6"
        "64A46416C90C530C18DF5ABB6C1DDE3AE2FA9DDC9CE40DF644CDE2E759F6DE43F31A"
        "EEEBC136A460B3E4B0A8F99326A335145B19F4C81B13804894B7D2A30F78A8A7D7F4"
        "52B83836FDB0DE90BE327FB5E5318757BEF5FE0FC3A5461CBEA0D3#)"
 "   (g #06#)"
 "   (y #36B38FB63E3340A0DD8A0468E9FAA512A32DA010BF7110201D0A3DF1B8FEA0E16F3C"
        "80374584E554804B96EAA8C270FE531F75D0DBD81BA65640EDB1F76D46C27D2925B7"
        "3EC3B295CDAEEF242904A84D74FB2879425F82D4C5B59BB49A992F85D574168DED85"
        "D227600BBEF7AF0B8F0DEB785528370E4C4B3E4D65C536122A5A#)"
 "   (x #03656C6186FCD27D4A4B1F5010DC0D2AE7833B501E423FCD51DE5EB6D80DACFE#)"
 "   ))";
 
 
 static const char sample_public_elg_key_2048[] =
 "(public-key"
 "  (elg"
 "   (p #00BE5A2BB4E562D7B644E3D01321CB818DBA27295C339FC2C47EAE9823225EE1E7B6"
        "38C5DE300E931080E09CC89A18C9D180C16559FEF0D89D6A09534BB86489CCCEE30D"
        "C18E007A8726BB99F2B2D90D2694597757B120CD2435C0098AD1B74C20004C25BA97"
        "73EAA4FBEC594EE17F8B25867EEB0F9F857C751116ADED68ADA2A1E9F9F4F40D18F0"
        "EC1221CA6A746FC5F4CDA2B8B5D0AB83834564ACF6FDBB1AB01D4BFBD1E2C0108FF5"
        "5FB3190C6D6DA4D95EA683EFA44935CFBC0BF5C6118ACC3768AEA9A98D06024841B8"
        "D07C234289D22A5E3948F199C397AA991C59A55BEA0C01E91902E039116946FEA135"
        "768011AF6B622C5AF366EF0196FC4EAEAA8127#)"
 "   (g #07#)"
 "   (y #5AFF87BC23D8B97AA62897A5C1CDFFA86C59F39EDBD6012B6F333CE23D872009B8C8"
        "D1E220E18CFCADFE0AA16346BA2EA132472FFEC746D11C6E758896052313BB501210"
        "2389C683A25A3464E9B35A192BAE0A3BB99C973126F7560D968C4A754901DC967354"
        "D61A90ACD56D90DCC4337AFB71FAE3FD18C60EB0D6DD173877DF5DB5199C4931FE4E"
        "5046F814422580E1162798406FC6554781142DBB7922D4B5B37A111F23761636090F"
        "6212681E133365191CF15753AE737F17943ED4B7506DE0A85C3B6D63227F9D65ADF8"
        "2C3DF0676C8F43B5B1C07D9AD4E6D0C812401D7DA7B9484DBA8CD3B73B19A95EB237"
        "D493E092AEA2371AA904009C8960B0969D12#)"
 "   ))";
 static const char sample_private_elg_key_2048[] =
 "(private-key"
 "  (elg"
 "   (p #00BE5A2BB4E562D7B644E3D01321CB818DBA27295C339FC2C47EAE9823225EE1E7B6"
        "38C5DE300E931080E09CC89A18C9D180C16559FEF0D89D6A09534BB86489CCCEE30D"
        "C18E007A8726BB99F2B2D90D2694597757B120CD2435C0098AD1B74C20004C25BA97"
        "73EAA4FBEC594EE17F8B25867EEB0F9F857C751116ADED68ADA2A1E9F9F4F40D18F0"
        "EC1221CA6A746FC5F4CDA2B8B5D0AB83834564ACF6FDBB1AB01D4BFBD1E2C0108FF5"
        "5FB3190C6D6DA4D95EA683EFA44935CFBC0BF5C6118ACC3768AEA9A98D06024841B8"
        "D07C234289D22A5E3948F199C397AA991C59A55BEA0C01E91902E039116946FEA135"
        "768011AF6B622C5AF366EF0196FC4EAEAA8127#)"
 "   (g #07#)"
 "   (y #5AFF87BC23D8B97AA62897A5C1CDFFA86C59F39EDBD6012B6F333CE23D872009B8C8"
        "D1E220E18CFCADFE0AA16346BA2EA132472FFEC746D11C6E758896052313BB501210"
        "2389C683A25A3464E9B35A192BAE0A3BB99C973126F7560D968C4A754901DC967354"
        "D61A90ACD56D90DCC4337AFB71FAE3FD18C60EB0D6DD173877DF5DB5199C4931FE4E"
        "5046F814422580E1162798406FC6554781142DBB7922D4B5B37A111F23761636090F"
        "6212681E133365191CF15753AE737F17943ED4B7506DE0A85C3B6D63227F9D65ADF8"
        "2C3DF0676C8F43B5B1C07D9AD4E6D0C812401D7DA7B9484DBA8CD3B73B19A95EB237"
        "D493E092AEA2371AA904009C8960B0969D12#)"
 "   (x #0628C3903972C55BDC1BC4223075616D3F3BA57D55532DDB40CB14CF72070E0D28BF"
        "D0402B9088D25ED8FC#)"
 "  ))";
 
 static const char sample_public_elg_key_3072[] =
 "(public-key"
 "  (elg"
 "   (p #008EAA3497AFE3706E1A57FFA52E68C64C500731B58EBAFEB51C4A20AB15BA57FA72"
        "BA1510A4703D5AA6F05DB67E4A776F92AD08800577DC686D00B793167A5D79C997E0"
        "5B9A9E5974B4B68B4D71ED8EC37F2F45235D901997D72915643F058E712AA18275A2"
        "C6F9F7C2B9B7CD1E814D215F12A840800B546AEF2A2E6C077CDD1A322738FFD36DB2"
        "FA5420B5848EED870BC1A6CF55040AE8D2A5945F11AE2BCBE107B41A59EFDBD3B05C"
        "F4C876C02C9AEAE22CD4C86806A415302936E4C1E5AA59DBBCCD2F83C20941A29888"
        "A70ADB94D3B8A6489C46BF2C5219CD9FD2341EA21D4E68A4ECC468FD09D215FE96D4"
        "7AEA12FD22B2456D2CC13672FC7E9772A365C68668157C51E46966B6A1831C429BA0"
        "D513519713C49C13C5FC7C14BE0A117627B204C4478D0A93C6B57929E448C9B65BF2"
        "390E04BC5940320C0262FC1A221E7C796493432239A6F12BC62C5CF32E8ADBC1730C"
        "84C6E6E6BD95AF62835941F3F344AF46BFE5A8F629D5FA699FE37EF8B8C6A2484E42"
        "D226206FDF7D1FB93A5457#)"
 "   (g #0B#)"
 "   (y #18E734FF645AE169079AEAFC78772371089AD3088627ECF77034AFBDF33ADF594AAF"
        "3288F6979E0DB59CE3D2F0FEE031DFF187F1E4549D3C79668794CB19C14481ECDE2D"
        "D50861AB674F87A011D50D35F28E424D0D2353850899C2CDD0CC8FDBFC5A0CA395F0"
        "E605D46CBDD140DBEF426EBD638C9ADD83C195C45CE84ED2D2B21B87800C783A4F79"
        "12226FEFBDA01C66B254534A51765AF09687275AA80C5DFBA143A6262E47C547D7E2"
        "289413F8C5C56AED3FA7E5DF5526958E2294FE318AF590C0E720029C202563E6E686"
        "9EC810F39A859262FB6047C1D418CAA9047A00BDB127B44B69CF6BC8E6B3709B4C23"
        "79783C5F8457EFE23EDA6FF00D1DDCC29268FC4A6C18577BE2B7004089CBB824027A"
        "A53C86B51DB054CC83B4F50C8923E2E9431F0A77D741237226CC68591083A2E40171"
        "5C7B74100BB74003E2264F8B44A0B0BC5404C44218ABE65C04AA573877506CE4F48C"
        "9E3F8AD1CD8DD9F285DD015C2FC5DEBCFA5779AD87F0BBC62E9EC6246021AB450DB9"
        "4DDDEFAFD2C7C66E235D#)"
 "   ))";
 static const char sample_private_elg_key_3072[] =
 "(private-key"
 "  (elg"
 "   (p #008EAA3497AFE3706E1A57FFA52E68C64C500731B58EBAFEB51C4A20AB15BA57FA72"
        "BA1510A4703D5AA6F05DB67E4A776F92AD08800577DC686D00B793167A5D79C997E0"
        "5B9A9E5974B4B68B4D71ED8EC37F2F45235D901997D72915643F058E712AA18275A2"
        "C6F9F7C2B9B7CD1E814D215F12A840800B546AEF2A2E6C077CDD1A322738FFD36DB2"
        "FA5420B5848EED870BC1A6CF55040AE8D2A5945F11AE2BCBE107B41A59EFDBD3B05C"
        "F4C876C02C9AEAE22CD4C86806A415302936E4C1E5AA59DBBCCD2F83C20941A29888"
        "A70ADB94D3B8A6489C46BF2C5219CD9FD2341EA21D4E68A4ECC468FD09D215FE96D4"
        "7AEA12FD22B2456D2CC13672FC7E9772A365C68668157C51E46966B6A1831C429BA0"
        "D513519713C49C13C5FC7C14BE0A117627B204C4478D0A93C6B57929E448C9B65BF2"
        "390E04BC5940320C0262FC1A221E7C796493432239A6F12BC62C5CF32E8ADBC1730C"
        "84C6E6E6BD95AF62835941F3F344AF46BFE5A8F629D5FA699FE37EF8B8C6A2484E42"
        "D226206FDF7D1FB93A5457#)"
 "   (g #0B#)"
 "   (y #18E734FF645AE169079AEAFC78772371089AD3088627ECF77034AFBDF33ADF594AAF"
        "3288F6979E0DB59CE3D2F0FEE031DFF187F1E4549D3C79668794CB19C14481ECDE2D"
        "D50861AB674F87A011D50D35F28E424D0D2353850899C2CDD0CC8FDBFC5A0CA395F0"
        "E605D46CBDD140DBEF426EBD638C9ADD83C195C45CE84ED2D2B21B87800C783A4F79"
        "12226FEFBDA01C66B254534A51765AF09687275AA80C5DFBA143A6262E47C547D7E2"
        "289413F8C5C56AED3FA7E5DF5526958E2294FE318AF590C0E720029C202563E6E686"
        "9EC810F39A859262FB6047C1D418CAA9047A00BDB127B44B69CF6BC8E6B3709B4C23"
        "79783C5F8457EFE23EDA6FF00D1DDCC29268FC4A6C18577BE2B7004089CBB824027A"
        "A53C86B51DB054CC83B4F50C8923E2E9431F0A77D741237226CC68591083A2E40171"
        "5C7B74100BB74003E2264F8B44A0B0BC5404C44218ABE65C04AA573877506CE4F48C"
        "9E3F8AD1CD8DD9F285DD015C2FC5DEBCFA5779AD87F0BBC62E9EC6246021AB450DB9"
        "4DDDEFAFD2C7C66E235D#)"
 "   (x #03A73F0389E470AAC831B039F8AA0C4EBD3A47DD083E32EEA08E4911236CD597C272"
        "9823D47A51C8535DA52FE6DAB3E8D1C20D#)"
 "  ))";
 
 
 #define BUG() do {fprintf ( stderr, "Ooops at %s:%d\n", __FILE__ , __LINE__ );\
 		  exit(2);} while(0)
 
 
 static void
 show_sexp (const char *prefix, gcry_sexp_t a)
 {
   char *buf;
   size_t size;
 
   fputs (prefix, stderr);
   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   buf = malloc (size);
   if (!buf)
     die ("out of core\n");
 
   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
   fprintf (stderr, "%.*s", (int)size, buf);
 }
 
 
 static void
 progress_cb (void *cb_data, const char *what, int printchar,
              int current, int total)
 {
   (void)cb_data;
 
   if (single_char_progress)
     {
       fputc (printchar, stdout);
       fflush (stderr);
     }
   else
     {
       fprintf (stderr, PGM ": progress (%s %c %d %d)\n",
                what, printchar, current, total);
       fflush (stderr);
     }
 }
 
 
 static void
 random_bench (int very_strong)
 {
   char buf[128];
   int i;
 
   printf ("%-10s", "random");
 
   if (!very_strong)
     {
       start_timer ();
       for (i=0; i < 100; i++)
         gcry_randomize (buf, sizeof buf, GCRY_STRONG_RANDOM);
       stop_timer ();
       printf (" %s", elapsed_time (1));
     }
 
   start_timer ();
   for (i=0; i < 100; i++)
     gcry_randomize (buf, 8,
                     very_strong? GCRY_VERY_STRONG_RANDOM:GCRY_STRONG_RANDOM);
   stop_timer ();
   printf (" %s", elapsed_time (1));
 
   putchar ('\n');
   if (verbose)
-    xgcry_control (GCRYCTL_DUMP_RANDOM_STATS);
+    xgcry_control ((GCRYCTL_DUMP_RANDOM_STATS));
 }
 
 
 
 static void
 md_bench ( const char *algoname )
 {
   int algo;
   gcry_md_hd_t hd;
   int i, j, repcount;
   char buf_base[1000+15];
   size_t bufsize = 1000;
   char *buf;
   char *largebuf_base;
   char *largebuf;
   char digest[512/8];
   gcry_error_t err = GPG_ERR_NO_ERROR;
 
   if (!algoname)
     {
       for (i=1; i < 400; i++)
         if (in_fips_mode && i == GCRY_MD_MD5)
           ; /* Don't use MD5 in fips mode.  */
         else if ( !gcry_md_test_algo (i) )
           md_bench (gcry_md_algo_name (i));
       return;
     }
 
   buf = buf_base + ((16 - ((size_t)buf_base & 0x0f)) % buffer_alignment);
 
   algo = gcry_md_map_name (algoname);
   if (!algo)
     {
       fprintf (stderr, PGM ": invalid hash algorithm `%s'\n", algoname);
       exit (1);
     }
 
   err = gcry_md_open (&hd, algo, 0);
   if (err)
     {
       fprintf (stderr, PGM ": error opening hash algorithm `%s'\n", algoname);
       exit (1);
     }
 
   for (i=0; i < bufsize; i++)
     buf[i] = i;
 
   printf ("%-12s", gcry_md_algo_name (algo));
 
   start_timer ();
   for (repcount=0; repcount < hash_repetitions; repcount++)
     for (i=0; i < 1000; i++)
       gcry_md_write (hd, buf, bufsize);
   gcry_md_final (hd);
   stop_timer ();
   printf (" %s", elapsed_time (1));
   fflush (stdout);
 
   gcry_md_reset (hd);
   start_timer ();
   for (repcount=0; repcount < hash_repetitions; repcount++)
     for (i=0; i < 10000; i++)
       gcry_md_write (hd, buf, bufsize/10);
   gcry_md_final (hd);
   stop_timer ();
   printf (" %s", elapsed_time (1));
   fflush (stdout);
 
   gcry_md_reset (hd);
   start_timer ();
   for (repcount=0; repcount < hash_repetitions; repcount++)
     for (i=0; i < 1000000; i++)
       gcry_md_write (hd, buf, 1);
   gcry_md_final (hd);
   stop_timer ();
   printf (" %s", elapsed_time (1));
   fflush (stdout);
 
   start_timer ();
   for (repcount=0; repcount < hash_repetitions; repcount++)
     for (i=0; i < 1000; i++)
       for (j=0; j < bufsize; j++)
         gcry_md_putc (hd, buf[j]);
   gcry_md_final (hd);
   stop_timer ();
   printf (" %s", elapsed_time (1));
   fflush (stdout);
 
   gcry_md_close (hd);
 
   /* Now 100 hash operations on 10000 bytes using the fast function.
      We initialize the buffer so that all memory pages are committed
      and we have repeatable values.  */
   if (gcry_md_get_algo_dlen (algo) > sizeof digest)
     die ("digest buffer too short\n");
 
   if (gcry_md_get_algo_dlen (algo))
     {
       largebuf_base = malloc (10000+15);
       if (!largebuf_base)
         die ("out of core\n");
       largebuf = (largebuf_base
                   + ((16 - ((size_t)largebuf_base & 0x0f)) % buffer_alignment));
 
       for (i=0; i < 10000; i++)
         largebuf[i] = i;
       start_timer ();
       for (repcount=0; repcount < hash_repetitions; repcount++)
         for (i=0; i < 100; i++)
           gcry_md_hash_buffer (algo, digest, largebuf, 10000);
       stop_timer ();
       printf (" %s", elapsed_time (1));
       free (largebuf_base);
     }
 
   putchar ('\n');
   fflush (stdout);
 }
 
 
 
 static void
 mac_bench ( const char *algoname )
 {
   int algo;
   gcry_mac_hd_t hd;
   int step, pos, j, i, repcount;
   char buf_base[1000+15];
   size_t bufsize = 1000;
   char *buf;
   char mac[3][512];
   char key[512];
   unsigned int maclen, keylen;
   size_t macoutlen;
   gcry_error_t err = GPG_ERR_NO_ERROR;
 
   if (!algoname)
     {
       for (i=1; i < 600; i++)
         if (in_fips_mode && i == GCRY_MAC_HMAC_MD5)
           ; /* Don't use MD5 in fips mode.  */
         else if ( !gcry_mac_test_algo (i) )
           mac_bench (gcry_mac_algo_name (i));
       return;
     }
 
   buf = buf_base + ((16 - ((size_t)buf_base & 0x0f)) % buffer_alignment);
 
   algo = gcry_mac_map_name (algoname);
   if (!algo)
     {
       fprintf (stderr, PGM ": invalid hash algorithm `%s'\n", algoname);
       exit (1);
     }
 
   maclen = gcry_mac_get_algo_maclen (algo);
   if (maclen > sizeof(mac))
     maclen = sizeof(mac);
 
   keylen = gcry_mac_get_algo_keylen (algo);
   if (keylen == 0)
     keylen = 32;
   if (keylen > sizeof(key))
     keylen = sizeof(key);
   for (i=0; i < keylen; i++)
     key[i] = (keylen - i) ^ 0x54;
 
   err = gcry_mac_open (&hd, algo, 0, NULL);
   if (err)
     {
       fprintf (stderr, PGM ": error opening mac algorithm `%s': %s\n", algoname,
                gpg_strerror (err));
       exit (1);
     }
 
   err = gcry_mac_setkey (hd, key, keylen);
   if (err)
     {
       fprintf (stderr, PGM ": error setting key for mac algorithm `%s': %s\n",
                algoname, gpg_strerror (err));
       exit (1);
     }
 
   for (i=0; i < bufsize; i++)
     buf[i] = i;
 
   if (algo >= GCRY_MAC_POLY1305_AES && algo <= GCRY_MAC_POLY1305_SEED)
     {
       static const char iv[16] = { 1, 2, 3, 4, };
       err = gcry_mac_setiv(hd, iv, sizeof(iv));
       if (err)
         {
           fprintf (stderr, PGM ": error setting nonce for mac algorithm `%s': %s\n",
                    algoname, gpg_strerror (err));
           exit (1);
         }
     }
 
   printf ("%-20s", gcry_mac_algo_name (algo));
 
   start_timer ();
   for (repcount=0; repcount < mac_repetitions; repcount++)
     for (i=0; i < 1000; i++)
       gcry_mac_write (hd, buf, bufsize);
   macoutlen = maclen;
   gcry_mac_read (hd, mac[0], &macoutlen);
   stop_timer ();
   printf (" %s", elapsed_time (1));
   fflush (stdout);
 
   gcry_mac_reset (hd);
   start_timer ();
   for (repcount=0; repcount < mac_repetitions; repcount++)
     for (i=0; i < 1000; i++)
       for (step=bufsize/10, pos=0, j=0; j < 10; j++, pos+=step)
         gcry_mac_write (hd, &buf[pos], step);
   macoutlen = maclen;
   gcry_mac_read (hd, mac[1], &macoutlen);
   stop_timer ();
   printf (" %s", elapsed_time (1));
   fflush (stdout);
 
   gcry_mac_reset (hd);
   start_timer ();
   for (repcount=0; repcount < mac_repetitions; repcount++)
     for (i=0; i < 1000; i++)
       for (step=bufsize/100, pos=0, j=0; j < 100; j++, pos+=step)
         gcry_mac_write (hd, &buf[pos], step);
   macoutlen = maclen;
   gcry_mac_read (hd, mac[2], &macoutlen);
   stop_timer ();
   printf (" %s", elapsed_time (1));
   fflush (stdout);
 
   gcry_mac_close (hd);
 
   for (i=1; i < 3; i++)
     {
       if (memcmp(mac[i-1], mac[i], maclen))
         {
           fprintf (stderr, PGM ": mac mismatch with algorithm `%s'\n",
                    algoname);
           exit(1);
         }
     }
 
   putchar ('\n');
   fflush (stdout);
 }
 
 
 static void ccm_aead_init(gcry_cipher_hd_t hd, size_t buflen, int authlen)
 {
   const int _L = 4;
   const int noncelen = 15 - _L;
   char nonce[noncelen];
   u64 params[3];
   gcry_error_t err = GPG_ERR_NO_ERROR;
 
   memset (nonce, 0x33, noncelen);
 
   err = gcry_cipher_setiv (hd, nonce, noncelen);
   if (err)
     {
       fprintf (stderr, "gcry_cipher_setiv failed: %s\n",
                gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 
   params[0] = buflen; /* encryptedlen */
   params[1] = 0; /* aadlen */
   params[2] = authlen; /* authtaglen */
   err = gcry_cipher_ctl (hd, GCRYCTL_SET_CCM_LENGTHS, params, sizeof(params));
   if (err)
     {
       fprintf (stderr, "gcry_cipher_setiv failed: %s\n",
                gpg_strerror (err));
       gcry_cipher_close (hd);
       exit (1);
     }
 }
 
 
 static gcry_error_t
 cipher_encrypt (gcry_cipher_hd_t h, char *out, size_t outsize,
 		const char *in, size_t inlen, size_t max_inlen)
 {
   gcry_error_t ret;
 
   while (inlen)
     {
       size_t currlen = inlen;
 
       if (currlen > max_inlen)
 	currlen = max_inlen;
 
       ret = gcry_cipher_encrypt(h, out, outsize, in, currlen);
       if (ret)
 	return ret;
 
       out += currlen;
       in += currlen;
       outsize -= currlen;
       inlen -= currlen;
     }
 
   return 0;
 }
 
 
 static gcry_error_t
 cipher_decrypt (gcry_cipher_hd_t h, char *out, size_t outsize,
 		const char *in, size_t inlen, size_t max_inlen)
 {
   gcry_error_t ret;
 
   while (inlen)
     {
       size_t currlen = inlen;
 
       if (currlen > max_inlen)
 	currlen = max_inlen;
 
       ret = gcry_cipher_decrypt(h, out, outsize, in, currlen);
       if (ret)
 	return ret;
 
       out += currlen;
       in += currlen;
       outsize -= currlen;
       inlen -= currlen;
     }
 
   return 0;
 }
 
 
 static void
 cipher_bench ( const char *algoname )
 {
   static int header_printed;
   int algo;
   gcry_cipher_hd_t hd;
   int i;
   int keylen, blklen;
   char key[128];
   char *outbuf, *buf;
   char *raw_outbuf, *raw_buf;
   size_t allocated_buflen, buflen;
   int repetitions;
   static const struct {
     int mode;
     const char *name;
     int blocked;
     unsigned int max_inlen;
     void (* const aead_init)(gcry_cipher_hd_t hd, size_t buflen, int authlen);
     int req_blocksize;
     int authlen;
     int noncelen;
     int doublekey;
   } modes[] = {
     { GCRY_CIPHER_MODE_ECB, "   ECB/Stream", 1, 0xffffffffU },
     { GCRY_CIPHER_MODE_CBC, " CBC/Poly1305", 1, 0xffffffffU },
     { GCRY_CIPHER_MODE_CFB, "      CFB", 0, 0xffffffffU },
     { GCRY_CIPHER_MODE_OFB, "      OFB", 0, 0xffffffffU },
     { GCRY_CIPHER_MODE_CTR, "      CTR", 0, 0xffffffffU },
     { GCRY_CIPHER_MODE_XTS, "      XTS", 0, 16 << 20,
       NULL, GCRY_XTS_BLOCK_LEN, 0, 0, 1 },
     { GCRY_CIPHER_MODE_CCM, "      CCM", 0, 0xffffffffU,
       ccm_aead_init, GCRY_CCM_BLOCK_LEN, 8, },
     { GCRY_CIPHER_MODE_GCM, "      GCM", 0, 0xffffffffU,
       NULL, GCRY_GCM_BLOCK_LEN, GCRY_GCM_BLOCK_LEN },
     { GCRY_CIPHER_MODE_OCB, "      OCB", 1, 0xffffffffU,
       NULL, 16, 16, 15 },
     { GCRY_CIPHER_MODE_EAX, "      EAX", 0, 0xffffffffU,
       NULL, 0, 8, 8 },
     { GCRY_CIPHER_MODE_STREAM, "", 0, 0xffffffffU },
     { GCRY_CIPHER_MODE_POLY1305, "", 0, 0xffffffffU,
       NULL, 1, 16, 12 },
     {0}
   };
   int modeidx;
   gcry_error_t err = GPG_ERR_NO_ERROR;
 
   if (!algoname)
     {
       for (i=1; i < 400; i++)
         if ( !gcry_cipher_test_algo (i) )
           cipher_bench (gcry_cipher_algo_name (i));
       return;
     }
 
   if (huge_buffers)
     {
       allocated_buflen = 256 * 1024 * 1024;
       repetitions = 4;
     }
   else if (large_buffers)
     {
       allocated_buflen = 1024 * 100;
       repetitions = 10;
     }
   else
     {
       allocated_buflen = 1024;
       repetitions = 1000;
     }
   repetitions *= cipher_repetitions;
 
   raw_buf = gcry_xcalloc (allocated_buflen+15, 1);
   buf = (raw_buf
          + ((16 - ((size_t)raw_buf & 0x0f)) % buffer_alignment));
   outbuf = raw_outbuf = gcry_xmalloc (allocated_buflen+15);
   outbuf = (raw_outbuf
             + ((16 - ((size_t)raw_outbuf & 0x0f)) % buffer_alignment));
 
   if (!header_printed)
     {
       if (cipher_repetitions != 1)
         printf ("Running each test %d times.\n", cipher_repetitions);
       printf ("%-12s", "");
       for (modeidx=0; modes[modeidx].mode; modeidx++)
         if (*modes[modeidx].name)
           printf (" %-15s", modes[modeidx].name );
       putchar ('\n');
       printf ("%-12s", "");
       for (modeidx=0; modes[modeidx].mode; modeidx++)
         if (*modes[modeidx].name)
           printf (" ---------------" );
       putchar ('\n');
       header_printed = 1;
     }
 
   algo = gcry_cipher_map_name (algoname);
   if (!algo)
     {
       fprintf (stderr, PGM ": invalid cipher algorithm `%s'\n", algoname);
       exit (1);
     }
 
   keylen = gcry_cipher_get_algo_keylen (algo);
   if (!keylen)
     {
       fprintf (stderr, PGM ": failed to get key length for algorithm `%s'\n",
 	       algoname);
       exit (1);
     }
   if ( keylen * 2 > sizeof key )
     {
         fprintf (stderr, PGM ": algo %d, keylength problem (%d)\n",
                  algo, keylen );
         exit (1);
     }
   for (i=0; i < keylen * 2; i++)
     key[i] = i + (clock () & 0xff);
 
   blklen = gcry_cipher_get_algo_blklen (algo);
   if (!blklen)
     {
       fprintf (stderr, PGM ": failed to get block length for algorithm `%s'\n",
 	       algoname);
       exit (1);
     }
 
   printf ("%-12s", gcry_cipher_algo_name (algo));
   fflush (stdout);
 
   for (modeidx=0; modes[modeidx].mode; modeidx++)
     {
       size_t modekeylen = keylen * (!!modes[modeidx].doublekey + 1);
       int is_stream = modes[modeidx].mode == GCRY_CIPHER_MODE_STREAM
                       || modes[modeidx].mode == GCRY_CIPHER_MODE_POLY1305;
 
       if ((blklen > 1 && is_stream) || (blklen == 1 && !is_stream))
         continue;
 
       if (modes[modeidx].mode == GCRY_CIPHER_MODE_POLY1305
           && algo != GCRY_CIPHER_CHACHA20)
         continue;
 
       if (modes[modeidx].req_blocksize > 0
           && blklen != modes[modeidx].req_blocksize)
         {
           printf (" %7s %7s", "-", "-" );
           continue;
         }
 
       for (i=0; i < sizeof buf; i++)
         buf[i] = i;
 
       err = gcry_cipher_open (&hd, algo, modes[modeidx].mode, 0);
       if (err)
         {
           fprintf (stderr, PGM ": error opening cipher `%s'\n", algoname);
           exit (1);
         }
 
       if (!cipher_with_keysetup)
         {
           err = gcry_cipher_setkey (hd, key, modekeylen);
           if (err)
             {
               fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
                        gpg_strerror (err));
               gcry_cipher_close (hd);
               exit (1);
             }
         }
 
       buflen = allocated_buflen;
       if (modes[modeidx].blocked)
         buflen = (buflen / blklen) * blklen;
 
       start_timer ();
       for (i=err=0; !err && i < repetitions; i++)
         {
           if (cipher_with_keysetup)
             {
               err = gcry_cipher_setkey (hd, key, modekeylen);
               if (err)
                 {
                   fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
                            gpg_strerror (err));
                   gcry_cipher_close (hd);
                   exit (1);
                 }
             }
 
           if (modes[modeidx].noncelen)
             {
               char nonce[100];
               size_t noncelen;
 
               noncelen = modes[modeidx].noncelen;
               if (noncelen > sizeof nonce)
                 noncelen = sizeof nonce;
               memset (nonce, 42, noncelen);
               err = gcry_cipher_setiv (hd, nonce, noncelen);
               if (err)
                 {
                   fprintf (stderr, "gcry_cipher_setiv failed: %s\n",
                            gpg_strerror (err));
                   gcry_cipher_close (hd);
                   exit (1);
                 }
             }
 
           if (modes[modeidx].aead_init)
             {
               (*modes[modeidx].aead_init) (hd, buflen, modes[modeidx].authlen);
               gcry_cipher_final (hd);
               err = cipher_encrypt (hd, outbuf, buflen, buf, buflen,
 				    modes[modeidx].max_inlen);
               if (err)
                 break;
               err = gcry_cipher_gettag (hd, outbuf, modes[modeidx].authlen);
             }
           else
             {
               err = cipher_encrypt (hd, outbuf, buflen, buf, buflen,
 				    modes[modeidx].max_inlen);
             }
         }
       stop_timer ();
 
       printf (" %s", elapsed_time (1));
       fflush (stdout);
       gcry_cipher_close (hd);
       if (err)
         {
           fprintf (stderr, "gcry_cipher_encrypt failed: %s\n",
                    gpg_strerror (err) );
           exit (1);
         }
 
       err = gcry_cipher_open (&hd, algo, modes[modeidx].mode, 0);
       if (err)
         {
           fprintf (stderr, PGM ": error opening cipher `%s'/n", algoname);
           exit (1);
         }
 
       if (!cipher_with_keysetup)
         {
           err = gcry_cipher_setkey (hd, key, modekeylen);
           if (err)
             {
               fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
                        gpg_strerror (err));
               gcry_cipher_close (hd);
               exit (1);
             }
         }
 
       start_timer ();
       for (i=err=0; !err && i < repetitions; i++)
         {
           if (cipher_with_keysetup)
             {
               err = gcry_cipher_setkey (hd, key, modekeylen);
               if (err)
                 {
                   fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
                            gpg_strerror (err));
                   gcry_cipher_close (hd);
                   exit (1);
                 }
             }
 
           if (modes[modeidx].noncelen)
             {
               char nonce[100];
               size_t noncelen;
 
               noncelen = modes[modeidx].noncelen;
               if (noncelen > sizeof nonce)
                 noncelen = sizeof nonce;
               memset (nonce, 42, noncelen);
               err = gcry_cipher_setiv (hd, nonce, noncelen);
               if (err)
                 {
                   fprintf (stderr, "gcry_cipher_setiv failed: %s\n",
                            gpg_strerror (err));
                   gcry_cipher_close (hd);
                   exit (1);
                 }
             }
 
           if (modes[modeidx].aead_init)
             {
               (*modes[modeidx].aead_init) (hd, buflen, modes[modeidx].authlen);
               gcry_cipher_final (hd);
               err = cipher_decrypt (hd, outbuf, buflen, buf, buflen,
 				    modes[modeidx].max_inlen);
               if (err)
                 break;
               err = gcry_cipher_checktag (hd, outbuf, modes[modeidx].authlen);
               if (gpg_err_code (err) == GPG_ERR_CHECKSUM)
                 err = 0;
             }
           else
             {
               gcry_cipher_final (hd);
               err = cipher_decrypt (hd, outbuf, buflen, buf, buflen,
 				    modes[modeidx].max_inlen);
             }
         }
       stop_timer ();
       printf (" %s", elapsed_time (1));
       fflush (stdout);
       gcry_cipher_close (hd);
       if (err)
         {
           fprintf (stderr, "gcry_cipher_decrypt failed: %s\n",
                    gpg_strerror (err) );
           exit (1);
         }
     }
 
   putchar ('\n');
   gcry_free (raw_buf);
   gcry_free (raw_outbuf);
 }
 
 
 
 static void
 rsa_bench (int iterations, int print_header, int no_blinding)
 {
   gpg_error_t err;
   int p_sizes[] = { 1024, 2048, 3072, 4096 };
   int testno;
 
   if (print_header)
     printf ("Algorithm         generate %4d*priv %4d*public\n"
             "------------------------------------------------\n",
             iterations, iterations );
   for (testno=0; testno < DIM (p_sizes); testno++)
     {
       gcry_sexp_t key_spec, key_pair, pub_key, sec_key;
       gcry_mpi_t x;
       gcry_sexp_t data;
       gcry_sexp_t sig = NULL;
       int count;
       unsigned nbits = p_sizes[testno];
 
       printf ("RSA %3d bit    ", nbits);
       fflush (stdout);
 
       if (in_fips_mode && !(nbits == 2048 || nbits == 3072))
         {
           puts ("[skipped in fips mode]");
           continue;
         }
 
       err = gcry_sexp_build (&key_spec, NULL,
                              gcry_fips_mode_active ()
                              ? "(genkey (RSA (nbits %d)))"
                              : "(genkey (RSA (nbits %d)(transient-key)))",
                              nbits);
       if (err)
         die ("creating S-expression failed: %s\n", gcry_strerror (err));
 
       start_timer ();
       err = gcry_pk_genkey (&key_pair, key_spec);
       if (err)
         die ("creating %d bit RSA key failed: %s\n",
              nbits, gcry_strerror (err));
 
       pub_key = gcry_sexp_find_token (key_pair, "public-key", 0);
       if (! pub_key)
         die ("public part missing in key\n");
       sec_key = gcry_sexp_find_token (key_pair, "private-key", 0);
       if (! sec_key)
         die ("private part missing in key\n");
       gcry_sexp_release (key_pair);
       gcry_sexp_release (key_spec);
 
       stop_timer ();
       printf ("   %s", elapsed_time (1));
       fflush (stdout);
 
       x = gcry_mpi_new (nbits);
       gcry_mpi_randomize (x, nbits-8, GCRY_WEAK_RANDOM);
       err = gcry_sexp_build (&data, NULL,
                              "(data (flags raw) (value %m))", x);
       gcry_mpi_release (x);
       if (err)
         die ("converting data failed: %s\n", gcry_strerror (err));
 
       start_timer ();
       for (count=0; count < iterations; count++)
         {
           gcry_sexp_release (sig);
           err = gcry_pk_sign (&sig, data, sec_key);
           if (err)
             die ("signing failed (%d): %s\n", count, gpg_strerror (err));
         }
       stop_timer ();
       printf ("   %s", elapsed_time (1));
       fflush (stdout);
 
       start_timer ();
       for (count=0; count < iterations; count++)
         {
           err = gcry_pk_verify (sig, data, pub_key);
           if (err)
             {
               putchar ('\n');
               show_sexp ("seckey:\n", sec_key);
               show_sexp ("data:\n", data);
               show_sexp ("sig:\n", sig);
               die ("verify failed (%d): %s\n", count, gpg_strerror (err));
             }
         }
       stop_timer ();
       printf ("     %s", elapsed_time (1));
 
       if (no_blinding)
         {
           fflush (stdout);
           x = gcry_mpi_new (nbits);
           gcry_mpi_randomize (x, nbits-8, GCRY_WEAK_RANDOM);
           err = gcry_sexp_build (&data, NULL,
                                  "(data (flags no-blinding) (value %m))", x);
           gcry_mpi_release (x);
           if (err)
             die ("converting data failed: %s\n", gcry_strerror (err));
 
           start_timer ();
           for (count=0; count < iterations; count++)
             {
               gcry_sexp_release (sig);
               err = gcry_pk_sign (&sig, data, sec_key);
               if (err)
                 die ("signing failed (%d): %s\n", count, gpg_strerror (err));
             }
           stop_timer ();
           printf ("   %s", elapsed_time (1));
           fflush (stdout);
         }
 
       putchar ('\n');
       fflush (stdout);
 
       gcry_sexp_release (sig);
       gcry_sexp_release (data);
       gcry_sexp_release (sec_key);
       gcry_sexp_release (pub_key);
     }
 }
 
 
 static void
 elg_bench (int iterations, int print_header)
 {
   gpg_error_t err;
   gcry_sexp_t pub_key[3], sec_key[3];
   int p_sizes[3] = { 1024, 2048, 3072 };
   gcry_sexp_t data = NULL;
   gcry_sexp_t enc = NULL;
   gcry_sexp_t plain = NULL;
   int i, j;
 
   err = gcry_sexp_sscan (pub_key+0, NULL, sample_public_elg_key_1024,
                          strlen (sample_public_elg_key_1024));
   if (!err)
     err = gcry_sexp_sscan (sec_key+0, NULL, sample_private_elg_key_1024,
                            strlen (sample_private_elg_key_1024));
   if (!err)
     err = gcry_sexp_sscan (pub_key+1, NULL, sample_public_elg_key_2048,
                            strlen (sample_public_elg_key_2048));
   if (!err)
     err = gcry_sexp_sscan (sec_key+1, NULL, sample_private_elg_key_2048,
                            strlen (sample_private_elg_key_2048));
   if (!err)
     err = gcry_sexp_sscan (pub_key+2, NULL, sample_public_elg_key_3072,
                            strlen (sample_public_elg_key_3072));
   if (!err)
     err = gcry_sexp_sscan (sec_key+2, NULL, sample_private_elg_key_3072,
                            strlen (sample_private_elg_key_3072));
   if (err)
     {
       fprintf (stderr, PGM ": converting sample keys failed: %s\n",
                gcry_strerror (err));
       exit (1);
     }
 
   if (print_header)
     printf ("Algorithm         generate %4d*priv %4d*public\n"
             "------------------------------------------------\n",
             iterations, iterations );
   for (i=0; i < DIM (p_sizes); i++)
     {
       char timerbuf1[100];
 
       {
         gcry_mpi_t x = gcry_mpi_new (p_sizes[i]);
         gcry_mpi_randomize (x, p_sizes[i] - 16, GCRY_WEAK_RANDOM);
         err = gcry_sexp_build (&data, NULL, "(data (flags raw) (value %m))", x);
         gcry_mpi_release (x);
       }
       if (err)
         {
           fprintf (stderr, PGM ": converting data failed: %s\n",
                    gcry_strerror (err));
           exit (1);
         }
 
       printf ("ELG %d bit             -", p_sizes[i]);
       fflush (stdout);
 
       start_timer ();
       for (j=0; j < iterations; j++)
         {
           gcry_sexp_release (enc);
           err = gcry_pk_encrypt (&enc, data, pub_key[i]);
           if (err)
             {
               putchar ('\n');
               fprintf (stderr, PGM ": encrypt failed: %s\n",
                        gpg_strerror (err));
               exit (1);
             }
         }
       stop_timer ();
       snprintf (timerbuf1, sizeof timerbuf1, "   %s", elapsed_time (1));
       fflush (stdout);
 
       start_timer ();
       for (j=0; j < iterations; j++)
         {
           gcry_sexp_release (plain);
           err = gcry_pk_decrypt (&plain, enc, sec_key[i]);
           if (err)
             {
               putchar ('\n');
               fprintf (stderr, PGM ": decrypt failed: %s\n",
                        gpg_strerror (err));
               exit (1);
             }
         }
       stop_timer ();
 
       printf ("   %s  %s\n", elapsed_time (1), timerbuf1);
       fflush (stdout);
 
       gcry_sexp_release (plain);
       plain = NULL;
       gcry_sexp_release (enc);
       enc = NULL;
       gcry_sexp_release (data);
       data = NULL;
     }
 
   for (i=0; i < DIM (p_sizes); i++)
     {
       gcry_sexp_release (sec_key[i]);
       gcry_sexp_release (pub_key[i]);
     }
 }
 
 
 static void
 dsa_bench (int iterations, int print_header)
 {
   gpg_error_t err;
   gcry_sexp_t pub_key[3], sec_key[3];
   int p_sizes[3] = { 1024, 2048, 3072 };
   int q_sizes[3] = { 160, 224, 256 };
   gcry_sexp_t data;
   gcry_sexp_t sig = NULL;
   int i, j;
 
   err = gcry_sexp_sscan (pub_key+0, NULL, sample_public_dsa_key_1024,
                          strlen (sample_public_dsa_key_1024));
   if (!err)
     err = gcry_sexp_sscan (sec_key+0, NULL, sample_private_dsa_key_1024,
                            strlen (sample_private_dsa_key_1024));
   if (!err)
     err = gcry_sexp_sscan (pub_key+1, NULL, sample_public_dsa_key_2048,
                            strlen (sample_public_dsa_key_2048));
   if (!err)
     err = gcry_sexp_sscan (sec_key+1, NULL, sample_private_dsa_key_2048,
                            strlen (sample_private_dsa_key_2048));
   if (!err)
     err = gcry_sexp_sscan (pub_key+2, NULL, sample_public_dsa_key_3072,
                            strlen (sample_public_dsa_key_3072));
   if (!err)
     err = gcry_sexp_sscan (sec_key+2, NULL, sample_private_dsa_key_3072,
                            strlen (sample_private_dsa_key_3072));
   if (err)
     {
       fprintf (stderr, PGM ": converting sample keys failed: %s\n",
                gcry_strerror (err));
       exit (1);
     }
 
   if (print_header)
     printf ("Algorithm         generate %4d*priv %4d*public\n"
             "------------------------------------------------\n",
             iterations, iterations );
   for (i=0; i < DIM (q_sizes); i++)
     {
       gcry_mpi_t x;
 
       x = gcry_mpi_new (q_sizes[i]);
       gcry_mpi_randomize (x, q_sizes[i], GCRY_WEAK_RANDOM);
       err = gcry_sexp_build (&data, NULL, "(data (flags raw) (value %m))", x);
       gcry_mpi_release (x);
       if (err)
         {
           fprintf (stderr, PGM ": converting data failed: %s\n",
                    gcry_strerror (err));
           exit (1);
         }
 
       printf ("DSA %d/%d             -", p_sizes[i], q_sizes[i]);
       fflush (stdout);
 
       start_timer ();
       for (j=0; j < iterations; j++)
         {
           gcry_sexp_release (sig);
           err = gcry_pk_sign (&sig, data, sec_key[i]);
           if (err)
             {
               putchar ('\n');
               fprintf (stderr, PGM ": signing failed: %s\n",
                        gpg_strerror (err));
               exit (1);
             }
         }
       stop_timer ();
       printf ("   %s", elapsed_time (1));
       fflush (stdout);
 
       start_timer ();
       for (j=0; j < iterations; j++)
         {
           err = gcry_pk_verify (sig, data, pub_key[i]);
           if (err)
             {
               putchar ('\n');
               fprintf (stderr, PGM ": verify failed: %s\n",
                        gpg_strerror (err));
               exit (1);
             }
         }
       stop_timer ();
       printf ("     %s\n", elapsed_time (1));
       fflush (stdout);
 
       gcry_sexp_release (sig);
       gcry_sexp_release (data);
       sig = NULL;
     }
 
 
   for (i=0; i < DIM (q_sizes); i++)
     {
       gcry_sexp_release (sec_key[i]);
       gcry_sexp_release (pub_key[i]);
     }
 }
 
 
 static void
 ecc_bench (int iterations, int print_header)
 {
 #if USE_ECC
   gpg_error_t err;
   const char *p_sizes[] = { "192", "224", "256", "384", "521", "Ed25519",
               "gost256", "gost512" };
   int testno;
 
   if (print_header)
     printf ("Algorithm         generate %4d*priv %4d*public\n"
             "------------------------------------------------\n",
             iterations, iterations );
   for (testno=0; testno < DIM (p_sizes); testno++)
     {
       gcry_sexp_t key_spec, key_pair, pub_key, sec_key;
       gcry_mpi_t x;
       gcry_sexp_t data;
       gcry_sexp_t sig = NULL;
       int count;
       int p_size;
       int is_ed25519;
       int is_gost;
 
       is_ed25519 = !strcmp (p_sizes[testno], "Ed25519");
       is_gost = !strncmp (p_sizes[testno], "gost", 4);
 
       /* Only P-{224,256,384,521} are allowed in fips mode */
       if (gcry_fips_mode_active()
           && (is_ed25519 || is_gost || !strcmp (p_sizes[testno], "192")))
          continue;
 
       if (is_ed25519)
         {
           p_size = 256;
           printf ("EdDSA Ed25519 ");
           fflush (stdout);
         }
       else if (is_gost)
         {
           p_size = atoi (p_sizes[testno] + 4);
           printf ("GOST  %3d bit ", p_size);
           fflush (stdout);
         }
       else
         {
           p_size = atoi (p_sizes[testno]);
           printf ("ECDSA %3d bit ", p_size);
         }
       fflush (stdout);
 
       if (is_ed25519)
         err = gcry_sexp_build (&key_spec, NULL,
                                "(genkey (ecdsa (curve \"Ed25519\")"
                                "(flags eddsa)))");
       else if (is_gost)
         err = gcry_sexp_build (&key_spec, NULL,
                                "(genkey (ecdsa (curve %s)))",
                                p_size == 256 ? "GOST2001-test" : "GOST2012-test");
       else
         err = gcry_sexp_build (&key_spec, NULL,
                                "(genkey (ECDSA (nbits %d)))", p_size);
       if (err)
         die ("creating S-expression failed: %s\n", gcry_strerror (err));
 
       start_timer ();
       err = gcry_pk_genkey (&key_pair, key_spec);
       if (err)
         die ("creating %d bit ECC key failed: %s\n",
              p_size, gcry_strerror (err));
       if (verbose > 2)
         show_sexp ("ECC key:\n", key_pair);
 
       pub_key = gcry_sexp_find_token (key_pair, "public-key", 0);
       if (! pub_key)
         die ("public part missing in key\n");
       sec_key = gcry_sexp_find_token (key_pair, "private-key", 0);
       if (! sec_key)
         die ("private part missing in key\n");
       gcry_sexp_release (key_pair);
       gcry_sexp_release (key_spec);
 
       stop_timer ();
       printf ("     %s", elapsed_time (1));
       fflush (stdout);
 
       x = gcry_mpi_new (p_size);
       gcry_mpi_randomize (x, p_size, GCRY_WEAK_RANDOM);
       if (is_ed25519)
         err = gcry_sexp_build (&data, NULL,
                                "(data (flags eddsa)(hash-algo sha512)"
                                " (value %m))", x);
       else if (is_gost)
         err = gcry_sexp_build (&data, NULL, "(data (flags gost) (value %m))", x);
       else
         err = gcry_sexp_build (&data, NULL, "(data (flags raw) (value %m))", x);
       gcry_mpi_release (x);
 
       if (err)
         die ("converting data failed: %s\n", gcry_strerror (err));
 
       start_timer ();
       for (count=0; count < iterations; count++)
         {
           gcry_sexp_release (sig);
           err = gcry_pk_sign (&sig, data, sec_key);
           if (err)
             {
               if (verbose)
                 {
                   putc ('\n', stderr);
                   show_sexp ("signing key:\n", sec_key);
                   show_sexp ("signed data:\n", data);
                 }
               die ("signing failed: %s\n", gpg_strerror (err));
             }
         }
       stop_timer ();
       printf ("   %s", elapsed_time (1));
       fflush (stdout);
 
       start_timer ();
       for (count=0; count < iterations; count++)
         {
           err = gcry_pk_verify (sig, data, pub_key);
           if (err)
             {
               putchar ('\n');
               show_sexp ("seckey:\n", sec_key);
               show_sexp ("data:\n", data);
               show_sexp ("sig:\n", sig);
               die ("verify failed: %s\n", gpg_strerror (err));
             }
         }
       stop_timer ();
       printf ("     %s\n", elapsed_time (1));
       fflush (stdout);
 
       gcry_sexp_release (sig);
       gcry_sexp_release (data);
       gcry_sexp_release (sec_key);
       gcry_sexp_release (pub_key);
     }
 #endif /*USE_ECC*/
 }
 
 
 
 static void
 do_powm ( const char *n_str, const char *e_str, const char *m_str)
 {
   gcry_mpi_t e, n, msg, cip;
   gcry_error_t err;
   int i;
 
   err = gcry_mpi_scan (&n, GCRYMPI_FMT_HEX, n_str, 0, 0);
   if (err) BUG ();
   err = gcry_mpi_scan (&e, GCRYMPI_FMT_HEX, e_str, 0, 0);
   if (err) BUG ();
   err = gcry_mpi_scan (&msg, GCRYMPI_FMT_HEX, m_str, 0, 0);
   if (err) BUG ();
 
   cip = gcry_mpi_new (0);
 
   start_timer ();
   for (i=0; i < 1000; i++)
     gcry_mpi_powm (cip, msg, e, n);
   stop_timer ();
   printf (" %s", elapsed_time (1)); fflush (stdout);
 /*    { */
 /*      char *buf; */
 
 /*      if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, (void**)&buf, NULL, cip)) */
 /*        BUG (); */
 /*      printf ("result: %s\n", buf); */
 /*      gcry_free (buf); */
 /*    } */
   gcry_mpi_release (cip);
   gcry_mpi_release (msg);
   gcry_mpi_release (n);
   gcry_mpi_release (e);
 }
 
 
 static void
 mpi_bench (void)
 {
   printf ("%-10s", "powm"); fflush (stdout);
 
   do_powm (
 "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E4",
            "29",
 "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8"
            );
   do_powm (
            "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA40716",
            "29",
            "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847"
            );
   do_powm (
            "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA4071620A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA40716",
            "29",
            "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847"
            );
 
   putchar ('\n');
 
 
 }
 
 
 static void
 prime_bench (void)
 {
   gpg_error_t err;
   int i;
   gcry_mpi_t prime;
   int old_prog = single_char_progress;
 
   single_char_progress = 1;
   if (!with_progress)
     printf ("%-10s", "prime");
   fflush (stdout);
   start_timer ();
   for (i=0; i < 10; i++)
     {
       if (with_progress)
         fputs ("primegen ", stdout);
       err = gcry_prime_generate (&prime,
                                  1024, 0,
                                  NULL,
                                  NULL, NULL,
                                  GCRY_WEAK_RANDOM,
                                  GCRY_PRIME_FLAG_SECRET);
       if (with_progress)
         {
           fputc ('\n', stdout);
           fflush (stdout);
         }
       if (err)
         {
           fprintf (stderr, PGM ": error creating prime: %s\n",
                    gpg_strerror (err));
           exit (1);
         }
       gcry_mpi_release (prime);
     }
   stop_timer ();
   if (with_progress)
     printf ("%-10s", "prime");
   printf (" %s\n", elapsed_time (1)); fflush (stdout);
 
   single_char_progress = old_prog;
 }
 
 
 int
 main( int argc, char **argv )
 {
   int last_argc = -1;
   int no_blinding = 0;
   int use_random_daemon = 0;
   int use_secmem = 0;
   int pk_count = 100;
 
   buffer_alignment = 1;
 
   if (argc)
     { argc--; argv++; }
 
   /* We skip this test if we are running under the test suite (no args
      and srcdir defined) and GCRYPT_NO_BENCHMARKS is set.  */
   if (!argc && getenv ("srcdir") && getenv ("GCRYPT_NO_BENCHMARKS"))
     exit (77);
 
   if (getenv ("GCRYPT_IN_REGRESSION_TEST"))
     {
       in_regression_test = 1;
       pk_count = 10;
     }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           fputs ("usage: benchmark "
                  "[md|mac|cipher|random|mpi|rsa|dsa|ecc|prime [algonames]]\n",
                  stdout);
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose += 2;
           debug++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--use-random-daemon"))
         {
           use_random_daemon = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--use-secmem"))
         {
           use_secmem = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--prefer-standard-rng"))
         {
           /* This is anyway the default, but we may want to use it for
              debugging. */
-          xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_STANDARD);
+          xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_STANDARD));
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--prefer-fips-rng"))
         {
-          xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_FIPS);
+          xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_FIPS));
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--prefer-system-rng"))
         {
-          xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_SYSTEM);
+          xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_SYSTEM));
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--no-blinding"))
         {
           no_blinding = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--large-buffers"))
         {
           large_buffers = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--huge-buffers"))
         {
           huge_buffers = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--cipher-repetitions"))
         {
           argc--; argv++;
           if (argc)
             {
               cipher_repetitions = atoi(*argv);
               argc--; argv++;
             }
         }
       else if (!strcmp (*argv, "--cipher-with-keysetup"))
         {
           cipher_with_keysetup = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--hash-repetitions"))
         {
           argc--; argv++;
           if (argc)
             {
               hash_repetitions = atoi(*argv);
               argc--; argv++;
             }
         }
       else if (!strcmp (*argv, "--mac-repetitions"))
         {
           argc--; argv++;
           if (argc)
             {
               mac_repetitions = atoi(*argv);
               argc--; argv++;
             }
         }
       else if (!strcmp (*argv, "--pk-count"))
         {
           argc--; argv++;
           if (argc)
             {
               pk_count = atoi(*argv);
               argc--; argv++;
             }
         }
       else if (!strcmp (*argv, "--alignment"))
         {
           argc--; argv++;
           if (argc)
             {
               buffer_alignment = atoi(*argv);
               argc--; argv++;
             }
         }
       else if (!strcmp (*argv, "--disable-hwf"))
         {
           argc--; argv++;
           if (argc)
             {
               if (gcry_control (GCRYCTL_DISABLE_HWF, *argv, NULL))
                 fprintf (stderr, PGM ": unknown hardware feature `%s'"
                          " - option ignored\n", *argv);
               argc--; argv++;
             }
         }
       else if (!strcmp (*argv, "--fips"))
         {
           argc--; argv++;
           /* This command needs to be called before gcry_check_version.  */
-          xgcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
+          xgcry_control ((GCRYCTL_FORCE_FIPS_MODE, 0));
         }
       else if (!strcmp (*argv, "--progress"))
         {
           argc--; argv++;
           with_progress = 1;
         }
     }
 
   if (buffer_alignment < 1 || buffer_alignment > 16)
     die ("value for --alignment must be in the range 1 to 16\n");
 
-  xgcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
+  xgcry_control ((GCRYCTL_SET_VERBOSITY, (int)verbose));
 
   if (!gcry_check_version (GCRYPT_VERSION))
     {
       fprintf (stderr, PGM ": version mismatch; pgm=%s, library=%s\n",
                GCRYPT_VERSION, gcry_check_version (NULL));
       exit (1);
     }
 
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u , 0));
 
   if (gcry_fips_mode_active ())
     in_fips_mode = 1;
   else if (!use_secmem)
-    xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+    xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
 
   if (use_random_daemon)
-    xgcry_control (GCRYCTL_USE_RANDOM_DAEMON, 1);
+    xgcry_control ((GCRYCTL_USE_RANDOM_DAEMON, 1));
 
   if (with_progress)
     gcry_set_progress_handler (progress_cb, NULL);
 
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   if (cipher_repetitions < 1)
     cipher_repetitions = 1;
   if (hash_repetitions < 1)
     hash_repetitions = 1;
   if (mac_repetitions < 1)
     mac_repetitions = 1;
 
   if (in_regression_test)
     fputs ("Note: " PGM " running in quick regression test mode.\n", stdout);
 
   if ( !argc )
     {
-      xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+      xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
       md_bench (NULL);
       putchar ('\n');
       mac_bench (NULL);
       putchar ('\n');
       cipher_bench (NULL);
       putchar ('\n');
       rsa_bench (pk_count, 1, no_blinding);
       elg_bench (pk_count, 0);
       dsa_bench (pk_count, 0);
       ecc_bench (pk_count, 0);
       putchar ('\n');
       mpi_bench ();
       putchar ('\n');
       random_bench (0);
     }
   else if ( !strcmp (*argv, "random") || !strcmp (*argv, "strongrandom"))
     {
       if (argc == 1)
         random_bench ((**argv == 's'));
       else if (argc == 2)
         {
-          xgcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, argv[1]);
+          xgcry_control ((GCRYCTL_SET_RANDOM_SEED_FILE, argv[1]));
           random_bench ((**argv == 's'));
-          xgcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
+          xgcry_control ((GCRYCTL_UPDATE_RANDOM_SEED_FILE));
         }
       else
         fputs ("usage: benchmark [strong]random [seedfile]\n", stdout);
     }
   else if ( !strcmp (*argv, "md"))
     {
       if (argc == 1)
         md_bench (NULL);
       else
         for (argc--, argv++; argc; argc--, argv++)
           md_bench ( *argv );
     }
   else if ( !strcmp (*argv, "mac"))
     {
       if (argc == 1)
         mac_bench (NULL);
       else
         for (argc--, argv++; argc; argc--, argv++)
           mac_bench ( *argv );
     }
   else if ( !strcmp (*argv, "cipher"))
     {
       if (argc == 1)
         cipher_bench (NULL);
       else
         for (argc--, argv++; argc; argc--, argv++)
           cipher_bench ( *argv );
     }
   else if ( !strcmp (*argv, "mpi"))
     {
         mpi_bench ();
     }
   else if ( !strcmp (*argv, "pubkey"))
     {
-        xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+        xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
         rsa_bench (pk_count, 1, no_blinding);
         elg_bench (pk_count, 0);
         dsa_bench (pk_count, 0);
         ecc_bench (pk_count, 0);
     }
   else if ( !strcmp (*argv, "rsa"))
     {
-        xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+        xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
         rsa_bench (pk_count, 1, no_blinding);
     }
   else if ( !strcmp (*argv, "elg"))
     {
-        xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+        xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
         elg_bench (pk_count, 1);
     }
   else if ( !strcmp (*argv, "dsa"))
     {
-        xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+        xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
         dsa_bench (pk_count, 1);
     }
   else if ( !strcmp (*argv, "ecc"))
     {
-        xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+        xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
         ecc_bench (pk_count, 1);
     }
   else if ( !strcmp (*argv, "prime"))
     {
-        xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+        xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
         prime_bench ();
     }
   else
     {
       fprintf (stderr, PGM ": bad arguments\n");
       return 1;
     }
 
 
   if (in_fips_mode && !gcry_fips_mode_active ())
     fprintf (stderr, PGM ": FIPS mode is not anymore active\n");
 
   return 0;
 }
diff --git a/tests/curves.c b/tests/curves.c
index 9e75fd55..dc5ebe77 100644
--- a/tests/curves.c
+++ b/tests/curves.c
@@ -1,190 +1,190 @@
 /* curves.c -  ECC curves regression tests
  *	Copyright (C) 2011 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 
 #include "../src/gcrypt-int.h"
 
 
 #define PGM "curves"
 #include "t-common.h"
 
 /* Number of curves defined in ../cipger/ecc.c */
 #define N_CURVES 22
 
 /* A real world sample public key.  */
 static char const sample_key_1[] =
 "(public-key\n"
 " (ecdsa\n"
 "  (p #00FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF#)\n"
 "  (a #00FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC#)\n"
 "  (b #5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B#)\n"
 "  (g #046B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296"
         "4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5#)\n"
 "  (n #00FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551#)\n"
 "  (h #000000000000000000000000000000000000000000000000000000000000000001#)\n"
 "  (q #0442B927242237639A36CE9221B340DB1A9AB76DF2FE3E171277F6A4023DED146EE"
       "86525E38CCECFF3FB8D152CC6334F70D23A525175C1BCBDDE6E023B2228770E#)\n"
 "  ))";
 static char const sample_key_1_curve[] = "NIST P-256";
 static unsigned int sample_key_1_nbits = 256;
 
 /* A made up sample public key.  */
 static char const sample_key_2[] =
 "(public-key\n"
 " (ecdh\n"
 "  (p #00e95e4a5f737059dc60dfc7ad95b3d8139515620f#)\n"
 "  (a #340e7be2a280eb74e2be61bada745d97e8f7c300#)\n"
 "  (b #1e589a8595423412134faa2dbdec95c8d8675e58#)\n"
 "  (g #04bed5af16ea3f6a4f62938c4631eb5af7bdbcdbc3"
         "1667cb477a1a8ec338f94741669c976316da6321#)\n"
 "  (n #00e95e4a5f737059dc60df5991d45029409e60fc09#)\n"
 "  (h #000000000000000000000000000000000000000000000000000000000000000001#)\n"
 "  (q #041111111111111111111111111111111111111111"
         "2222222222222222222222222222222222222222#)\n"
 "  ))";
 static char const sample_key_2_curve[] = "brainpoolP160r1";
 static unsigned int sample_key_2_nbits = 160;
 
 
 static void
 list_curves (void)
 {
   int idx;
   const char *name;
   unsigned int nbits;
 
   for (idx=0; (name = gcry_pk_get_curve (NULL, idx, &nbits)); idx++)
     {
       if (verbose)
         printf ("%s - %u bits\n", name, nbits);
     }
   if (idx != N_CURVES)
     fail ("expected %d curves but got %d\n", N_CURVES, idx);
   if (gcry_pk_get_curve (NULL, -1, NULL))
     fail ("curve iteration failed\n");
 }
 
 
 static void
 check_matching (void)
 {
   gpg_error_t err;
   gcry_sexp_t key;
   const char *name;
   unsigned int nbits;
 
   err = gcry_sexp_new (&key, sample_key_1, 0, 1);
   if (err)
     die ("parsing s-expression string failed: %s\n", gpg_strerror (err));
   name = gcry_pk_get_curve (key, 0, &nbits);
   if (!name)
     fail ("curve name not found for sample_key_1\n");
   else if (strcmp (name, sample_key_1_curve))
     fail ("expected curve name %s but got %s for sample_key_1\n",
           sample_key_1_curve, name);
   else if (nbits != sample_key_1_nbits)
     fail ("expected curve size %u but got %u for sample_key_1\n",
           sample_key_1_nbits, nbits);
 
   gcry_sexp_release (key);
 
   err = gcry_sexp_new (&key, sample_key_2, 0, 1);
   if (err)
     die ("parsing s-expression string failed: %s\n", gpg_strerror (err));
   name = gcry_pk_get_curve (key, 0, &nbits);
   if (!name)
     fail ("curve name not found for sample_key_2\n");
   else if (strcmp (name, sample_key_2_curve))
     fail ("expected curve name %s but got %s for sample_key_2\n",
           sample_key_2_curve, name);
   else if (nbits != sample_key_2_nbits)
     fail ("expected curve size %u but got %u for sample_key_2\n",
           sample_key_2_nbits, nbits);
 
   gcry_sexp_release (key);
 }
 
 
 static void
 check_get_params (void)
 {
   gcry_sexp_t param;
   const char *name;
 
   param = gcry_pk_get_param (GCRY_PK_ECDSA, sample_key_1_curve);
   if (!param)
     fail ("error gerring parameters for `%s'\n", sample_key_1_curve);
 
   name = gcry_pk_get_curve (param, 0, NULL);
   if (!name)
     fail ("get_param: curve name not found for sample_key_1\n");
   else if (strcmp (name, sample_key_1_curve))
     fail ("get_param: expected curve name %s but got %s for sample_key_1\n",
           sample_key_1_curve, name);
 
   gcry_sexp_release (param);
 
   /* Brainpool curves are not supported in fips mode */
   if (gcry_fips_mode_active())
     return;
 
   param = gcry_pk_get_param (GCRY_PK_ECDSA, sample_key_2_curve);
   if (!param)
     fail ("error gerring parameters for `%s'\n", sample_key_2_curve);
 
   name = gcry_pk_get_curve (param, 0, NULL);
   if (!name)
     fail ("get_param: curve name not found for sample_key_2\n");
   else if (strcmp (name, sample_key_2_curve))
     fail ("get_param: expected curve name %s but got %s for sample_key_2\n",
           sample_key_2_curve, name);
 
   gcry_sexp_release (param);
 }
 
 
 int
 main (int argc, char **argv)
 {
   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     verbose = 1;
   else if (argc > 1 && !strcmp (argv[1], "--debug"))
     verbose = debug = 1;
 
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
   list_curves ();
   check_matching ();
   check_get_params ();
 
   return error_count ? 1 : 0;
 }
diff --git a/tests/dsa-rfc6979.c b/tests/dsa-rfc6979.c
index 2cfa94a8..7d3d2080 100644
--- a/tests/dsa-rfc6979.c
+++ b/tests/dsa-rfc6979.c
@@ -1,983 +1,983 @@
 /* dsa-rfc6979.c - Test for Deterministic DSA
  * Copyright (C) 2008 Free Software Foundation, Inc.
  * Copyright (C) 2013 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 
 #ifndef _GCRYPT_IN_LIBGCRYPT
 # include <gcrypt.h>
 #endif
 
 #define PGM "dsa-rfc6979"
 #include "t-common.h"
 
 
 static void
 show_sexp (const char *prefix, gcry_sexp_t a)
 {
   char *buf;
   size_t size;
 
   if (prefix)
     fputs (prefix, stderr);
   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   buf = gcry_xmalloc (size);
 
   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
   fprintf (stderr, "%.*s", (int)size, buf);
   gcry_free (buf);
 }
 
 
 /* Convert STRING consisting of hex characters into its binary
    representation and return it as an allocated buffer. The valid
    length of the buffer is returned at R_LENGTH.  The string is
    delimited by end of string.  The function returns NULL on
    error.  */
 static void *
 data_from_hex (const char *string, size_t *r_length)
 {
   const char *s;
   unsigned char *buffer;
   size_t length;
 
   buffer = gcry_xmalloc (strlen(string)/2+1);
   length = 0;
   for (s=string; *s; s +=2 )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         die ("error parsing hex string `%s'\n", string);
       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     }
   *r_length = length;
   return buffer;
 }
 
 
 static void
 extract_cmp_data (gcry_sexp_t sexp, const char *name, const char *expected)
 {
   gcry_sexp_t l1;
   const void *a;
   size_t alen;
   void *b;
   size_t blen;
 
   l1 = gcry_sexp_find_token (sexp, name, 0);
   a = gcry_sexp_nth_data (l1, 1, &alen);
   b = data_from_hex (expected, &blen);
   if (!a)
     fail ("parameter \"%s\" missing in key\n", name);
   else if ( alen != blen || memcmp (a, b, alen) )
     {
       fail ("parameter \"%s\" does not match expected value\n", name);
       if (verbose)
         {
           info ("expected: %s\n", expected);
           show_sexp ("sexp: ", sexp);
         }
     }
   gcry_free (b);
   gcry_sexp_release (l1);
 }
 
 
 /* These test vectors are from RFC 6979.  */
 static void
 check_dsa_rfc6979 (void)
 {
   static struct {
     const char *name;
     const char *key;
   } keys[] = {
     {
       "DSA, 1024 bits",
       "(private-key"
       " (DSA"
       " (p #86F5CA03DCFEB225063FF830A0C769B9DD9D6153AD91D7CE27F787C43278B447"
       "     E6533B86B18BED6E8A48B784A14C252C5BE0DBF60B86D6385BD2F12FB763ED88"
       "     73ABFD3F5BA2E0A8C0A59082EAC056935E529DAF7C610467899C77ADEDFC846C"
       "     881870B7B19B2B58F9BE0521A17002E3BDD6B86685EE90B3D9A1B02B782B1779#)"
       " (q #996F967F6C8E388D9E28D01E205FBA957A5698B1#)"
       " (g #07B0F92546150B62514BB771E2A0C0CE387F03BDA6C56B505209FF25FD3C133D"
       "     89BBCD97E904E09114D9A7DEFDEADFC9078EA544D2E401AEECC40BB9FBBF78FD"
       "     87995A10A1C27CB7789B594BA7EFB5C4326A9FE59A070E136DB77175464ADCA4"
       "     17BE5DCE2F40D10A46A3A3943F26AB7FD9C0398FF8C76EE0A56826A8A88F1DBD#)"
       " (x #411602CB19A6CCC34494D79D98EF1E7ED5AF25F7#)"
       " (y #5DF5E01DED31D0297E274E1691C192FE5868FEF9E19A84776454B100CF16F653"
       "     92195A38B90523E2542EE61871C0440CB87C322FC4B4D2EC5E1E7EC766E1BE8D"
       "     4CE935437DC11C3C8FD426338933EBFE739CB3465F4D3668C5E473508253B1E6"
       "     82F65CBDC4FAE93C2EA212390E54905A86E2223170B44EAA7DA5DD9FFCFB7F3B#)"
       " ))"
     },
     {
       "DSA, 2048 bits",
       "(private-key"
       " (DSA"
       " (p #9DB6FB5951B66BB6FE1E140F1D2CE5502374161FD6538DF1648218642F0B5C48"
       "     C8F7A41AADFA187324B87674FA1822B00F1ECF8136943D7C55757264E5A1A44F"
       "     FE012E9936E00C1D3E9310B01C7D179805D3058B2A9F4BB6F9716BFE6117C6B5"
       "     B3CC4D9BE341104AD4A80AD6C94E005F4B993E14F091EB51743BF33050C38DE2"
       "     35567E1B34C3D6A5C0CEAA1A0F368213C3D19843D0B4B09DCB9FC72D39C8DE41"
       "     F1BF14D4BB4563CA28371621CAD3324B6A2D392145BEBFAC748805236F5CA2FE"
       "     92B871CD8F9C36D3292B5509CA8CAA77A2ADFC7BFD77DDA6F71125A7456FEA15"
       "     3E433256A2261C6A06ED3693797E7995FAD5AABBCFBE3EDA2741E375404AE25B#)"
       " (q #F2C3119374CE76C9356990B465374A17F23F9ED35089BD969F61C6DDE9998C1F#)"
       " (g #5C7FF6B06F8F143FE8288433493E4769C4D988ACE5BE25A0E24809670716C613"
       "     D7B0CEE6932F8FAA7C44D2CB24523DA53FBE4F6EC3595892D1AA58C4328A06C4"
       "     6A15662E7EAA703A1DECF8BBB2D05DBE2EB956C142A338661D10461C0D135472"
       "     085057F3494309FFA73C611F78B32ADBB5740C361C9F35BE90997DB2014E2EF5"
       "     AA61782F52ABEB8BD6432C4DD097BC5423B285DAFB60DC364E8161F4A2A35ACA"
       "     3A10B1C4D203CC76A470A33AFDCBDD92959859ABD8B56E1725252D78EAC66E71"
       "     BA9AE3F1DD2487199874393CD4D832186800654760E1E34C09E4D155179F9EC0"
       "     DC4473F996BDCE6EED1CABED8B6F116F7AD9CF505DF0F998E34AB27514B0FFE7#)"
       " (x #69C7548C21D0DFEA6B9A51C9EAD4E27C33D3B3F180316E5BCAB92C933F0E4DBC#)"
       " (y #667098C654426C78D7F8201EAC6C203EF030D43605032C2F1FA937E5237DBD94"
       "     9F34A0A2564FE126DC8B715C5141802CE0979C8246463C40E6B6BDAA2513FA61"
       "     1728716C2E4FD53BC95B89E69949D96512E873B9C8F8DFD499CC312882561ADE"
       "     CB31F658E934C0C197F2C4D96B05CBAD67381E7B768891E4DA3843D24D94CDFB"
       "     5126E9B8BF21E8358EE0E0A30EF13FD6A664C0DCE3731F7FB49A4845A4FD8254"
       "     687972A2D382599C9BAC4E0ED7998193078913032558134976410B89D2C171D1"
       "     23AC35FD977219597AA7D15C1A9A428E59194F75C721EBCBCFAE44696A499AFA"
       "     74E04299F132026601638CB87AB79190D4A0986315DA8EEC6561C938996BEADF#)"
       " ))"
     },
     {
       "ECDSA, 192 bits (prime field)",
       "(private-key"
       " (ecdsa"
       " (curve \"NIST P-192\")"
       " (q #04AC2C77F529F91689FEA0EA5EFEC7F210D8EEA0B9E047ED56"
       "       3BC723E57670BD4887EBC732C523063D0A7C957BC97C1C43#)"
       " (d #6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4#)"
       " ))"
     },
     {
       "ECDSA, 224 bits (prime field)",
       "(private-key"
       " (ecdsa"
       " (curve \"NIST P-224\")"
       " (q #04"
       "     00CF08DA5AD719E42707FA431292DEA11244D64FC51610D94B130D6C"
       "     EEAB6F3DEBE455E3DBF85416F7030CBD94F34F2D6F232C69F3C1385A#)"
       " (d #F220266E1105BFE3083E03EC7A3A654651F45E37167E88600BF257C1#)"
       " ))"
     },
     {
       "ECDSA, 256 bits (prime field)",
       "(private-key"
       " (ecdsa"
       " (curve \"NIST P-256\")"
       " (q #04"
       "     60FED4BA255A9D31C961EB74C6356D68C049B8923B61FA6CE669622E60F29FB6"
       "     7903FE1008B8BC99A41AE9E95628BC64F2F1B20C2D7E9F5177A3C294D4462299#)"
       " (d #C9AFA9D845BA75166B5C215767B1D6934E50C3DB36E89B127B8A622B120F6721#)"
       " ))"
     },
     {
       "ECDSA, 384 bits (prime field)",
       "(private-key"
       " (ecdsa"
       " (curve \"NIST P-384\")"
       " (q #04"
       "     EC3A4E415B4E19A4568618029F427FA5DA9A8BC4AE92E02E06AAE5286B300C64"
       "     DEF8F0EA9055866064A254515480BC13"
       "     8015D9B72D7D57244EA8EF9AC0C621896708A59367F9DFB9F54CA84B3F1C9DB1"
       "     288B231C3AE0D4FE7344FD2533264720#)"
       " (d #6B9D3DAD2E1B8C1C05B19875B6659F4DE23C3B667BF297BA9AA47740787137D8"
       "     96D5724E4C70A825F872C9EA60D2EDF5#)"
       " ))"
     },
     {
       "ECDSA, 521 bits (prime field)",
       "(private-key"
       " (ecdsa"
       " (curve \"NIST P-521\")"
       " (q #04"
       "     01894550D0785932E00EAA23B694F213F8C3121F86DC97A04E5A7167DB4E5BCD"
       "     371123D46E45DB6B5D5370A7F20FB633155D38FFA16D2BD761DCAC474B9A2F50"
       "     23A4"
       "     00493101C962CD4D2FDDF782285E64584139C2F91B47F87FF82354D6630F746A"
       "     28A0DB25741B5B34A828008B22ACC23F924FAAFBD4D33F81EA66956DFEAA2BFD"
       "     FCF5#)"
       " (d #FAD06DAA62BA3B25D2FB40133DA757205DE67F5BB0018FEE8C86E1B68C7E75"
       "     CAA896EB32F1F47C70855836A6D16FCC1466F6D8FBEC67DB89EC0C08B0E996B8"
       "     3538#)"
       " ))"
     },
     { NULL }
   };
 
   static struct {
     const char *keyname;
     const char *name;
     const char *hashname;
     const char *message;
     const char *k, *r, *s;
   } tests[] = {
     {
       "DSA, 1024 bits",
       "With SHA-1, message = \"sample\"",
       "sha1", "sample",
       "7BDB6B0FF756E1BB5D53583EF979082F9AD5BD5B",
       "2E1A0C2562B2912CAAF89186FB0F42001585DA55",
       "29EFB6B0AFF2D7A68EB70CA313022253B9A88DF5"
     },
     {
       "DSA, 1024 bits",
       "With SHA-224, message = \"sample\"",
       "sha224", "sample",
       "562097C06782D60C3037BA7BE104774344687649",
       "4BC3B686AEA70145856814A6F1BB53346F02101E",
       "410697B92295D994D21EDD2F4ADA85566F6F94C1"
     },
     {
       "DSA, 1024 bits",
       "With SHA-256, message = \"sample\"",
       "sha256", "sample",
       "519BA0546D0C39202A7D34D7DFA5E760B318BCFB",
       "81F2F5850BE5BC123C43F71A3033E9384611C545",
       "4CDD914B65EB6C66A8AAAD27299BEE6B035F5E89"
     },
     {
       "DSA, 1024 bits",
       "With SHA-384, message = \"sample\"",
       "sha384", "sample",
       "95897CD7BBB944AA932DBC579C1C09EB6FCFC595",
       "07F2108557EE0E3921BC1774F1CA9B410B4CE65A",
       "54DF70456C86FAC10FAB47C1949AB83F2C6F7595"
     },
     {
       "DSA, 1024 bits",
       "With SHA-512, message = \"sample\"",
       "sha512", "sample",
       "09ECE7CA27D0F5A4DD4E556C9DF1D21D28104F8B",
       "16C3491F9B8C3FBBDD5E7A7B667057F0D8EE8E1B",
       "02C36A127A7B89EDBB72E4FFBC71DABC7D4FC69C"
     },
     {
       "DSA, 1024 bits",
       "With SHA-1, message = \"test\"",
       "sha1", "test",
       "5C842DF4F9E344EE09F056838B42C7A17F4A6433",
       "42AB2052FD43E123F0607F115052A67DCD9C5C77",
       "183916B0230D45B9931491D4C6B0BD2FB4AAF088"
     },
     {
       "DSA, 1024 bits",
       "With SHA-224, message = \"test\"",
       "sha224", "test",
       "4598B8EFC1A53BC8AECD58D1ABBB0C0C71E67297",
       "6868E9964E36C1689F6037F91F28D5F2C30610F2",
       "49CEC3ACDC83018C5BD2674ECAAD35B8CD22940F"
     },
     {
       "DSA, 1024 bits",
       "With SHA-256, message = \"test\"",
       "sha256", "test",
       "5A67592E8128E03A417B0484410FB72C0B630E1A",
       "22518C127299B0F6FDC9872B282B9E70D0790812",
       "6837EC18F150D55DE95B5E29BE7AF5D01E4FE160"
     },
     {
       "DSA, 1024 bits",
       "With SHA-384, message = \"test\"",
       "sha384", "test",
       "220156B761F6CA5E6C9F1B9CF9C24BE25F98CD89",
       "854CF929B58D73C3CBFDC421E8D5430CD6DB5E66",
       "91D0E0F53E22F898D158380676A871A157CDA622"
     },
     {
       "DSA, 1024 bits",
       "With SHA-512, message = \"test\"",
       "sha512", "test",
       "65D2C2EEB175E370F28C75BFCDC028D22C7DBE9C",
       "8EA47E475BA8AC6F2D821DA3BD212D11A3DEB9A0",
       "7C670C7AD72B6C050C109E1790008097125433E8"
     },
     {
       "DSA, 2048 bits",
       "With SHA-1, message = \"sample\"",
       "sha1", "sample",
       "888FA6F7738A41BDC9846466ABDB8174C0338250AE50CE955CA16230F9CBD53E",
       "3A1B2DBD7489D6ED7E608FD036C83AF396E290DBD602408E8677DAABD6E7445A",
       "D26FCBA19FA3E3058FFC02CA1596CDBB6E0D20CB37B06054F7E36DED0CDBBCCF"
     },
     {
       "DSA, 2048 bits",
       "With SHA-224, message = \"sample\"",
       "sha224", "sample",
       "BC372967702082E1AA4FCE892209F71AE4AD25A6DFD869334E6F153BD0C4D806",
       "DC9F4DEADA8D8FF588E98FED0AB690FFCE858DC8C79376450EB6B76C24537E2C",
       "A65A9C3BC7BABE286B195D5DA68616DA8D47FA0097F36DD19F517327DC848CEC"
     },
     {
       "DSA, 2048 bits",
       "With SHA-256, message = \"sample\"",
       "sha256", "sample",
       "8926A27C40484216F052F4427CFD5647338B7B3939BC6573AF4333569D597C52",
       "EACE8BDBBE353C432A795D9EC556C6D021F7A03F42C36E9BC87E4AC7932CC809",
       "7081E175455F9247B812B74583E9E94F9EA79BD640DC962533B0680793A38D53"
     },
     {
       "DSA, 2048 bits",
       "With SHA-384, message = \"sample\"",
       "sha384", "sample",
       "C345D5AB3DA0A5BCB7EC8F8FB7A7E96069E03B206371EF7D83E39068EC564920",
       "B2DA945E91858834FD9BF616EBAC151EDBC4B45D27D0DD4A7F6A22739F45C00B",
       "19048B63D9FD6BCA1D9BAE3664E1BCB97F7276C306130969F63F38FA8319021B"
     },
     {
       "DSA, 2048 bits",
       "With SHA-512, message = \"sample\"",
       "sha512", "sample",
       "5A12994431785485B3F5F067221517791B85A597B7A9436995C89ED0374668FC",
       "2016ED092DC5FB669B8EFB3D1F31A91EECB199879BE0CF78F02BA062CB4C942E",
       "D0C76F84B5F091E141572A639A4FB8C230807EEA7D55C8A154A224400AFF2351"
     },
     {
       "DSA, 2048 bits",
       "With SHA-1, message = \"test\"",
       "sha1", "test",
       "6EEA486F9D41A037B2C640BC5645694FF8FF4B98D066A25F76BE641CCB24BA4F",
       "C18270A93CFC6063F57A4DFA86024F700D980E4CF4E2CB65A504397273D98EA0",
       "414F22E5F31A8B6D33295C7539C1C1BA3A6160D7D68D50AC0D3A5BEAC2884FAA"
     },
     {
       "DSA, 2048 bits",
       "With SHA-224, message = \"test\"",
       "sha224", "test",
       "06BD4C05ED74719106223BE33F2D95DA6B3B541DAD7BFBD7AC508213B6DA6670",
       "272ABA31572F6CC55E30BF616B7A265312018DD325BE031BE0CC82AA17870EA3",
       "E9CC286A52CCE201586722D36D1E917EB96A4EBDB47932F9576AC645B3A60806"
     },
     {
       "DSA, 2048 bits",
       "With SHA-256, message = \"test\"",
       "sha256", "test",
       "1D6CE6DDA1C5D37307839CD03AB0A5CBB18E60D800937D67DFB4479AAC8DEAD7",
       "8190012A1969F9957D56FCCAAD223186F423398D58EF5B3CEFD5A4146A4476F0",
       "7452A53F7075D417B4B013B278D1BB8BBD21863F5E7B1CEE679CF2188E1AB19E"
     },
     {
       "DSA, 2048 bits",
       "With SHA-384, message = \"test\"",
       "sha384", "test",
       "206E61F73DBE1B2DC8BE736B22B079E9DACD974DB00EEBBC5B64CAD39CF9F91C",
       "239E66DDBE8F8C230A3D071D601B6FFBDFB5901F94D444C6AF56F732BEB954BE",
       "6BD737513D5E72FE85D1C750E0F73921FE299B945AAD1C802F15C26A43D34961"
     },
     {
       "DSA, 2048 bits",
       "With SHA-512, message = \"test\"",
       "sha512", "test",
       "AFF1651E4CD6036D57AA8B2A05CCF1A9D5A40166340ECBBDC55BE10B568AA0AA",
       "89EC4BB1400ECCFF8E7D9AA515CD1DE7803F2DAFF09693EE7FD1353E90A68307",
       "C9F0BDABCC0D880BB137A994CC7F3980CE91CC10FAF529FC46565B15CEA854E1"
     },
     {
       "ECDSA, 192 bits (prime field)",
       "With SHA-1, message = \"sample\"",
       "sha1", "sample",
       "37D7CA00D2C7B0E5E412AC03BD44BA837FDD5B28CD3B0021",
       "98C6BD12B23EAF5E2A2045132086BE3EB8EBD62ABF6698FF",
       "57A22B07DEA9530F8DE9471B1DC6624472E8E2844BC25B64"
     },
     {
       "ECDSA, 192 bits (prime field)",
       "With SHA-224, message = \"sample\"",
       "sha224", "sample",
       "4381526B3FC1E7128F202E194505592F01D5FF4C5AF015D8",
       "A1F00DAD97AEEC91C95585F36200C65F3C01812AA60378F5",
       "E07EC1304C7C6C9DEBBE980B9692668F81D4DE7922A0F97A"
     },
     {
       "ECDSA, 192 bits (prime field)",
       "With SHA-256, message = \"sample\"",
       "sha256", "sample",
       "32B1B6D7D42A05CB449065727A84804FB1A3E34D8F261496",
       "4B0B8CE98A92866A2820E20AA6B75B56382E0F9BFD5ECB55",
       "CCDB006926EA9565CBADC840829D8C384E06DE1F1E381B85"
     },
     {
       "ECDSA, 192 bits (prime field)",
       "With SHA-384, message = \"sample\"",
       "sha384", "sample",
       "4730005C4FCB01834C063A7B6760096DBE284B8252EF4311",
       "DA63BF0B9ABCF948FBB1E9167F136145F7A20426DCC287D5",
       "C3AA2C960972BD7A2003A57E1C4C77F0578F8AE95E31EC5E"
     },
     {
       "ECDSA, 192 bits (prime field)",
       "With SHA-512, message = \"sample\"",
       "sha512", "sample",
       "A2AC7AB055E4F20692D49209544C203A7D1F2C0BFBC75DB1",
       "4D60C5AB1996BD848343B31C00850205E2EA6922DAC2E4B8",
       "3F6E837448F027A1BF4B34E796E32A811CBB4050908D8F67"
     },
     {
       "ECDSA, 192 bits (prime field)",
       "With SHA-1, message = \"test\"",
       "sha1", "test",
       "D9CF9C3D3297D3260773A1DA7418DB5537AB8DD93DE7FA25",
       "0F2141A0EBBC44D2E1AF90A50EBCFCE5E197B3B7D4DE036D",
       "EB18BC9E1F3D7387500CB99CF5F7C157070A8961E38700B7"
     },
     {
       "ECDSA, 192 bits (prime field)",
       "With SHA-224, message = \"test\"",
       "sha224", "test",
       "F5DC805F76EF851800700CCE82E7B98D8911B7D510059FBE",
       "6945A1C1D1B2206B8145548F633BB61CEF04891BAF26ED34",
       "B7FB7FDFC339C0B9BD61A9F5A8EAF9BE58FC5CBA2CB15293"
     },
     {
       "ECDSA, 192 bits (prime field)",
       "With SHA-256, message = \"test\"",
       "sha256", "test",
       "5C4CE89CF56D9E7C77C8585339B006B97B5F0680B4306C6C",
       "3A718BD8B4926C3B52EE6BBE67EF79B18CB6EB62B1AD97AE",
       "5662E6848A4A19B1F1AE2F72ACD4B8BBE50F1EAC65D9124F"
     },
     {
       "ECDSA, 192 bits (prime field)",
       "With SHA-384, message = \"test\"",
       "sha384", "test",
       "5AFEFB5D3393261B828DB6C91FBC68C230727B030C975693",
       "B234B60B4DB75A733E19280A7A6034BD6B1EE88AF5332367",
       "7994090B2D59BB782BE57E74A44C9A1C700413F8ABEFE77A"
     },
     {
       "ECDSA, 192 bits (prime field)",
       "With SHA-512, message = \"test\"",
       "sha512", "test",
       "0758753A5254759C7CFBAD2E2D9B0792EEE44136C9480527",
       "FE4F4AE86A58B6507946715934FE2D8FF9D95B6B098FE739",
       "74CF5605C98FBA0E1EF34D4B5A1577A7DCF59457CAE52290"
     },
 
 
 
     {
       "ECDSA, 224 bits (prime field)",
       "With SHA-1, message = \"sample\"",
       "sha1", "sample",
       "7EEFADD91110D8DE6C2C470831387C50D3357F7F4D477054B8B426BC",
       "22226F9D40A96E19C4A301CE5B74B115303C0F3A4FD30FC257FB57AC",
       "66D1CDD83E3AF75605DD6E2FEFF196D30AA7ED7A2EDF7AF475403D69"
     },
     {
       "ECDSA, 224 bits (prime field)",
       "With SHA-224, message = \"sample\"",
       "sha224", "sample",
       "C1D1F2F10881088301880506805FEB4825FE09ACB6816C36991AA06D",
       "1CDFE6662DDE1E4A1EC4CDEDF6A1F5A2FB7FBD9145C12113E6ABFD3E",
       "A6694FD7718A21053F225D3F46197CA699D45006C06F871808F43EBC"
     },
     {
       "ECDSA, 224 bits (prime field)",
       "With SHA-256, message = \"sample\"",
       "sha256", "sample",
       "AD3029E0278F80643DE33917CE6908C70A8FF50A411F06E41DEDFCDC",
       "61AA3DA010E8E8406C656BC477A7A7189895E7E840CDFE8FF42307BA",
       "BC814050DAB5D23770879494F9E0A680DC1AF7161991BDE692B10101"
     },
     {
       "ECDSA, 224 bits (prime field)",
       "With SHA-384, message = \"sample\"",
       "sha384", "sample",
       "52B40F5A9D3D13040F494E83D3906C6079F29981035C7BD51E5CAC40",
       "0B115E5E36F0F9EC81F1325A5952878D745E19D7BB3EABFABA77E953",
       "830F34CCDFE826CCFDC81EB4129772E20E122348A2BBD889A1B1AF1D"
     },
     {
       "ECDSA, 224 bits (prime field)",
       "With SHA-512, message = \"sample\"",
       "sha512", "sample",
       "9DB103FFEDEDF9CFDBA05184F925400C1653B8501BAB89CEA0FBEC14",
       "074BD1D979D5F32BF958DDC61E4FB4872ADCAFEB2256497CDAC30397",
       "A4CECA196C3D5A1FF31027B33185DC8EE43F288B21AB342E5D8EB084"
     },
     {
       "ECDSA, 224 bits (prime field)",
       "With SHA-1, message = \"test\"",
       "sha1", "test",
       "2519178F82C3F0E4F87ED5883A4E114E5B7A6E374043D8EFD329C253",
       "DEAA646EC2AF2EA8AD53ED66B2E2DDAA49A12EFD8356561451F3E21C",
       "95987796F6CF2062AB8135271DE56AE55366C045F6D9593F53787BD2"
     },
     {
       "ECDSA, 224 bits (prime field)",
       "With SHA-224, message = \"test\"",
       "sha224", "test",
       "DF8B38D40DCA3E077D0AC520BF56B6D565134D9B5F2EAE0D34900524",
       "C441CE8E261DED634E4CF84910E4C5D1D22C5CF3B732BB204DBEF019",
       "902F42847A63BDC5F6046ADA114953120F99442D76510150F372A3F4"
     },
     {
       "ECDSA, 224 bits (prime field)",
       "With SHA-256, message = \"test\"",
       "sha256", "test",
       "FF86F57924DA248D6E44E8154EB69F0AE2AEBAEE9931D0B5A969F904",
       "AD04DDE87B84747A243A631EA47A1BA6D1FAA059149AD2440DE6FBA6",
       "178D49B1AE90E3D8B629BE3DB5683915F4E8C99FDF6E666CF37ADCFD"
     },
     {
       "ECDSA, 224 bits (prime field)",
       "With SHA-384, message = \"test\"",
       "sha384", "test",
       "7046742B839478C1B5BD31DB2E862AD868E1A45C863585B5F22BDC2D",
       "389B92682E399B26518A95506B52C03BC9379A9DADF3391A21FB0EA4",
       "414A718ED3249FF6DBC5B50C27F71F01F070944DA22AB1F78F559AAB"
     },
     {
       "ECDSA, 224 bits (prime field)",
       "With SHA-512, message = \"test\"",
       "sha512", "test",
       "E39C2AA4EA6BE2306C72126D40ED77BF9739BB4D6EF2BBB1DCB6169D",
       "049F050477C5ADD858CAC56208394B5A55BAEBBE887FDF765047C17C",
       "077EB13E7005929CEFA3CD0403C7CDCC077ADF4E44F3C41B2F60ECFF"
     },
     {
       "ECDSA, 256 bits (prime field)",
       "With SHA-1, message = \"sample\"",
       "sha1", "sample",
       "882905F1227FD620FBF2ABF21244F0BA83D0DC3A9103DBBEE43A1FB858109DB4",
       "61340C88C3AAEBEB4F6D667F672CA9759A6CCAA9FA8811313039EE4A35471D32",
       "6D7F147DAC089441BB2E2FE8F7A3FA264B9C475098FDCF6E00D7C996E1B8B7EB"
     },
     {
       "ECDSA, 256 bits (prime field)",
       "With SHA-224, message = \"sample\"",
       "sha224", "sample",
       "103F90EE9DC52E5E7FB5132B7033C63066D194321491862059967C715985D473",
       "53B2FFF5D1752B2C689DF257C04C40A587FABABB3F6FC2702F1343AF7CA9AA3F",
       "B9AFB64FDC03DC1A131C7D2386D11E349F070AA432A4ACC918BEA988BF75C74C"
     },
     {
       "ECDSA, 256 bits (prime field)",
       "With SHA-256, message = \"sample\"",
       "sha256", "sample",
       "A6E3C57DD01ABE90086538398355DD4C3B17AA873382B0F24D6129493D8AAD60",
       "EFD48B2AACB6A8FD1140DD9CD45E81D69D2C877B56AAF991C34D0EA84EAF3716",
       "F7CB1C942D657C41D436C7A1B6E29F65F3E900DBB9AFF4064DC4AB2F843ACDA8"
     },
     {
       "ECDSA, 256 bits (prime field)",
       "With SHA-384, message = \"sample\"",
       "sha384", "sample",
       "09F634B188CEFD98E7EC88B1AA9852D734D0BC272F7D2A47DECC6EBEB375AAD4",
       "0EAFEA039B20E9B42309FB1D89E213057CBF973DC0CFC8F129EDDDC800EF7719",
       "4861F0491E6998B9455193E34E7B0D284DDD7149A74B95B9261F13ABDE940954"
     },
     {
       "ECDSA, 256 bits (prime field)",
       "With SHA-512, message = \"sample\"",
       "sha512", "sample",
       "5FA81C63109BADB88C1F367B47DA606DA28CAD69AA22C4FE6AD7DF73A7173AA5",
       "8496A60B5E9B47C825488827E0495B0E3FA109EC4568FD3F8D1097678EB97F00",
       "2362AB1ADBE2B8ADF9CB9EDAB740EA6049C028114F2460F96554F61FAE3302FE"
     },
     {
       "ECDSA, 256 bits (prime field)",
       "With SHA-1, message = \"test\"",
       "sha1", "test",
       "8C9520267C55D6B980DF741E56B4ADEE114D84FBFA2E62137954164028632A2E",
       "0CBCC86FD6ABD1D99E703E1EC50069EE5C0B4BA4B9AC60E409E8EC5910D81A89",
       "01B9D7B73DFAA60D5651EC4591A0136F87653E0FD780C3B1BC872FFDEAE479B1"
     },
     {
       "ECDSA, 256 bits (prime field)",
       "With SHA-224, message = \"test\"",
       "sha224", "test",
       "669F4426F2688B8BE0DB3A6BD1989BDAEFFF84B649EEB84F3DD26080F667FAA7",
       "C37EDB6F0AE79D47C3C27E962FA269BB4F441770357E114EE511F662EC34A692",
       "C820053A05791E521FCAAD6042D40AEA1D6B1A540138558F47D0719800E18F2D"
     },
     {
       "ECDSA, 256 bits (prime field)",
       "With SHA-256, message = \"test\"",
       "sha256", "test",
       "D16B6AE827F17175E040871A1C7EC3500192C4C92677336EC2537ACAEE0008E0",
       "F1ABB023518351CD71D881567B1EA663ED3EFCF6C5132B354F28D3B0B7D38367",
       "019F4113742A2B14BD25926B49C649155F267E60D3814B4C0CC84250E46F0083"
     },
     {
       "ECDSA, 256 bits (prime field)",
       "With SHA-384, message = \"test\"",
       "sha384", "test",
       "16AEFFA357260B04B1DD199693960740066C1A8F3E8EDD79070AA914D361B3B8",
       "83910E8B48BB0C74244EBDF7F07A1C5413D61472BD941EF3920E623FBCCEBEB6",
       "8DDBEC54CF8CD5874883841D712142A56A8D0F218F5003CB0296B6B509619F2C"
     },
     {
       "ECDSA, 256 bits (prime field)",
       "With SHA-512, message = \"test\"",
       "sha512", "test",
       "6915D11632ACA3C40D5D51C08DAF9C555933819548784480E93499000D9F0B7F",
       "461D93F31B6540894788FD206C07CFA0CC35F46FA3C91816FFF1040AD1581A04",
       "39AF9F15DE0DB8D97E72719C74820D304CE5226E32DEDAE67519E840D1194E55"
     },
     {
       "ECDSA, 384 bits (prime field)",
       "With SHA-1, message = \"sample\"",
       "sha1", "sample",
       "4471EF7518BB2C7C20F62EAE1C387AD0C5E8E470995DB4ACF694466E6AB09663"
       "0F29E5938D25106C3C340045A2DB01A7",
       "EC748D839243D6FBEF4FC5C4859A7DFFD7F3ABDDF72014540C16D73309834FA3"
       "7B9BA002899F6FDA3A4A9386790D4EB2",
       "A3BCFA947BEEF4732BF247AC17F71676CB31A847B9FF0CBC9C9ED4C1A5B3FACF"
       "26F49CA031D4857570CCB5CA4424A443"
     },
     {
       "ECDSA, 384 bits (prime field)",
       "With SHA-224, message = \"sample\"",
       "sha224", "sample",
       "A4E4D2F0E729EB786B31FC20AD5D849E304450E0AE8E3E341134A5C1AFA03CAB"
       "8083EE4E3C45B06A5899EA56C51B5879",
       "42356E76B55A6D9B4631C865445DBE54E056D3B3431766D0509244793C3F9366"
       "450F76EE3DE43F5A125333A6BE060122",
       "9DA0C81787064021E78DF658F2FBB0B042BF304665DB721F077A4298B095E483"
       "4C082C03D83028EFBF93A3C23940CA8D"
     },
     {
       "ECDSA, 384 bits (prime field)",
       "With SHA-256, message = \"sample\"",
       "sha256", "sample",
       "180AE9F9AEC5438A44BC159A1FCB277C7BE54FA20E7CF404B490650A8ACC414E"
       "375572342863C899F9F2EDF9747A9B60",
       "21B13D1E013C7FA1392D03C5F99AF8B30C570C6F98D4EA8E354B63A21D3DAA33"
       "BDE1E888E63355D92FA2B3C36D8FB2CD",
       "F3AA443FB107745BF4BD77CB3891674632068A10CA67E3D45DB2266FA7D1FEEB"
       "EFDC63ECCD1AC42EC0CB8668A4FA0AB0"
     },
     {
       "ECDSA, 384 bits (prime field)",
       "With SHA-384, message = \"sample\"",
       "sha384", "sample",
       "94ED910D1A099DAD3254E9242AE85ABDE4BA15168EAF0CA87A555FD56D10FBCA"
       "2907E3E83BA95368623B8C4686915CF9",
       "94EDBB92A5ECB8AAD4736E56C691916B3F88140666CE9FA73D64C4EA95AD133C"
       "81A648152E44ACF96E36DD1E80FABE46",
       "99EF4AEB15F178CEA1FE40DB2603138F130E740A19624526203B6351D0A3A94F"
       "A329C145786E679E7B82C71A38628AC8"
     },
     {
       "ECDSA, 384 bits (prime field)",
       "With SHA-512, message = \"sample\"",
       "sha512", "sample",
       "92FC3C7183A883E24216D1141F1A8976C5B0DD797DFA597E3D7B32198BD35331"
       "A4E966532593A52980D0E3AAA5E10EC3",
       "ED0959D5880AB2D869AE7F6C2915C6D60F96507F9CB3E047C0046861DA4A799C"
       "FE30F35CC900056D7C99CD7882433709",
       "512C8CCEEE3890A84058CE1E22DBC2198F42323CE8ACA9135329F03C068E5112"
       "DC7CC3EF3446DEFCEB01A45C2667FDD5"
     },
     {
       "ECDSA, 384 bits (prime field)",
       "With SHA-1, message = \"test\"",
       "sha1", "test",
       "66CC2C8F4D303FC962E5FF6A27BD79F84EC812DDAE58CF5243B64A4AD8094D47"
       "EC3727F3A3C186C15054492E30698497",
       "4BC35D3A50EF4E30576F58CD96CE6BF638025EE624004A1F7789A8B8E43D0678"
       "ACD9D29876DAF46638645F7F404B11C7",
       "D5A6326C494ED3FF614703878961C0FDE7B2C278F9A65FD8C4B7186201A29916"
       "95BA1C84541327E966FA7B50F7382282"
     },
     {
       "ECDSA, 384 bits (prime field)",
       "With SHA-224, message = \"test\"",
       "sha224", "test",
       "18FA39DB95AA5F561F30FA3591DC59C0FA3653A80DAFFA0B48D1A4C6DFCBFF6E"
       "3D33BE4DC5EB8886A8ECD093F2935726",
       "E8C9D0B6EA72A0E7837FEA1D14A1A9557F29FAA45D3E7EE888FC5BF954B5E624"
       "64A9A817C47FF78B8C11066B24080E72",
       "07041D4A7A0379AC7232FF72E6F77B6DDB8F09B16CCE0EC3286B2BD43FA8C614"
       "1C53EA5ABEF0D8231077A04540A96B66"
     },
     {
       "ECDSA, 384 bits (prime field)",
       "With SHA-256, message = \"test\"",
       "sha256", "test",
       "0CFAC37587532347DC3389FDC98286BBA8C73807285B184C83E62E26C401C0FA"
       "A48DD070BA79921A3457ABFF2D630AD7",
       "6D6DEFAC9AB64DABAFE36C6BF510352A4CC27001263638E5B16D9BB51D451559"
       "F918EEDAF2293BE5B475CC8F0188636B",
       "2D46F3BECBCC523D5F1A1256BF0C9B024D879BA9E838144C8BA6BAEB4B53B47D"
       "51AB373F9845C0514EEFB14024787265"
     },
     {
       "ECDSA, 384 bits (prime field)",
       "With SHA-384, message = \"test\"",
       "sha384", "test",
       "015EE46A5BF88773ED9123A5AB0807962D193719503C527B031B4C2D225092AD"
       "A71F4A459BC0DA98ADB95837DB8312EA",
       "8203B63D3C853E8D77227FB377BCF7B7B772E97892A80F36AB775D509D7A5FEB"
       "0542A7F0812998DA8F1DD3CA3CF023DB",
       "DDD0760448D42D8A43AF45AF836FCE4DE8BE06B485E9B61B827C2F13173923E0"
       "6A739F040649A667BF3B828246BAA5A5"
     },
     {
       "ECDSA, 384 bits (prime field)",
       "With SHA-512, message = \"test\"",
       "sha512", "test",
       "3780C4F67CB15518B6ACAE34C9F83568D2E12E47DEAB6C50A4E4EE5319D1E8CE"
       "0E2CC8A136036DC4B9C00E6888F66B6C",
       "A0D5D090C9980FAF3C2CE57B7AE951D31977DD11C775D314AF55F76C676447D0"
       "6FB6495CD21B4B6E340FC236584FB277",
       "976984E59B4C77B0E8E4460DCA3D9F20E07B9BB1F63BEEFAF576F6B2E8B22463"
       "4A2092CD3792E0159AD9CEE37659C736"
     },
     {
       "ECDSA, 521 bits (prime field)",
       "With SHA-1, message = \"sample\"",
       "sha1", "sample",
       "0089C071B419E1C2820962321787258469511958E80582E95D8378E0C2CCDB3CB"
       "42BEDE42F50E3FA3C71F5A76724281D31D9C89F0F91FC1BE4918DB1C03A5838D"
       "0F9",
       "343B6EC45728975EA5CBA6659BBB6062A5FF89EEA58BE3C80B619F322C87910"
       "FE092F7D45BB0F8EEE01ED3F20BABEC079D202AE677B243AB40B5431D497C55D"
       "75D",
       "E7B0E675A9B24413D448B8CC119D2BF7B2D2DF032741C096634D6D65D0DBE3D"
       "5694625FB9E8104D3B842C1B0E2D0B98BEA19341E8676AEF66AE4EBA3D5475D5"
       "D16"
     },
     {
       "ECDSA, 521 bits (prime field)",
       "With SHA-224, message = \"sample\"",
       "sha224", "sample",
       "121415EC2CD7726330A61F7F3FA5DE14BE9436019C4DB8CB4041F3B54CF31BE0"
       "493EE3F427FB906393D895A19C9523F3A1D54BB8702BD4AA9C99DAB2597B9211"
       "3F3",
       "01776331CFCDF927D666E032E00CF776187BC9FDD8E69D0DABB4109FFE1B5E2A3"
       "0715F4CC923A4A5E94D2503E9ACFED92857B7F31D7152E0F8C00C15FF3D87E2E"
       "D2E",
       "50CB5265417FE2320BBB5A122B8E1A32BD699089851128E360E620A30C7E17B"
       "A41A666AF126CE100E5799B153B60528D5300D08489CA9178FB610A2006C254B"
       "41F"
     },
     {
       "ECDSA, 521 bits (prime field)",
       "With SHA-256, message = \"sample\"",
       "sha256", "sample",
       "0EDF38AFCAAECAB4383358B34D67C9F2216C8382AAEA44A3DAD5FDC9C3257576"
       "1793FEF24EB0FC276DFC4F6E3EC476752F043CF01415387470BCBD8678ED2C7E"
       "1A0",
       "01511BB4D675114FE266FC4372B87682BAECC01D3CC62CF2303C92B3526012659"
       "D16876E25C7C1E57648F23B73564D67F61C6F14D527D54972810421E7D87589E"
       "1A7",
       "4A171143A83163D6DF460AAF61522695F207A58B95C0644D87E52AA1A347916"
       "E4F7A72930B1BC06DBE22CE3F58264AFD23704CBB63B29B931F7DE6C9D949A7E"
       "CFC"
     },
     {
       "ECDSA, 521 bits (prime field)",
       "With SHA-384, message = \"sample\"",
       "sha384", "sample",
       "1546A108BC23A15D6F21872F7DED661FA8431DDBD922D0DCDB77CC878C8553FF"
       "AD064C95A920A750AC9137E527390D2D92F153E66196966EA554D9ADFCB109C4"
       "211",
       "01EA842A0E17D2DE4F92C15315C63DDF72685C18195C2BB95E572B9C5136CA4B4"
       "B576AD712A52BE9730627D16054BA40CC0B8D3FF035B12AE75168397F5D50C67"
       "451",
       "01F21A3CEE066E1961025FB048BD5FE2B7924D0CD797BABE0A83B66F1E35EEAF5"
       "FDE143FA85DC394A7DEE766523393784484BDF3E00114A1C857CDE1AA203DB65"
       "D61"
     },
     {
       "ECDSA, 521 bits (prime field)",
       "With SHA-512, message = \"sample\"",
       "sha512", "sample",
       "1DAE2EA071F8110DC26882D4D5EAE0621A3256FC8847FB9022E2B7D28E6F1019"
       "8B1574FDD03A9053C08A1854A168AA5A57470EC97DD5CE090124EF52A2F7ECBF"
       "FD3",
       "C328FAFCBD79DD77850370C46325D987CB525569FB63C5D3BC53950E6D4C5F1"
       "74E25A1EE9017B5D450606ADD152B534931D7D4E8455CC91F9B15BF05EC36E37"
       "7FA",
       "617CCE7CF5064806C467F678D3B4080D6F1CC50AF26CA209417308281B68AF2"
       "82623EAA63E5B5C0723D8B8C37FF0777B1A20F8CCB1DCCC43997F1EE0E44DA4A"
       "67A"
     },
     {
       "ECDSA, 521 bits (prime field)",
       "With SHA-1, message = \"test\"",
       "sha1", "test",
       "0BB9F2BF4FE1038CCF4DABD7139A56F6FD8BB1386561BD3C6A4FC818B20DF5DD"
       "BA80795A947107A1AB9D12DAA615B1ADE4F7A9DC05E8E6311150F47F5C57CE8B"
       "222",
       "013BAD9F29ABE20DE37EBEB823C252CA0F63361284015A3BF430A46AAA80B87B0"
       "693F0694BD88AFE4E661FC33B094CD3B7963BED5A727ED8BD6A3A202ABE009D0"
       "367",
       "01E9BB81FF7944CA409AD138DBBEE228E1AFCC0C890FC78EC8604639CB0DBDC90"
       "F717A99EAD9D272855D00162EE9527567DD6A92CBD629805C0445282BBC91679"
       "7FF"
     },
     {
       "ECDSA, 521 bits (prime field)",
       "With SHA-224, message = \"test\"",
       "sha224", "test",
       "040D09FCF3C8A5F62CF4FB223CBBB2B9937F6B0577C27020A99602C25A011369"
       "87E452988781484EDBBCF1C47E554E7FC901BC3085E5206D9F619CFF07E73D6F"
       "706",
       "01C7ED902E123E6815546065A2C4AF977B22AA8EADDB68B2C1110E7EA44D42086"
       "BFE4A34B67DDC0E17E96536E358219B23A706C6A6E16BA77B65E1C595D43CAE1"
       "7FB",
       "0177336676304FCB343CE028B38E7B4FBA76C1C1B277DA18CAD2A8478B2A9A9F5"
       "BEC0F3BA04F35DB3E4263569EC6AADE8C92746E4C82F8299AE1B8F1739F8FD51"
       "9A4"
     },
     {
       "ECDSA, 521 bits (prime field)",
       "With SHA-256, message = \"test\"",
       "sha256", "test",
       "01DE74955EFAABC4C4F17F8E84D881D1310B5392D7700275F82F145C61E84384"
       "1AF09035BF7A6210F5A431A6A9E81C9323354A9E69135D44EBD2FCAA7731B909"
       "258",
       "0E871C4A14F993C6C7369501900C4BC1E9C7B0B4BA44E04868B30B41D807104"
       "2EB28C4C250411D0CE08CD197E4188EA4876F279F90B3D8D74A3C76E6F1E4656"
       "AA8",
       "CD52DBAA33B063C3A6CD8058A1FB0A46A4754B034FCC644766CA14DA8CA5CA9"
       "FDE00E88C1AD60CCBA759025299079D7A427EC3CC5B619BFBC828E7769BCD694"
       "E86"
     },
     {
       "ECDSA, 521 bits (prime field)",
       "With SHA-384, message = \"test\"",
       "sha384", "test",
       "1F1FC4A349A7DA9A9E116BFDD055DC08E78252FF8E23AC276AC88B1770AE0B5D"
       "CEB1ED14A4916B769A523CE1E90BA22846AF11DF8B300C38818F713DADD85DE0"
       "C88",
       "014BEE21A18B6D8B3C93FAB08D43E739707953244FDBE924FA926D76669E7AC8C"
       "89DF62ED8975C2D8397A65A49DCC09F6B0AC62272741924D479354D74FF60755"
       "78C",
       "0133330865C067A0EAF72362A65E2D7BC4E461E8C8995C3B6226A21BD1AA78F0E"
       "D94FE536A0DCA35534F0CD1510C41525D163FE9D74D134881E35141ED5E8E95B"
       "979"
     },
     {
       "ECDSA, 521 bits (prime field)",
       "With SHA-512, message = \"test\"",
       "sha512", "test",
       "16200813020EC986863BEDFC1B121F605C1215645018AEA1A7B215A564DE9EB1"
       "B38A67AA1128B80CE391C4FB71187654AAA3431027BFC7F395766CA988C964DC"
       "56D",
       "013E99020ABF5CEE7525D16B69B229652AB6BDF2AFFCAEF38773B4B7D08725F10"
       "CDB93482FDCC54EDCEE91ECA4166B2A7C6265EF0CE2BD7051B7CEF945BABD47E"
       "E6D",
       "01FBD0013C674AA79CB39849527916CE301C66EA7CE8B80682786AD60F98F7E78"
       "A19CA69EFF5C57400E3B3A0AD66CE0978214D13BAF4E9AC60752F7B155E2DE4D"
       "CE3"
     },
     { NULL }
   };
 
   gpg_error_t err;
   int tno, i, hashalgo;
   gcry_sexp_t seckey, data, sig;
   unsigned char digest[64];
   int digestlen;
 
   for (tno = 0; tests[tno].keyname; tno++)
     {
       if (verbose)
         info ("Test %d: %s. %s.\n", tno, tests[tno].keyname, tests[tno].name);
 
       {
         for (i=0; keys[i].name; i++)
           if (!strcmp (tests[tno].keyname, keys[i].name))
             break;
         if (!keys[i].name)
           die ("Key '%s' used by test '%s' not found\n",
                tests[tno].keyname, tests[tno].name);
 
         err = gcry_sexp_new (&seckey, keys[i].key, 0, 1);
         if (err)
           die ("reading key failed: %s\n", gpg_strerror (err));
       }
 
       hashalgo = gcry_md_map_name (tests[tno].hashname);
       if (!hashalgo)
         die ("hash with name '%s' is not supported\n", tests[tno].hashname);
 
       digestlen = gcry_md_get_algo_dlen (hashalgo);
       if (digestlen > sizeof digest)
         die ("internal error: digest does not fit into our buffer\n");
 
       gcry_md_hash_buffer (hashalgo, digest,
                            tests[tno].message, strlen (tests[tno].message));
 
       err = gcry_sexp_build (&data, NULL,
                              "(data "
                              " (flags rfc6979)"
                              " (hash %s %b))",
                              tests[tno].hashname, digestlen, digest);
       if (err)
         die ("building data sexp failed: %s\n", gpg_strerror (err));
 
       err = gcry_pk_sign (&sig, data, seckey);
       if (err)
         fail ("signing failed: %s\n", gpg_strerror (err));
 
       extract_cmp_data (sig, "r", tests[tno].r);
       extract_cmp_data (sig, "s", tests[tno].s);
 
       err = gcry_pk_verify (sig, data, seckey);
       if (err)
         fail ("verification failed: %s\n", gpg_strerror (err));
 
       gcry_sexp_release (sig);
       gcry_sexp_release (data);
       gcry_sexp_release (seckey);
     }
 }
 
 
 
 int
 main (int argc, char **argv)
 {
   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     verbose = 1;
   else if (argc > 1 && !strcmp (argv[1], "--debug"))
     {
       verbose = 2;
       debug = 1;
     }
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
   /* Check that we test exactly our version - including the patchlevel.  */
   if (strcmp (GCRYPT_VERSION, gcry_check_version (NULL)))
     die ("version mismatch; pgm=%s, library=%s\n",
          GCRYPT_VERSION,gcry_check_version (NULL));
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
   /* No valuable keys are create, so we can speed up our RNG. */
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
 
   check_dsa_rfc6979 ();
 
   return error_count ? 1 : 0;
 }
diff --git a/tests/fips186-dsa.c b/tests/fips186-dsa.c
index b5f0cf0b..5ed5653b 100644
--- a/tests/fips186-dsa.c
+++ b/tests/fips186-dsa.c
@@ -1,429 +1,429 @@
 /* fips186-dsa.c - FIPS 186 DSA tests
  *	Copyright (C) 2008 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 
 #ifdef _GCRYPT_IN_LIBGCRYPT
 # include "../src/gcrypt-int.h"
 #else
 # include <gcrypt.h>
 #endif
 
 #define PGM "fips186-dsa"
 #include "t-common.h"
 
 
 static void
 show_sexp (const char *prefix, gcry_sexp_t a)
 {
   char *buf;
   size_t size;
 
   if (prefix)
     fputs (prefix, stderr);
   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   buf = gcry_xmalloc (size);
 
   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
   fprintf (stderr, "%.*s", (int)size, buf);
   gcry_free (buf);
 }
 
 static gcry_mpi_t
 mpi_from_string (const char *string)
 {
   gpg_error_t err;
   gcry_mpi_t a;
 
   err = gcry_mpi_scan (&a, GCRYMPI_FMT_HEX, string, 0, NULL);
   if (err)
     die ("error converting string to mpi: %s\n", gpg_strerror (err));
   return a;
 }
 
 /* Convert STRING consisting of hex characters into its binary
    representation and return it as an allocated buffer. The valid
    length of the buffer is returned at R_LENGTH.  The string is
    delimited by end of string.  The function returns NULL on
    error.  */
 static void *
 data_from_hex (const char *string, size_t *r_length)
 {
   const char *s;
   unsigned char *buffer;
   size_t length;
 
   buffer = gcry_xmalloc (strlen(string)/2+1);
   length = 0;
   for (s=string; *s; s +=2 )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         die ("error parsing hex string `%s'\n", string);
       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     }
   *r_length = length;
   return buffer;
 }
 
 
 static void
 extract_cmp_mpi (gcry_sexp_t sexp, const char *name, const char *expected)
 {
   gcry_sexp_t l1;
   gcry_mpi_t a, b;
 
   l1 = gcry_sexp_find_token (sexp, name, 0);
   a = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
   b = mpi_from_string (expected);
   if (!a)
     fail ("parameter \"%s\" missing in key\n", name);
   else if ( gcry_mpi_cmp (a, b) )
     fail ("parameter \"%s\" does not match expected value\n", name);
   gcry_mpi_release (b);
   gcry_mpi_release (a);
   gcry_sexp_release (l1);
 }
 
 
 static void
 extract_cmp_data (gcry_sexp_t sexp, const char *name, const char *expected)
 {
   gcry_sexp_t l1;
   const void *a;
   size_t alen;
   void *b;
   size_t blen;
 
   l1 = gcry_sexp_find_token (sexp, name, 0);
   a = gcry_sexp_nth_data (l1, 1, &alen);
   b = data_from_hex (expected, &blen);
   if (!a)
     fail ("parameter \"%s\" missing in key\n", name);
   else if ( alen != blen || memcmp (a, b, alen) )
     fail ("parameter \"%s\" does not match expected value\n", name);
   gcry_free (b);
   gcry_sexp_release (l1);
 }
 
 static void
 extract_cmp_int (gcry_sexp_t sexp, const char *name, int expected)
 {
   gcry_sexp_t l1;
   char *a;
 
   l1 = gcry_sexp_find_token (sexp, name, 0);
   a = gcry_sexp_nth_string (l1, 1);
   if (!a)
     fail ("parameter \"%s\" missing in key\n", name);
   else if ( strtoul (a, NULL, 10) != expected )
     fail ("parameter \"%s\" does not match expected value\n", name);
   gcry_free (a);
   gcry_sexp_release (l1);
 }
 
 
 static void
 check_dsa_gen_186_2 (void)
 {
   static struct {
     int nbits;
     const char *p, *q, *g;
     const char *seed;
     int counter;
     const char *h;
   } tbl[] = {
     /* These tests are from FIPS 186-2, B.3.1.  */
     {
       1024,
       "d3aed1876054db831d0c1348fbb1ada72507e5fbf9a62cbd47a63aeb7859d6921"
       "4adeb9146a6ec3f43520f0fd8e3125dd8bbc5d87405d1ac5f82073cd762a3f8d7"
       "74322657c9da88a7d2f0e1a9ceb84a39cb40876179e6a76e400498de4bb9379b0"
       "5f5feb7b91eb8fea97ee17a955a0a8a37587a272c4719d6feb6b54ba4ab69",
       "9c916d121de9a03f71fb21bc2e1c0d116f065a4f",
       "8157c5f68ca40b3ded11c353327ab9b8af3e186dd2e8dade98761a0996dda99ab"
       "0250d3409063ad99efae48b10c6ab2bba3ea9a67b12b911a372a2bba260176fad"
       "b4b93247d9712aad13aa70216c55da9858f7a298deb670a403eb1e7c91b847f1e"
       "ccfbd14bd806fd42cf45dbb69cd6d6b43add2a78f7d16928eaa04458dea44",
       "0cb1990c1fd3626055d7a0096f8fa99807399871",
       98,
       "00000000000000000000000000000000000000000000000000000000000000000"
       "00000000000000000000000000000000000000000000000000000000000000000"
       "00000000000000000000000000000000000000000000000000000000000000000"
       "0000000000000000000000000000000000000000000000000000000000002"
     },
     {
       1024,
       "f5c73304080353357de1b5967597c27d65f70aa2fe9b6aed1d0afc2b499adf22f"
       "8e37937096d88548ac36c4a067f8353c7fed73f96f0d688b19b0624aedbae5dbb"
       "0ee8835a4c269288c0e1d69479e701ee266bb767af39d748fe7d6afc73fdf44be"
       "3eb6e661e599670061203e75fc8b3dbd59e40b54f358d0097013a0f3867f9",
       "f8751166cf4f6f3b07c081fd2a9071f23ca1988d",
       "1e288a442e02461c418ed67a66d24cacbeb8936fbde62ff995f5fd569dee6be62"
       "4e4f0f9f8c8093f5d192ab3b3f9ae3f2665d95d27fb10e382f45cd356e7f4eb7a"
       "665db432113ed06478f93b7cf188ec7a1ee97aec8f91ea7bfceaf8b6e7e5a349c"
       "4ad3225362ef440c57cbc6e69df15b6699caac85f733555075f04781b2b33",
       "34b3520d45d240a8861b82c8b61ffa16e67b5cce",
       622,
       "00000000000000000000000000000000000000000000000000000000000000000"
       "00000000000000000000000000000000000000000000000000000000000000000"
       "00000000000000000000000000000000000000000000000000000000000000000"
       "0000000000000000000000000000000000000000000000000000000000002",
     },
     {
       1024,
       "c6c6f4f4eed927fb1c3b0c81010967e530658e6f9698ebe058b4f47b2dc8fcbc7"
       "b69296b9e8b6cf55681181fe72492668061b262b0046a0d409902e269b0cb69a4"
       "55ed1a086caf41927f5912bf0e0cbc45ee81a4f98bf6146f6168a228aec80e9cc"
       "1162d6f6aa412efe82d4f18b95e34ab790daac5bd7aef0b22fa08ba5dbaad",
       "d32b29f065c1394a30490b6fcbf812a32a8634ab",
       "06f973c879e2e89345d0ac04f9c34ad69b9eff1680f18d1c8f3e1596c2e8fa8e1"
       "ecef6830409e9012d4788bef6ec7414d09c981b47c941b77f39dfc49caff5e714"
       "c97abe25a7a8b5d1fe88700bb96eff91cca64d53700a28b1146d81bad1212d231"
       "80154c95a01f5aeebb553a8365c38a5ebe05539b51734233776ce9aff98b2",
       "b6ec750da2f824cb42c5f7e28c81350d97f75125",
       185,
       "00000000000000000000000000000000000000000000000000000000000000000"
       "00000000000000000000000000000000000000000000000000000000000000000"
       "00000000000000000000000000000000000000000000000000000000000000000"
       "0000000000000000000000000000000000000000000000000000000000002",
     },
     {
       1024,
       "b827a9dc9221a6ed1bec7b64d61232aacb2812f888b0a0b3a95033d7a22e77d0b"
       "ff23bfeed0fb1281b21b8ff7421f0c727d1fb8aa2b843d6885f067e763f83d41f"
       "d800ab15a7e2b12f71ec2058ee7bd62cd72c26989b272e519785da57bfa1f974b"
       "c652e1a2d6cfb68477de5635fd019b37add656cff0b802558b31b6d2851e5",
       "de822c03445b77cec4ad3a6fb0ca39ff97059ddf",
       "65a9e2d43a378d7063813104586868cacf2fccd51aec1e0b6af8ba3e66dee6371"
       "681254c3fb5e3929d65e3c4bcd20abd4ddc7cf815623e17b9fc92f02b8d44278b"
       "848480ffd193104cf5612639511e45bd247708ff6028bd3824f8844c263b46c69"
       "1f2076f8cd13c5d0be95f1f2a1a17ab1f7e5bc73500bac27d57b473ba9748",
       "cd2221dd73815a75224e9fde7faf52829b81ac7a",
       62,
       "00000000000000000000000000000000000000000000000000000000000000000"
       "00000000000000000000000000000000000000000000000000000000000000000"
       "00000000000000000000000000000000000000000000000000000000000000000"
       "0000000000000000000000000000000000000000000000000000000000002",
     },
     {
       1024,
       "898a8d93e295c8ef2ffd46976225a1543640640d155a576fafa0be32136165803"
       "ba2eff2782a2be75cc9ec65db6bd3238cca695b3a5a14726a2a314775c377d891"
       "354b3de6c89e714a05599ca04132c987f889f72c4fe298ccb31f711c03b07e1d9"
       "8d72af590754cf3847398b60cecd55a4611692b308809560a83880404c227",
       "c6d786643d2acfc6b8d576863fda8cfbfbd5e03f",
       "2fd38b8d21c58e8fb5315a177b8d5dc4c450d574e69348b7b9da367c26e72438d"
       "af8372e7f0bee84ef5dcbbc3727194a2228431192f1779be24837f22a0e14d10d"
       "5344da1b8b403df9f9b2655095b3d0f67418ed6cd989f35aa4232e4b7001764fb"
       "e85d6b2c716980f13272fc4271ac1e234f7e24c023cfc2d2dc0aa1e9af2fb",
       "73483e697599871af983a281e3afa22e0ed86b68",
       272,
       "00000000000000000000000000000000000000000000000000000000000000000"
       "00000000000000000000000000000000000000000000000000000000000000000"
       "00000000000000000000000000000000000000000000000000000000000000000"
       "0000000000000000000000000000000000000000000000000000000000002",
     },
 
     /* These tests are generated by the OpenSSL FIPS version.  */
     {
       1024,
       "A404363903FDCE86839BCFD953AAD2DA2B0E70CAED3B5FF5D68F15A1C4BB0A793C"
       "A9D58FC956804C5901DE0AF99F345ED1A8617C687864BAC044B7C3C3E732A2B255"
       "EC986AA76EA8CB0E0815B3E0E605650AF7D8058EE7E8EBCDEFFDAB8100D3FC1033"
       "11BA3AB232EF06BB74BA9A949EC0C7ED324C19B202F4AB725BBB4080C9",
       "C643946CEA8748E12D430C48DB038F9165814389",
       "59B7E7BA0033CCE8E6837173420FBB382A784D4154A3C166043F5A68CB92945D16"
       "892D4CC5585F2D28C780E75A6C20A379E2B58304C1E5FC0D8C15E4E89C4498C8BC"
       "B90FB36ED8DC0489B9D0BC09EC4411FB0BFADF25485EEAB6700BE0ACF5C44A6ED7"
       "44A015382FF9B8DA7EAA00DEA135FADC59212DBBFFC1537336FA4B7225",
       "02708ab36e3f0bfd67ec3b8bd8829d03b84f56bd",
       50,
       "02"
     },
     {
       1024,
       "9C664033DB8B203D826F896D2293C62EF9351D5CFD0F4C0AD7EFDA4DDC7F15987"
       "6A3C68CAB2586B44FD1BD4DEF7A17905D88D321DD77C4E1720D848CA21D79F9B3"
       "D8F537338E09B44E9F481E8DA3C56569F63146596A050EF8FAEE8ACA32C666450"
       "04F675C8806EB4025B0A5ECC39CE89983EA40A183A7CF5208BA958045ABD5",
       "AD0D8CBA369AF6CD0D2BAC0B4CFCAF0A1F9BCDF7",
       "74D717F7092A2AF725FDD6C2561D1DBE5AEE40203C638BA8B9F49003857873701"
       "95A44E515C4E8B344F5CDC7F4A6D38097CD57675E7643AB9700692C69F0A99B0E"
       "039FDDDFCA8CEB607BDB4ADF2834DE1690F5823FC8199FB8F6F29E5A583B6786A"
       "C14C7E67106C3B30568CBB9383F89287D578159778EB18216799D16D46498",
       "6481a12a50384888ee84b61024f7c9c685d6ac96",
       289,
       "02"
     },
     {
       1024,
 
       "B0DFB602EB8462B1DC8C2214A52B587D3E6842CCF1C38D0F7C7F967ED30CF6828"
       "1E2675B3BAB594755FB1634E66B4C23936F0725A358F8DFF3C307E2601FD66D63"
       "5B17270450C50BD2BEC29E0E9A471DF1C15B0191517952268A2763D4BD28B8503"
       "B3399686272B76B11227F693D7833105EF70C2289C3194CF4527024B272DF",
       "EA649C04911FAB5A41440287A517EF752A40354B",
       "88C5A4563ECB949763E0B696CD04B21321360F54C0EE7B23E2CEDC30E9E486162"
       "01BFB1619E7C54B653D1F890C50E04B29205F5E3E2F93A13B0751AF25491C5194"
       "93C09DDF6B9C173B3846DFB0E7A5C870BBFC78419260C90E20315410691C8326C"
       "858D7063E7921F3F601158E912C7EE487FF259202BEEB10F6D9E99190F696",
       "5bf9d17bc62fbbf3d569c92bd4505586b2e5ef1a",
       626,
       "02"
     },
     {
       1024,
       "F783C08D7F9463E48BA87893805C4B34B63C85DF7EBDD9EBEE94DB4AF4E4A415C"
       "F0F3793AE55096BA1199598798FA8403B28DED7F7C7AFD54FD535861A0150EF4D"
       "5871465B13837CCF46BEB0A22F8D38DC7D6AE0E14A3845FD0C027CFA97791B977"
       "CE2808BAD9B43CE69390C0F40016056722D82C0D7B1B27413D026A39D7DAD",
       "A40D9EE456AED4C8A653FDB47B6629C0B843FE8F",
       "DF876263E21F263AE6DA57409BD517DCEADB9216048F066D6B58867F8E59A5EEE"
       "700283A946C1455534618979BE6C227673C1B803910262BD93BC94D5089850614"
       "F3E29AB64E8C989A7E3E28FE670FFA3EE21DEEEC1AB0B60E1D8E2AA39663BADD7"
       "2C9F957D7F3D4F17D9FDAD050EB373A6DEFD09F5DA752EAFE046836E14B67",
       "8a9a57706f69f4f566252cdf6d5cbfdf2020150b",
       397,
       "02"
     },
     {
       1024,
       "D40E4F6461E145859CCF60FD57962840BD75FFF12C22F76626F566842252AD068"
       "29745F0147056354F6C016CF12762B0E331787925B8128CF5AF81F9B176A51934"
       "96D792430FF83C7B79BD595BDA10787B34600787FA552EFE3662F37B99AAD3F3A"
       "093732680A01345192A19BECCE6BF5D498E44ED6BED5B0BA72AAD49E8276B",
       "D12F1BD0AA78B99247FD9F18EAFEE5C136686EA5",
       "468EBD20C99449C1E440E6F8E452C6A6BC7551C555FE5E94996E20CFD4DA3B9CC"
       "58499D6CC2374CCF9C392715A537DE10CFCA8A6A37AFBD187CF6B88D26881E5F5"
       "7521D9D2C9BBA51E7B87B070BBE73F5C5FE31E752CAF88183516D8503BAAC1159"
       "928EF50DEE52D96F396B93FB4138D786464C315401A853E57C9A0F9D25839",
       "30b3599944a914a330a3f49d11ec88f555422aef",
       678,
       "02"
     }
   };
   gpg_error_t err;
   int tno;
   gcry_sexp_t key_spec, key, pub_key, sec_key, seed_values;
   gcry_sexp_t l1;
 
   for (tno = 0; tno < DIM (tbl); tno++)
     {
       if (verbose)
         info ("generating FIPS 186-2 test key %d\n", tno);
 
       {
         void *data;
         size_t datalen;
 
         data = data_from_hex (tbl[tno].seed, &datalen);
         err = gcry_sexp_build (&key_spec, NULL,
                                "(genkey (dsa (nbits %d)(use-fips186-2)"
                                "(derive-parms(seed %b))))",
                                tbl[tno].nbits, (int)datalen, data);
         gcry_free (data);
       }
       if (err)
         die ("error creating S-expression %d: %s\n", tno, gpg_strerror (err));
 
       err = gcry_pk_genkey (&key, key_spec);
       gcry_sexp_release (key_spec);
       if (err)
         {
           fail ("error generating key %d: %s\n", tno, gpg_strerror (err));
           continue;
         }
 
       if (verbose > 1)
         show_sexp ("generated key:\n", key);
 
       pub_key = gcry_sexp_find_token (key, "public-key", 0);
       if (!pub_key)
         fail ("public part missing in key %d\n", tno);
 
       sec_key = gcry_sexp_find_token (key, "private-key", 0);
       if (!sec_key)
         fail ("private part missing in key %d\n", tno);
 
       l1 = gcry_sexp_find_token (key, "misc-key-info", 0);
       if (!l1)
         fail ("misc_key_info part missing in key %d\n", tno);
       seed_values = gcry_sexp_find_token (l1, "seed-values", 0);
       if (!seed_values)
         fail ("seed-values part missing in key %d\n", tno);
       gcry_sexp_release (l1);
 
       extract_cmp_mpi (sec_key, "p", tbl[tno].p);
       extract_cmp_mpi (sec_key, "q", tbl[tno].q);
       extract_cmp_mpi (sec_key, "g", tbl[tno].g);
 
       extract_cmp_data (seed_values, "seed", tbl[tno].seed);
       extract_cmp_int (seed_values, "counter", tbl[tno].counter);
       extract_cmp_mpi (seed_values, "h", tbl[tno].h);
 
       gcry_sexp_release (seed_values);
       gcry_sexp_release (sec_key);
       gcry_sexp_release (pub_key);
       gcry_sexp_release (key);
     }
 }
 
 
 static void
 check_dsa_gen_186_3 (void)
 {
   /* FIXME: Needs to be implemented.  */
   if (verbose)
     info ("generating FIPS 186-3 test keys - skipped\n");
 }
 
 
 int
 main (int argc, char **argv)
 {
   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     verbose = 1;
   else if (argc > 1 && !strcmp (argv[1], "--debug"))
     {
       verbose = 2;
       debug = 1;
     }
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
   /* No valuable keys are create, so we can speed up our RNG. */
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
 
 
   check_dsa_gen_186_2 ();
   check_dsa_gen_186_3 ();
 
 
   return error_count ? 1 : 0;
 }
diff --git a/tests/fipsdrv.c b/tests/fipsdrv.c
index 71554e23..f6268e2a 100644
--- a/tests/fipsdrv.c
+++ b/tests/fipsdrv.c
@@ -1,2865 +1,2865 @@
 /* fipsdrv.c  -  A driver to help with FIPS CAVS tests.
    Copyright (C) 2008 Free Software Foundation, Inc.
 
    This file is part of Libgcrypt.
 
    Libgcrypt is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2.1 of
    the License, or (at your option) any later version.
 
    Libgcrypt is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <errno.h>
 #include <ctype.h>
 #ifdef HAVE_W32_SYSTEM
 # include <fcntl.h> /* We need setmode().  */
 #else
 # include <signal.h>
 #endif
 #include <assert.h>
 #include <unistd.h>
 
 #ifndef _GCRYPT_IN_LIBGCRYPT
 # include <gcrypt.h>
 # define PACKAGE_BUGREPORT "devnull@example.org"
 # define PACKAGE_VERSION "[build on " __DATE__ " " __TIME__ "]"
 #endif
 #include "../src/gcrypt-testapi.h"
 
 #define PGM "fipsdrv"
 #include "t-common.h"
 
 
 /* Binary input flag.  */
 static int binary_input;
 
 /* Binary output flag.  */
 static int binary_output;
 
 /* Base64 output flag.  */
 static int base64_output;
 
 /* We need to know whether we are in loop_mode.  */
 static int loop_mode;
 
 /* If true some functions are modified to print the output in the CAVS
    response file format.  */
 static int standalone_mode;
 
 
 /* ASN.1 classes.  */
 enum
 {
   UNIVERSAL = 0,
   APPLICATION = 1,
   ASNCONTEXT = 2,
   PRIVATE = 3
 };
 
 
 /* ASN.1 tags.  */
 enum
 {
   TAG_NONE = 0,
   TAG_BOOLEAN = 1,
   TAG_INTEGER = 2,
   TAG_BIT_STRING = 3,
   TAG_OCTET_STRING = 4,
   TAG_NULL = 5,
   TAG_OBJECT_ID = 6,
   TAG_OBJECT_DESCRIPTOR = 7,
   TAG_EXTERNAL = 8,
   TAG_REAL = 9,
   TAG_ENUMERATED = 10,
   TAG_EMBEDDED_PDV = 11,
   TAG_UTF8_STRING = 12,
   TAG_REALTIVE_OID = 13,
   TAG_SEQUENCE = 16,
   TAG_SET = 17,
   TAG_NUMERIC_STRING = 18,
   TAG_PRINTABLE_STRING = 19,
   TAG_TELETEX_STRING = 20,
   TAG_VIDEOTEX_STRING = 21,
   TAG_IA5_STRING = 22,
   TAG_UTC_TIME = 23,
   TAG_GENERALIZED_TIME = 24,
   TAG_GRAPHIC_STRING = 25,
   TAG_VISIBLE_STRING = 26,
   TAG_GENERAL_STRING = 27,
   TAG_UNIVERSAL_STRING = 28,
   TAG_CHARACTER_STRING = 29,
   TAG_BMP_STRING = 30
 };
 
 /* ASN.1 Parser object.  */
 struct tag_info
 {
   int class;             /* Object class.  */
   unsigned long tag;     /* The tag of the object.  */
   unsigned long length;  /* Length of the values.  */
   int nhdr;              /* Length of the header (TL).  */
   unsigned int ndef:1;   /* The object has an indefinite length.  */
   unsigned int cons:1;   /* This is a constructed object.  */
 };
 
 
 static void
 showhex (const char *prefix, const void *buffer, size_t length)
 {
   const unsigned char *p = buffer;
 
   if (prefix)
     fprintf (stderr, PGM ": %s: ", prefix);
   while (length-- )
     fprintf (stderr, "%02X", *p++);
   if (prefix)
     putc ('\n', stderr);
 }
 
 /* static void */
 /* show_sexp (const char *prefix, gcry_sexp_t a) */
 /* { */
 /*   char *buf; */
 /*   size_t size; */
 
 /*   if (prefix) */
 /*     fputs (prefix, stderr); */
 /*   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0); */
 /*   buf = gcry_xmalloc (size); */
 
 /*   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size); */
 /*   fprintf (stderr, "%.*s", (int)size, buf); */
 /*   gcry_free (buf); */
 /* } */
 
 
 /* Convert STRING consisting of hex characters into its binary
    representation and store that at BUFFER.  BUFFER needs to be of
    LENGTH bytes.  The function checks that the STRING will convert
    exactly to LENGTH bytes. The string is delimited by either end of
    string or a white space character.  The function returns -1 on
    error or the length of the parsed string.  */
 static int
 hex2bin (const char *string, void *buffer, size_t length)
 {
   int i;
   const char *s = string;
 
   for (i=0; i < length; )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         return -1;           /* Invalid hex digits. */
       ((unsigned char*)buffer)[i++] = xtoi_2 (s);
       s += 2;
     }
   if (*s && (!my_isascii (*s) || !isspace (*s)) )
     return -1;             /* Not followed by Nul or white space.  */
   if (i != length)
     return -1;             /* Not of expected length.  */
   if (*s)
     s++; /* Skip the delimiter. */
   return s - string;
 }
 
 
 /* Convert STRING consisting of hex characters into its binary
    representation and return it as an allocated buffer. The valid
    length of the buffer is returned at R_LENGTH.  The string is
    delimited by end of string.  The function returns NULL on
    error.  */
 static void *
 hex2buffer (const char *string, size_t *r_length)
 {
   const char *s;
   unsigned char *buffer;
   size_t length;
 
   buffer = gcry_xmalloc (strlen(string)/2+1);
   length = 0;
   for (s=string; *s; s +=2 )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         return NULL;           /* Invalid hex digits. */
       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     }
   *r_length = length;
   return buffer;
 }
 
 
 static char *
 read_textline (FILE *fp)
 {
   char line[256];
   char *p;
   int any = 0;
 
   /* Read line but skip over initial empty lines.  */
   do
     {
       do
         {
           if (!fgets (line, sizeof line, fp))
             {
               if (feof (fp))
                 return NULL;
               die ("error reading input line: %s\n", strerror (errno));
             }
           p = strchr (line, '\n');
           if (p)
             *p = 0;
           p = line + (*line? (strlen (line)-1):0);
           for ( ;p > line; p--)
             if (my_isascii (*p) && isspace (*p))
               *p = 0;
         }
       while (!any && !*line);
       any = 1;
     }
   while (*line == '#');  /* Always skip comment lines.  */
   if (verbose > 1)
     fprintf (stderr, PGM ": received line: %s\n", line);
   return gcry_xstrdup (line);
 }
 
 static char *
 read_hexline (FILE *fp, size_t *retlen)
 {
   char *line, *p;
 
   line = read_textline (fp);
   if (!line)
     return NULL;
   p = hex2buffer (line, retlen);
   if (!p)
     die ("error decoding hex string on input\n");
   gcry_free (line);
   return p;
 }
 
 static void
 skip_to_empty_line (FILE *fp)
 {
   char line[256];
   char *p;
 
   do
     {
       if (!fgets (line, sizeof line, fp))
         {
           if (feof (fp))
             return;
           die ("error reading input line: %s\n", strerror (errno));
         }
       p = strchr (line, '\n');
       if (p)
         *p =0;
     }
   while (*line);
 }
 
 
 
 /* Read a file from stream FP into a newly allocated buffer and return
    that buffer.  The valid length of the buffer is stored at R_LENGTH.
    Returns NULL on failure.  If decode is set, the file is assumed to
    be hex encoded and the decoded content is returned. */
 static void *
 read_file (FILE *fp, int decode, size_t *r_length)
 {
   char *buffer;
   size_t buflen;
   size_t nread, bufsize = 0;
 
   *r_length = 0;
 #define NCHUNK 8192
 #ifdef HAVE_DOSISH_SYSTEM
   setmode (fileno(fp), O_BINARY);
 #endif
   buffer = NULL;
   buflen = 0;
   do
     {
       bufsize += NCHUNK;
       if (!buffer)
         buffer = gcry_xmalloc (bufsize);
       else
         buffer = gcry_xrealloc (buffer, bufsize);
 
       nread = fread (buffer + buflen, 1, NCHUNK, fp);
       if (nread < NCHUNK && ferror (fp))
         {
           gcry_free (buffer);
           return NULL;
         }
       buflen += nread;
     }
   while (nread == NCHUNK);
 #undef NCHUNK
   if (decode)
     {
       const char *s;
       char *p;
 
       for (s=buffer,p=buffer,nread=0; nread+1 < buflen; s += 2, nread +=2 )
         {
           if (!hexdigitp (s) || !hexdigitp (s+1))
             {
               gcry_free (buffer);
               return NULL;  /* Invalid hex digits. */
             }
           *(unsigned char*)p++ = xtoi_2 (s);
         }
       if (nread != buflen)
         {
           gcry_free (buffer);
           return NULL;  /* Odd number of hex digits. */
         }
       buflen = p - buffer;
     }
 
   *r_length = buflen;
   return buffer;
 }
 
 /* Do in-place decoding of base-64 data of LENGTH in BUFFER.  Returns
    the new length of the buffer.  Dies on error.  */
 static size_t
 base64_decode (char *buffer, size_t length)
 {
   static unsigned char const asctobin[128] =
     {
       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
       0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0xff, 0xff,
       0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
       0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
       0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
       0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
       0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff
     };
 
   int idx = 0;
   unsigned char val = 0;
   int c = 0;
   char *d, *s;
   int lfseen = 1;
 
   /* Find BEGIN line.  */
   for (s=buffer; length; length--, s++)
     {
       if (lfseen && *s == '-' && length > 11 && !memcmp (s, "-----BEGIN ", 11))
         {
           for (; length && *s != '\n'; length--, s++)
             ;
           break;
         }
       lfseen = (*s == '\n');
     }
 
   /* Decode until pad character or END line.  */
   for (d=buffer; length; length--, s++)
     {
       if (lfseen && *s == '-' && length > 9 && !memcmp (s, "-----END ", 9))
         break;
       if ((lfseen = (*s == '\n')) || *s == ' ' || *s == '\r' || *s == '\t')
         continue;
       if (*s == '=')
         {
           /* Pad character: stop */
           if (idx == 1)
             *d++ = val;
           break;
         }
 
       if ( (*s & 0x80) || (c = asctobin[*(unsigned char *)s]) == 0xff)
         die ("invalid base64 character %02X at pos %d detected\n",
              *(unsigned char*)s, (int)(s-buffer));
 
       switch (idx)
         {
         case 0:
           val = c << 2;
           break;
         case 1:
           val |= (c>>4)&3;
           *d++ = val;
           val = (c<<4)&0xf0;
           break;
         case 2:
           val |= (c>>2)&15;
           *d++ = val;
           val = (c<<6)&0xc0;
           break;
         case 3:
           val |= c&0x3f;
           *d++ = val;
           break;
         }
       idx = (idx+1) % 4;
     }
 
   return d - buffer;
 }
 
 
 /* Parse the buffer at the address BUFFER which consists of the number
    of octets as stored at BUFLEN.  Return the tag and the length part
    from the TLV triplet.  Update BUFFER and BUFLEN on success.  Checks
    that the encoded length does not exhaust the length of the provided
    buffer. */
 static int
 parse_tag (unsigned char const **buffer, size_t *buflen, struct tag_info *ti)
 {
   int c;
   unsigned long tag;
   const unsigned char *buf = *buffer;
   size_t length = *buflen;
 
   ti->length = 0;
   ti->ndef = 0;
   ti->nhdr = 0;
 
   /* Get the tag */
   if (!length)
     return -1; /* Premature EOF.  */
   c = *buf++; length--;
   ti->nhdr++;
 
   ti->class = (c & 0xc0) >> 6;
   ti->cons  = !!(c & 0x20);
   tag       = (c & 0x1f);
 
   if (tag == 0x1f)
     {
       tag = 0;
       do
         {
           tag <<= 7;
           if (!length)
             return -1; /* Premature EOF.  */
           c = *buf++; length--;
           ti->nhdr++;
           tag |= (c & 0x7f);
         }
       while ( (c & 0x80) );
     }
   ti->tag = tag;
 
   /* Get the length */
   if (!length)
     return -1; /* Premature EOF. */
   c = *buf++; length--;
   ti->nhdr++;
 
   if ( !(c & 0x80) )
     ti->length = c;
   else if (c == 0x80)
     ti->ndef = 1;
   else if (c == 0xff)
     return -1; /* Forbidden length value.  */
   else
     {
       unsigned long len = 0;
       int count = c & 0x7f;
 
       for (; count; count--)
         {
           len <<= 8;
           if (!length)
             return -1; /* Premature EOF.  */
           c = *buf++; length--;
           ti->nhdr++;
           len |= (c & 0xff);
         }
       ti->length = len;
     }
 
   if (ti->class == UNIVERSAL && !ti->tag)
     ti->length = 0;
 
   if (ti->length > length)
     return -1; /* Data larger than buffer.  */
 
   *buffer = buf;
   *buflen = length;
   return 0;
 }
 
 
 /* Read the file FNAME assuming it is a PEM encoded private key file
    and return an S-expression.  With SHOW set, the key parameters are
    printed.  */
 static gcry_sexp_t
 read_private_key_file (const char *fname, int show)
 {
   gcry_error_t err;
   FILE *fp;
   char *buffer;
   size_t buflen;
   const unsigned char *der;
   size_t derlen;
   struct tag_info ti;
   gcry_mpi_t keyparms[8];
   int n_keyparms = 8;
   int idx;
   gcry_sexp_t s_key;
 
   fp = fopen (fname, binary_input?"rb":"r");
   if (!fp)
     die ("can't open `%s': %s\n", fname, strerror (errno));
   buffer = read_file (fp, 0, &buflen);
   if (!buffer)
     die ("error reading `%s'\n", fname);
   fclose (fp);
 
   buflen = base64_decode (buffer, buflen);
 
   /* Parse the ASN.1 structure.  */
   der = (const unsigned char*)buffer;
   derlen = buflen;
   if ( parse_tag (&der, &derlen, &ti)
        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
     goto bad_asn1;
   if ( parse_tag (&der, &derlen, &ti)
        || ti.tag != TAG_INTEGER || ti.class || ti.cons || ti.ndef)
     goto bad_asn1;
   if (ti.length != 1 || *der)
     goto bad_asn1;  /* The value of the first integer is no 0. */
   der += ti.length; derlen -= ti.length;
 
   for (idx=0; idx < n_keyparms; idx++)
     {
       if ( parse_tag (&der, &derlen, &ti)
            || ti.tag != TAG_INTEGER || ti.class || ti.cons || ti.ndef)
         goto bad_asn1;
       if (show)
         {
           char prefix[2];
 
           prefix[0] = idx < 8? "nedpq12u"[idx] : '?';
           prefix[1] = 0;
           showhex (prefix, der, ti.length);
         }
       err = gcry_mpi_scan (keyparms+idx, GCRYMPI_FMT_USG, der, ti.length,NULL);
       if (err)
         die ("error scanning RSA parameter %d: %s\n", idx, gpg_strerror (err));
       der += ti.length; derlen -= ti.length;
     }
   if (idx != n_keyparms)
     die ("not enough RSA key parameters\n");
 
   gcry_free (buffer);
 
   /* Convert from OpenSSL parameter ordering to the OpenPGP order. */
   /* First check that p < q; if not swap p and q and recompute u.  */
   if (gcry_mpi_cmp (keyparms[3], keyparms[4]) > 0)
     {
       gcry_mpi_swap (keyparms[3], keyparms[4]);
       gcry_mpi_invm (keyparms[7], keyparms[3], keyparms[4]);
     }
 
   /* Build the S-expression.  */
   err = gcry_sexp_build (&s_key, NULL,
                          "(private-key(rsa(n%m)(e%m)"
                          /**/            "(d%m)(p%m)(q%m)(u%m)))",
                          keyparms[0], keyparms[1], keyparms[2],
                          keyparms[3], keyparms[4], keyparms[7] );
   if (err)
     die ("error building S-expression: %s\n", gpg_strerror (err));
 
   for (idx=0; idx < n_keyparms; idx++)
     gcry_mpi_release (keyparms[idx]);
 
   return s_key;
 
  bad_asn1:
   die ("invalid ASN.1 structure in `%s'\n", fname);
   return NULL; /*NOTREACHED*/
 }
 
 
 /* Read the file FNAME assuming it is a PEM encoded public key file
    and return an S-expression.  With SHOW set, the key parameters are
    printed.  */
 static gcry_sexp_t
 read_public_key_file (const char *fname, int show)
 {
   gcry_error_t err;
   FILE *fp;
   char *buffer;
   size_t buflen;
   const unsigned char *der;
   size_t derlen;
   struct tag_info ti;
   gcry_mpi_t keyparms[2];
   int n_keyparms = 2;
   int idx;
   gcry_sexp_t s_key;
 
   fp = fopen (fname, binary_input?"rb":"r");
   if (!fp)
     die ("can't open `%s': %s\n", fname, strerror (errno));
   buffer = read_file (fp, 0, &buflen);
   if (!buffer)
     die ("error reading `%s'\n", fname);
   fclose (fp);
 
   buflen = base64_decode (buffer, buflen);
 
   /* Parse the ASN.1 structure.  */
   der = (const unsigned char*)buffer;
   derlen = buflen;
   if ( parse_tag (&der, &derlen, &ti)
        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
     goto bad_asn1;
   if ( parse_tag (&der, &derlen, &ti)
        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
     goto bad_asn1;
   /* We skip the description of the key parameters and assume it is RSA.  */
   der += ti.length; derlen -= ti.length;
 
   if ( parse_tag (&der, &derlen, &ti)
        || ti.tag != TAG_BIT_STRING || ti.class || ti.cons || ti.ndef)
     goto bad_asn1;
   if (ti.length < 1 || *der)
     goto bad_asn1;  /* The number of unused bits needs to be 0. */
   der += 1; derlen -= 1;
 
   /* Parse the BIT string.  */
   if ( parse_tag (&der, &derlen, &ti)
        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
     goto bad_asn1;
 
   for (idx=0; idx < n_keyparms; idx++)
     {
       if ( parse_tag (&der, &derlen, &ti)
            || ti.tag != TAG_INTEGER || ti.class || ti.cons || ti.ndef)
         goto bad_asn1;
       if (show)
         {
           char prefix[2];
 
           prefix[0] = idx < 2? "ne"[idx] : '?';
           prefix[1] = 0;
           showhex (prefix, der, ti.length);
         }
       err = gcry_mpi_scan (keyparms+idx, GCRYMPI_FMT_USG, der, ti.length,NULL);
       if (err)
         die ("error scanning RSA parameter %d: %s\n", idx, gpg_strerror (err));
       der += ti.length; derlen -= ti.length;
     }
   if (idx != n_keyparms)
     die ("not enough RSA key parameters\n");
 
   gcry_free (buffer);
 
   /* Build the S-expression.  */
   err = gcry_sexp_build (&s_key, NULL,
                          "(public-key(rsa(n%m)(e%m)))",
                          keyparms[0], keyparms[1] );
   if (err)
     die ("error building S-expression: %s\n", gpg_strerror (err));
 
   for (idx=0; idx < n_keyparms; idx++)
     gcry_mpi_release (keyparms[idx]);
 
   return s_key;
 
  bad_asn1:
   die ("invalid ASN.1 structure in `%s'\n", fname);
   return NULL; /*NOTREACHED*/
 }
 
 
 
 /* Read the file FNAME assuming it is a binary signature result and
    return an an S-expression suitable for gcry_pk_verify.  */
 static gcry_sexp_t
 read_sig_file (const char *fname)
 {
   gcry_error_t err;
   FILE *fp;
   char *buffer;
   size_t buflen;
   gcry_mpi_t tmpmpi;
   gcry_sexp_t s_sig;
 
   fp = fopen (fname, "rb");
   if (!fp)
     die ("can't open `%s': %s\n", fname, strerror (errno));
   buffer = read_file (fp, 0, &buflen);
   if (!buffer)
     die ("error reading `%s'\n", fname);
   fclose (fp);
 
   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, buffer, buflen, NULL);
   if (!err)
     err = gcry_sexp_build (&s_sig, NULL,
                            "(sig-val(rsa(s %m)))", tmpmpi);
   if (err)
     die ("error building S-expression: %s\n", gpg_strerror (err));
   gcry_mpi_release (tmpmpi);
   gcry_free (buffer);
 
   return s_sig;
 }
 
 
 /* Read an S-expression from FNAME.  */
 static gcry_sexp_t
 read_sexp_from_file (const char *fname)
 {
   gcry_error_t err;
   FILE *fp;
   char *buffer;
   size_t buflen;
   gcry_sexp_t sexp;
 
   fp = fopen (fname, "rb");
   if (!fp)
     die ("can't open `%s': %s\n", fname, strerror (errno));
   buffer = read_file (fp, 0, &buflen);
   if (!buffer)
     die ("error reading `%s'\n", fname);
   fclose (fp);
   if (!buflen)
     die ("error: file `%s' is empty\n", fname);
 
   err = gcry_sexp_create (&sexp, buffer, buflen, 1, gcry_free);
   if (err)
     die ("error parsing `%s': %s\n", fname, gpg_strerror (err));
 
   return sexp;
 }
 
 
 static void
 print_buffer (const void *buffer, size_t length)
 {
   int writerr = 0;
 
   if (base64_output)
     {
       static const unsigned char bintoasc[64+1] =
         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
         "abcdefghijklmnopqrstuvwxyz"
         "0123456789+/";
       const unsigned char *p;
       unsigned char inbuf[4];
       char outbuf[4];
       int idx, quads;
 
       idx = quads = 0;
       for (p = buffer; length; p++, length--)
         {
           inbuf[idx++] = *p;
           if (idx > 2)
             {
               outbuf[0] = bintoasc[(*inbuf>>2)&077];
               outbuf[1] = bintoasc[(((*inbuf<<4)&060)
                                     |((inbuf[1] >> 4)&017))&077];
               outbuf[2] = bintoasc[(((inbuf[1]<<2)&074)
                                     |((inbuf[2]>>6)&03))&077];
               outbuf[3] = bintoasc[inbuf[2]&077];
               if (fwrite (outbuf, 4, 1, stdout) != 1)
                 writerr = 1;
               idx = 0;
               if (++quads >= (64/4))
                 {
                   if (fwrite ("\n", 1, 1, stdout) != 1)
                     writerr = 1;
                   quads = 0;
                 }
             }
         }
       if (idx)
         {
           outbuf[0] = bintoasc[(*inbuf>>2)&077];
           if (idx == 1)
             {
               outbuf[1] = bintoasc[((*inbuf<<4)&060)&077];
               outbuf[2] = outbuf[3] = '=';
             }
           else
             {
               outbuf[1] = bintoasc[(((*inbuf<<4)&060)
                                     |((inbuf[1]>>4)&017))&077];
               outbuf[2] = bintoasc[((inbuf[1]<<2)&074)&077];
               outbuf[3] = '=';
             }
           if (fwrite (outbuf, 4, 1, stdout) != 1)
             writerr = 1;
           quads++;
         }
       if (quads && fwrite ("\n", 1, 1, stdout) != 1)
         writerr = 1;
     }
   else if (binary_output)
     {
       if (fwrite (buffer, length, 1, stdout) != 1)
         writerr++;
     }
   else
     {
       const unsigned char *p = buffer;
 
       if (verbose > 1)
         showhex ("sent line", buffer, length);
       while (length-- && !ferror (stdout) )
         printf ("%02X", *p++);
       if (ferror (stdout))
         writerr++;
     }
   if (!writerr && fflush (stdout) == EOF)
     writerr++;
   if (writerr)
     {
 #ifndef HAVE_W32_SYSTEM
       if (loop_mode && errno == EPIPE)
         loop_mode = 0;
       else
 #endif
         die ("writing output failed: %s\n", strerror (errno));
     }
 }
 
 
 /* Print an MPI on a line.  */
 static void
 print_mpi_line (gcry_mpi_t a, int no_lz)
 {
   unsigned char *buf, *p;
   gcry_error_t err;
   int writerr = 0;
 
   err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buf, NULL, a);
   if (err)
     die ("gcry_mpi_aprint failed: %s\n", gpg_strerror (err));
 
   p = buf;
   if (no_lz && p[0] == '0' && p[1] == '0' && p[2])
     p += 2;
 
   printf ("%s\n", p);
   if (ferror (stdout))
     writerr++;
   if (!writerr && fflush (stdout) == EOF)
     writerr++;
   if (writerr)
     die ("writing output failed: %s\n", strerror (errno));
   gcry_free (buf);
 }
 
 
 /* Print some data on hex format on a line.  */
 static void
 print_data_line (const void *data, size_t datalen)
 {
   const unsigned char *p = data;
   int writerr = 0;
 
   while (data && datalen-- && !ferror (stdout) )
     printf ("%02X", *p++);
   putchar ('\n');
   if (ferror (stdout))
     writerr++;
   if (!writerr && fflush (stdout) == EOF)
     writerr++;
   if (writerr)
     die ("writing output failed: %s\n", strerror (errno));
 }
 
 /* Print the S-expression A to the stream FP.  */
 static void
 print_sexp (gcry_sexp_t a, FILE *fp)
 {
   char *buf;
   size_t size;
 
   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   buf = gcry_xmalloc (size);
   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
   if (fwrite (buf, size, 1, fp) != 1)
     die ("error writing to stream: %s\n", strerror (errno));
   gcry_free (buf);
 }
 
 
 
 
 static gcry_error_t
 init_external_rng_test (void **r_context,
                     unsigned int flags,
                     const void *key, size_t keylen,
                     const void *seed, size_t seedlen,
                     const void *dt, size_t dtlen)
 {
   return gcry_control (PRIV_CTL_INIT_EXTRNG_TEST,
                        r_context, flags,
                        key, keylen,
                        seed, seedlen,
                        dt, dtlen);
 }
 
 static gcry_error_t
 run_external_rng_test (void *context, void *buffer, size_t buflen)
 {
   return gcry_control (PRIV_CTL_RUN_EXTRNG_TEST, context, buffer, buflen);
 }
 
 static void
 deinit_external_rng_test (void *context)
 {
-  xgcry_control (PRIV_CTL_DEINIT_EXTRNG_TEST, context);
+  xgcry_control ((PRIV_CTL_DEINIT_EXTRNG_TEST, context));
 }
 
 
 /* Given an OpenSSL cipher name NAME, return the Libgcrypt algirithm
    identified and store the libgcrypt mode at R_MODE.  Returns 0 on
    error.  */
 static int
 map_openssl_cipher_name (const char *name, int *r_mode)
 {
   static struct {
     const char *name;
     int algo;
     int mode;
   } table[] =
     {
       { "bf-cbc",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CBC },
       { "bf",           GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CBC },
       { "bf-cfb",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CFB },
       { "bf-ecb",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_ECB },
       { "bf-ofb",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_OFB },
 
       { "cast-cbc",     GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC },
       { "cast",         GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC },
       { "cast5-cbc",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC },
       { "cast5-cfb",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CFB },
       { "cast5-ecb",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_ECB },
       { "cast5-ofb",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_OFB },
 
       { "des-cbc",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_CBC },
       { "des",          GCRY_CIPHER_DES, GCRY_CIPHER_MODE_CBC },
       { "des-cfb",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_CFB },
       { "des-ofb",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_OFB },
       { "des-ecb",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_ECB },
 
       { "des-ede3-cbc", GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC },
       { "des-ede3",     GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_ECB },
       { "des3",         GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC },
       { "des-ede3-cfb", GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CFB },
       { "des-ede3-ofb", GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_OFB },
 
       { "rc4",          GCRY_CIPHER_ARCFOUR, GCRY_CIPHER_MODE_STREAM },
 
       { "aes-128-cbc",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC },
       { "aes-128",      GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC },
       { "aes-128-cfb",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CFB },
       { "aes-128-ecb",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB },
       { "aes-128-ofb",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_OFB },
 
       { "aes-192-cbc",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC },
       { "aes-192",      GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC },
       { "aes-192-cfb",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CFB },
       { "aes-192-ecb",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_ECB },
       { "aes-192-ofb",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_OFB },
 
       { "aes-256-cbc",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC },
       { "aes-256",      GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC },
       { "aes-256-cfb",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB },
       { "aes-256-ecb",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_ECB },
       { "aes-256-ofb",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB },
 
       { NULL, 0 , 0 }
     };
   int idx;
 
   for (idx=0; table[idx].name; idx++)
     if (!strcmp (name, table[idx].name))
       {
         *r_mode = table[idx].mode;
         return table[idx].algo;
       }
   *r_mode = 0;
   return 0;
 }
 
 
 
 /* Run an encrypt or decryption operations.  If DATA is NULL the
    function reads its input in chunks of size DATALEN from fp and
    processes it and writes it out until EOF.  */
 static void
 run_encrypt_decrypt (int encrypt_mode,
                      int cipher_algo, int cipher_mode,
                      const void *iv_buffer, size_t iv_buflen,
                      const void *key_buffer, size_t key_buflen,
                      const void *data, size_t datalen, FILE *fp)
 {
   gpg_error_t err;
   gcry_cipher_hd_t hd;
   void *outbuf;
   size_t outbuflen;
   void *inbuf;
   size_t inbuflen;
   size_t blocklen;
 
   err = gcry_cipher_open (&hd, cipher_algo, cipher_mode, 0);
   if (err)
     die ("gcry_cipher_open failed for algo %d, mode %d: %s\n",
          cipher_algo, cipher_mode, gpg_strerror (err));
 
   blocklen = gcry_cipher_get_algo_blklen (cipher_algo);
   assert (blocklen);
 
   gcry_cipher_ctl (hd, PRIV_CIPHERCTL_DISABLE_WEAK_KEY, NULL, 0);
 
   err = gcry_cipher_setkey (hd, key_buffer, key_buflen);
   if (err)
     die ("gcry_cipher_setkey failed with keylen %u: %s\n",
          (unsigned int)key_buflen, gpg_strerror (err));
 
   if (iv_buffer)
     {
       err = gcry_cipher_setiv (hd, iv_buffer, iv_buflen);
       if (err)
         die ("gcry_cipher_setiv failed with ivlen %u: %s\n",
              (unsigned int)iv_buflen, gpg_strerror (err));
     }
 
   inbuf = data? NULL : gcry_xmalloc (datalen);
   outbuflen = datalen;
   outbuf = gcry_xmalloc (outbuflen < blocklen? blocklen:outbuflen);
 
   do
     {
       if (inbuf)
         {
           int nread = fread (inbuf, 1, datalen, fp);
           if (nread < (int)datalen && ferror (fp))
             die ("error reading input\n");
           data = inbuf;
           inbuflen = nread;
         }
       else
         inbuflen = datalen;
 
       if (encrypt_mode)
         err = gcry_cipher_encrypt (hd, outbuf, outbuflen, data, inbuflen);
       else
         err = gcry_cipher_decrypt (hd, outbuf, outbuflen, data, inbuflen);
       if (err)
         die ("gcry_cipher_%scrypt failed: %s\n",
              encrypt_mode? "en":"de", gpg_strerror (err));
 
       print_buffer (outbuf, outbuflen);
     }
   while (inbuf);
 
   gcry_cipher_close (hd);
   gcry_free (outbuf);
   gcry_free (inbuf);
 }
 
 
 static void
 get_current_iv (gcry_cipher_hd_t hd, void *buffer, size_t buflen)
 {
   unsigned char tmp[17];
 
   if (gcry_cipher_ctl (hd, PRIV_CIPHERCTL_GET_INPUT_VECTOR, tmp, sizeof tmp))
     die ("error getting current input vector\n");
   if (buflen > *tmp)
     die ("buffer too short to store the current input vector\n");
   memcpy (buffer, tmp+1, *tmp);
 }
 
 /* Run the inner loop of the CAVS monte carlo test.  */
 static void
 run_cipher_mct_loop (int encrypt_mode, int cipher_algo, int cipher_mode,
                      const void *iv_buffer, size_t iv_buflen,
                      const void *key_buffer, size_t key_buflen,
                      const void *data, size_t datalen, int iterations)
 {
   gpg_error_t err;
   gcry_cipher_hd_t hd;
   size_t blocklen;
   int count;
   char input[16];
   char output[16];
   char last_output[16];
   char last_last_output[16];
   char last_iv[16];
 
 
   err = gcry_cipher_open (&hd, cipher_algo, cipher_mode, 0);
   if (err)
     die ("gcry_cipher_open failed for algo %d, mode %d: %s\n",
          cipher_algo, cipher_mode, gpg_strerror (err));
 
   blocklen = gcry_cipher_get_algo_blklen (cipher_algo);
   if (!blocklen || blocklen > sizeof output)
     die ("invalid block length %d\n", (int)blocklen);
 
 
   gcry_cipher_ctl (hd, PRIV_CIPHERCTL_DISABLE_WEAK_KEY, NULL, 0);
 
   err = gcry_cipher_setkey (hd, key_buffer, key_buflen);
   if (err)
     die ("gcry_cipher_setkey failed with keylen %u: %s\n",
          (unsigned int)key_buflen, gpg_strerror (err));
 
   if (iv_buffer)
     {
       err = gcry_cipher_setiv (hd, iv_buffer, iv_buflen);
       if (err)
         die ("gcry_cipher_setiv failed with ivlen %u: %s\n",
              (unsigned int)iv_buflen, gpg_strerror (err));
     }
 
   if (datalen != blocklen)
     die ("length of input (%u) does not match block length (%u)\n",
          (unsigned int)datalen, (unsigned int)blocklen);
   memcpy (input, data, datalen);
   memset (output, 0, sizeof output);
   for (count=0; count < iterations; count++)
     {
       memcpy (last_last_output, last_output, sizeof last_output);
       memcpy (last_output, output, sizeof output);
 
       get_current_iv (hd, last_iv, blocklen);
 
       if (encrypt_mode)
         err = gcry_cipher_encrypt (hd, output, blocklen, input, blocklen);
       else
         err = gcry_cipher_decrypt (hd, output, blocklen, input, blocklen);
       if (err)
         die ("gcry_cipher_%scrypt failed: %s\n",
              encrypt_mode? "en":"de", gpg_strerror (err));
 
 
       if (encrypt_mode && (cipher_mode == GCRY_CIPHER_MODE_CFB
                            || cipher_mode == GCRY_CIPHER_MODE_CBC))
         memcpy (input, last_iv, blocklen);
       else if (cipher_mode == GCRY_CIPHER_MODE_OFB)
         memcpy (input, last_iv, blocklen);
       else if (!encrypt_mode && cipher_mode == GCRY_CIPHER_MODE_CFB)
         {
           /* Reconstruct the output vector.  */
           int i;
           for (i=0; i < blocklen; i++)
             input[i] ^= output[i];
         }
       else
         memcpy (input, output, blocklen);
     }
 
   print_buffer (output, blocklen);
   putchar ('\n');
   print_buffer (last_output, blocklen);
   putchar ('\n');
   print_buffer (last_last_output, blocklen);
   putchar ('\n');
   get_current_iv (hd, last_iv, blocklen);
   print_buffer (last_iv, blocklen); /* Last output vector.  */
   putchar ('\n');
   print_buffer (input, blocklen);   /* Next input text. */
   putchar ('\n');
   if (verbose > 1)
     showhex ("sent line", "", 0);
   putchar ('\n');
   fflush (stdout);
 
   gcry_cipher_close (hd);
 }
 
 
 
 /* Run a digest operation.  */
 static void
 run_digest (int digest_algo,  const void *data, size_t datalen)
 {
   gpg_error_t err;
   gcry_md_hd_t hd;
   const unsigned char *digest;
   unsigned int digestlen;
 
   err = gcry_md_open (&hd, digest_algo, 0);
   if (err)
     die ("gcry_md_open failed for algo %d: %s\n",
          digest_algo,  gpg_strerror (err));
 
   gcry_md_write (hd, data, datalen);
   digest = gcry_md_read (hd, digest_algo);
   digestlen = gcry_md_get_algo_dlen (digest_algo);
   print_buffer (digest, digestlen);
   gcry_md_close (hd);
 }
 
 
 /* Run a HMAC operation.  */
 static void
 run_hmac (int digest_algo, const void *key, size_t keylen,
           const void *data, size_t datalen)
 {
   gpg_error_t err;
   gcry_md_hd_t hd;
   const unsigned char *digest;
   unsigned int digestlen;
 
   err = gcry_md_open (&hd, digest_algo, GCRY_MD_FLAG_HMAC);
   if (err)
     die ("gcry_md_open failed for HMAC algo %d: %s\n",
          digest_algo,  gpg_strerror (err));
 
   gcry_md_setkey (hd, key, keylen);
   if (err)
     die ("gcry_md_setkey failed for HMAC algo %d: %s\n",
          digest_algo,  gpg_strerror (err));
 
   gcry_md_write (hd, data, datalen);
   digest = gcry_md_read (hd, digest_algo);
   digestlen = gcry_md_get_algo_dlen (digest_algo);
   print_buffer (digest, digestlen);
   gcry_md_close (hd);
 }
 
 
 
 /* Derive an RSA key using the S-expression in (DATA,DATALEN).  This
    S-expression is used directly as input to gcry_pk_genkey.  The
    result is printed to stdout with one parameter per line in hex
    format and in this order: p, q, n, d.  */
 static void
 run_rsa_derive (const void *data, size_t datalen)
 {
   gpg_error_t err;
   gcry_sexp_t s_keyspec, s_key, s_top, l1;
   gcry_mpi_t mpi;
   const char *parmlist;
   int idx;
 
   if (!datalen)
     err = gpg_error (GPG_ERR_NO_DATA);
   else
     err = gcry_sexp_new (&s_keyspec, data, datalen, 1);
   if (err)
     die ("gcry_sexp_new failed for RSA key derive: %s\n",
          gpg_strerror (err));
 
   err = gcry_pk_genkey (&s_key, s_keyspec);
   if (err)
     die ("gcry_pk_genkey failed for RSA: %s\n", gpg_strerror (err));
 
   gcry_sexp_release (s_keyspec);
 
   /* P and Q might have been swapped but we need to to return them in
      the proper order.  Build the parameter list accordingly.  */
   parmlist = "pqnd";
   s_top = gcry_sexp_find_token (s_key, "misc-key-info", 0);
   if (s_top)
     {
       l1 = gcry_sexp_find_token (s_top, "p-q-swapped", 0);
       if (l1)
         parmlist = "qpnd";
       gcry_sexp_release (l1);
       gcry_sexp_release (s_top);
     }
 
   /* Parse and print the parameters.  */
   l1 = gcry_sexp_find_token (s_key, "private-key", 0);
   s_top = gcry_sexp_find_token (l1, "rsa", 0);
   gcry_sexp_release (l1);
   if (!s_top)
     die ("private-key part not found in result\n");
 
   for (idx=0; parmlist[idx]; idx++)
     {
       l1 = gcry_sexp_find_token (s_top, parmlist+idx, 1);
       mpi = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
       gcry_sexp_release (l1);
       if (!mpi)
         die ("parameter %c missing in private-key\n", parmlist[idx]);
       print_mpi_line (mpi, 1);
       gcry_mpi_release (mpi);
     }
 
   gcry_sexp_release (s_top);
   gcry_sexp_release (s_key);
 }
 
 
 /* Generate RSA key using the S-expression in (DATA,DATALEN).  This
    S-expression is used directly as input to gcry_pk_genkey.  The
    result is printed to stdout with one parameter per line in hex
    format and in this order: e, p, q, n, d.  */
 static void
 run_rsa_keygen (const void *data, size_t datalen, int test)
 {
   gpg_error_t err;
   gcry_sexp_t s_keyspec, s_key, s_top, l1;
   gcry_mpi_t mpi;
   const char *parmlist;
   int idx;
 
   if (!datalen)
     err = gpg_error (GPG_ERR_NO_DATA);
   else
     err = gcry_sexp_new (&s_keyspec, data, datalen, 1);
   if (err)
     die ("gcry_sexp_new failed for RSA key generation: %s\n",
          gpg_strerror (err));
 
   err = gcry_pk_genkey (&s_key, s_keyspec);
 
   gcry_sexp_release (s_keyspec);
 
   if (test) {
 	if (err)
 		printf("F\n");
 	else {
 		gcry_sexp_release (s_key);
 		printf("P\n");
 	}
 	return;
   }
 
   if (err)
     die ("gcry_pk_genkey failed for RSA: %s\n", gpg_strerror (err));
 
   parmlist = "epqnd";
 
   /* Parse and print the parameters.  */
   l1 = gcry_sexp_find_token (s_key, "private-key", 0);
   s_top = gcry_sexp_find_token (l1, "rsa", 0);
   gcry_sexp_release (l1);
   if (!s_top)
     die ("private-key part not found in result\n");
 
   for (idx=0; parmlist[idx]; idx++)
     {
       l1 = gcry_sexp_find_token (s_top, parmlist+idx, 1);
       mpi = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
       gcry_sexp_release (l1);
       if (!mpi)
         die ("parameter %c missing in private-key\n", parmlist[idx]);
       print_mpi_line (mpi, 1);
       gcry_mpi_release (mpi);
     }
 
   gcry_sexp_release (s_top);
   gcry_sexp_release (s_key);
 }
 
 
 
 static size_t
 compute_tag_length (size_t n)
 {
   int needed = 0;
 
   if (n < 128)
     needed += 2; /* Tag and one length byte.  */
   else if (n < 256)
     needed += 3; /* Tag, number of length bytes, 1 length byte.  */
   else if (n < 65536)
     needed += 4; /* Tag, number of length bytes, 2 length bytes.  */
   else
     die ("DER object too long to encode\n");
 
   return needed;
 }
 
 static unsigned char *
 store_tag_length (unsigned char *p, int tag, size_t n)
 {
   if (tag == TAG_SEQUENCE)
     tag |= 0x20; /* constructed */
 
   *p++ = tag;
   if (n < 128)
     *p++ = n;
   else if (n < 256)
     {
       *p++ = 0x81;
       *p++ = n;
     }
   else if (n < 65536)
     {
       *p++ = 0x82;
       *p++ = n >> 8;
       *p++ = n;
     }
 
   return p;
 }
 
 
 /* Generate an RSA key of size KEYSIZE using the public exponent
    PUBEXP and print it to stdout in the OpenSSL format.  The format
    is:
 
        SEQUENCE {
          INTEGER (0)  -- Unknown constant.
          INTEGER      -- n
          INTEGER      -- e
          INTEGER      -- d
          INTEGER      -- p
          INTEGER      -- q      (with p < q)
          INTEGER      -- dmp1 = d mod (p-1)
          INTEGER      -- dmq1 = d mod (q-1)
          INTEGER      -- u    = p^{-1} mod q
        }
 
 */
 static void
 run_rsa_gen (int keysize, int pubexp)
 {
   gpg_error_t err;
   gcry_sexp_t keyspec, key, l1;
   const char keyelems[] = "nedpq..u";
   gcry_mpi_t keyparms[8];
   size_t     keyparmslen[8];
   int idx;
   size_t derlen, needed, n;
   unsigned char *derbuf, *der;
 
   err = gcry_sexp_build (&keyspec, NULL,
                          "(genkey (rsa (nbits %d)(rsa-use-e %d)))",
                          keysize, pubexp);
   if (err)
     die ("gcry_sexp_build failed for RSA key generation: %s\n",
          gpg_strerror (err));
 
   err = gcry_pk_genkey (&key, keyspec);
   if (err)
     die ("gcry_pk_genkey failed for RSA: %s\n", gpg_strerror (err));
 
   gcry_sexp_release (keyspec);
 
   l1 = gcry_sexp_find_token (key, "private-key", 0);
   if (!l1)
     die ("private key not found in genkey result\n");
   gcry_sexp_release (key);
   key = l1;
 
   l1 = gcry_sexp_find_token (key, "rsa", 0);
   if (!l1)
     die ("returned private key not formed as expected\n");
   gcry_sexp_release (key);
   key = l1;
 
   /* Extract the parameters from the S-expression and store them in a
      well defined order in KEYPARMS.  */
   for (idx=0; idx < DIM(keyparms); idx++)
     {
       if (keyelems[idx] == '.')
         {
           keyparms[idx] = gcry_mpi_new (0);
           continue;
         }
       l1 = gcry_sexp_find_token (key, keyelems+idx, 1);
       if (!l1)
         die ("no %c parameter in returned private key\n", keyelems[idx]);
       keyparms[idx] = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
       if (!keyparms[idx])
         die ("no value for %c parameter in returned private key\n",
              keyelems[idx]);
       gcry_sexp_release (l1);
     }
 
   gcry_sexp_release (key);
 
   /* Check that p < q; if not swap p and q and recompute u.  */
   if (gcry_mpi_cmp (keyparms[3], keyparms[4]) > 0)
     {
       gcry_mpi_swap (keyparms[3], keyparms[4]);
       gcry_mpi_invm (keyparms[7], keyparms[3], keyparms[4]);
     }
 
   /* Compute the additional parameters.  */
   gcry_mpi_sub_ui (keyparms[5], keyparms[3], 1);
   gcry_mpi_mod (keyparms[5], keyparms[2], keyparms[5]);
   gcry_mpi_sub_ui (keyparms[6], keyparms[4], 1);
   gcry_mpi_mod (keyparms[6], keyparms[2], keyparms[6]);
 
   /* Compute the length of the DER encoding.  */
   needed = compute_tag_length (1) + 1;
   for (idx=0; idx < DIM(keyparms); idx++)
     {
       err = gcry_mpi_print (GCRYMPI_FMT_STD, NULL, 0, &n, keyparms[idx]);
       if (err)
         die ("error formatting parameter: %s\n", gpg_strerror (err));
       keyparmslen[idx] = n;
       needed += compute_tag_length (n) + n;
     }
 
   /* Store the key parameters. */
   derlen = compute_tag_length (needed) + needed;
   der = derbuf = gcry_xmalloc (derlen);
 
   der = store_tag_length (der, TAG_SEQUENCE, needed);
   der = store_tag_length (der, TAG_INTEGER, 1);
   *der++ = 0;
   for (idx=0; idx < DIM(keyparms); idx++)
     {
       der = store_tag_length (der, TAG_INTEGER, keyparmslen[idx]);
       err = gcry_mpi_print (GCRYMPI_FMT_STD, der,
                            keyparmslen[idx], NULL, keyparms[idx]);
       if (err)
         die ("error formatting parameter: %s\n", gpg_strerror (err));
       der += keyparmslen[idx];
     }
 
   /* Print the stuff.  */
   for (idx=0; idx < DIM(keyparms); idx++)
     gcry_mpi_release (keyparms[idx]);
 
   assert (der - derbuf == derlen);
 
   if (base64_output)
     puts ("-----BEGIN RSA PRIVATE KEY-----");
   print_buffer (derbuf, derlen);
   if (base64_output)
     puts ("-----END RSA PRIVATE KEY-----");
 
   gcry_free (derbuf);
 }
 
 
 
 /* Sign DATA of length DATALEN using the key taken from the PEM
    encoded KEYFILE and the hash algorithm HASHALGO.  */
 static void
 run_rsa_sign (const void *data, size_t datalen,
               int hashalgo, int pkcs1, int pss, const char *keyfile)
 
 {
   gpg_error_t err;
   gcry_sexp_t s_data, s_key, s_sig, s_tmp;
   gcry_mpi_t sig_mpi = NULL;
   unsigned char *outbuf;
   size_t outlen;
 
 /*   showhex ("D", data, datalen); */
   if (pkcs1)
     {
       unsigned char hash[64];
       unsigned int hashsize;
 
       hashsize = gcry_md_get_algo_dlen (hashalgo);
       if (!hashsize || hashsize > sizeof hash)
         die ("digest too long for buffer or unknown hash algorithm\n");
       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
       err = gcry_sexp_build (&s_data, NULL,
                              "(data (flags pkcs1)(hash %s %b))",
                              gcry_md_algo_name (hashalgo),
                              (int)hashsize, hash);
     }
   else if (pss)
     {
       unsigned char hash[64];
       unsigned int hashsize;
 
       hashsize = gcry_md_get_algo_dlen (hashalgo);
       if (!hashsize || hashsize > sizeof hash)
         die ("digest too long for buffer or unknown hash algorithm\n");
       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
       err = gcry_sexp_build (&s_data, NULL,
                              "(data (flags pss)(salt-length #00#)(hash %s %b))",
                              gcry_md_algo_name (hashalgo),
                              (int)hashsize, hash);
     }
   else
     {
       gcry_mpi_t tmp;
 
       err = gcry_mpi_scan (&tmp, GCRYMPI_FMT_USG, data, datalen,NULL);
       if (!err)
         {
           err = gcry_sexp_build (&s_data, NULL,
                                  "(data (flags raw)(value %m))", tmp);
           gcry_mpi_release (tmp);
         }
     }
   if (err)
     die ("gcry_sexp_build failed for RSA data input: %s\n",
          gpg_strerror (err));
 
   s_key = read_private_key_file (keyfile, 0);
 
   err = gcry_pk_sign (&s_sig, s_data, s_key);
   if (err)
     {
       gcry_sexp_release (read_private_key_file (keyfile, 1));
       die ("gcry_pk_signed failed (datalen=%d,keyfile=%s): %s\n",
            (int)datalen, keyfile, gpg_strerror (err));
     }
   gcry_sexp_release (s_key);
   gcry_sexp_release (s_data);
 
   s_tmp = gcry_sexp_find_token (s_sig, "sig-val", 0);
   if (s_tmp)
     {
       gcry_sexp_release (s_sig);
       s_sig = s_tmp;
       s_tmp = gcry_sexp_find_token (s_sig, "rsa", 0);
       if (s_tmp)
         {
           gcry_sexp_release (s_sig);
           s_sig = s_tmp;
           s_tmp = gcry_sexp_find_token (s_sig, "s", 0);
           if (s_tmp)
             {
               gcry_sexp_release (s_sig);
               s_sig = s_tmp;
               sig_mpi = gcry_sexp_nth_mpi (s_sig, 1, GCRYMPI_FMT_USG);
             }
         }
     }
   gcry_sexp_release (s_sig);
 
   if (!sig_mpi)
     die ("no value in returned S-expression\n");
   err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &outbuf, &outlen, sig_mpi);
   if (err)
     die ("gcry_mpi_aprint failed: %s\n", gpg_strerror (err));
   gcry_mpi_release (sig_mpi);
 
   print_buffer (outbuf, outlen);
   gcry_free (outbuf);
 }
 
 
 
 /* Verify DATA of length DATALEN using the public key taken from the
    PEM encoded KEYFILE and the hash algorithm HASHALGO against the
    binary signature in SIGFILE.  */
 static void
 run_rsa_verify (const void *data, size_t datalen, int hashalgo, int pkcs1,
                 int pss, const char *keyfile, const char *sigfile)
 
 {
   gpg_error_t err;
   gcry_sexp_t s_data, s_key, s_sig;
 
   if (pkcs1)
     {
       unsigned char hash[64];
       unsigned int hashsize;
 
       hashsize = gcry_md_get_algo_dlen (hashalgo);
       if (!hashsize || hashsize > sizeof hash)
         die ("digest too long for buffer or unknown hash algorithm\n");
       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
       err = gcry_sexp_build (&s_data, NULL,
                              "(data (flags pkcs1)(hash %s %b))",
                              gcry_md_algo_name (hashalgo),
                              (int)hashsize, hash);
     }
   else if (pss)
     {
       unsigned char hash[64];
       unsigned int hashsize;
 
       hashsize = gcry_md_get_algo_dlen (hashalgo);
       if (!hashsize || hashsize > sizeof hash)
         die ("digest too long for buffer or unknown hash algorithm\n");
       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
       err = gcry_sexp_build (&s_data, NULL,
                              "(data (flags pss)(salt-length #00#)(hash %s %b))",
                              gcry_md_algo_name (hashalgo),
                              (int)hashsize, hash);
     }
   else
     {
       gcry_mpi_t tmp;
 
       err = gcry_mpi_scan (&tmp, GCRYMPI_FMT_USG, data, datalen,NULL);
       if (!err)
         {
           err = gcry_sexp_build (&s_data, NULL,
                                  "(data (flags raw)(value %m))", tmp);
           gcry_mpi_release (tmp);
         }
     }
   if (err)
     die ("gcry_sexp_build failed for RSA data input: %s\n",
          gpg_strerror (err));
 
   s_key = read_public_key_file (keyfile, 0);
 
   s_sig = read_sig_file (sigfile);
 
   err = gcry_pk_verify (s_sig, s_data, s_key);
   if (!err)
     puts ("GOOD signature");
   else if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
     puts ("BAD signature");
   else
     printf ("ERROR (%s)\n", gpg_strerror (err));
 
   gcry_sexp_release (s_sig);
   gcry_sexp_release (s_key);
   gcry_sexp_release (s_data);
 }
 
 
 
 /* Generate a DSA key of size KEYSIZE and return the complete
    S-expression.  */
 static gcry_sexp_t
 dsa_gen (int keysize)
 {
   gpg_error_t err;
   gcry_sexp_t keyspec, key;
 
   err = gcry_sexp_build (&keyspec, NULL,
                          "(genkey (dsa (nbits %d)(use-fips186-2)))",
                          keysize);
   if (err)
     die ("gcry_sexp_build failed for DSA key generation: %s\n",
          gpg_strerror (err));
 
   err = gcry_pk_genkey (&key, keyspec);
   if (err)
     die ("gcry_pk_genkey failed for DSA: %s\n", gpg_strerror (err));
 
   gcry_sexp_release (keyspec);
 
   return key;
 }
 
 
 /* Generate a DSA key of size KEYSIZE and return the complete
    S-expression.  */
 static gcry_sexp_t
 dsa_gen_with_seed (int keysize, const void *seed, size_t seedlen)
 {
   gpg_error_t err;
   gcry_sexp_t keyspec, key;
 
   err = gcry_sexp_build (&keyspec, NULL,
                          "(genkey"
                          "  (dsa"
                          "    (nbits %d)"
                          "    (use-fips186-2)"
                          "    (derive-parms"
                          "      (seed %b))))",
                          keysize, (int)seedlen, seed);
   if (err)
     die ("gcry_sexp_build failed for DSA key generation: %s\n",
          gpg_strerror (err));
 
   err = gcry_pk_genkey (&key, keyspec);
   if (err)
     die ("gcry_pk_genkey failed for DSA: %s\n", gpg_strerror (err));
 
   gcry_sexp_release (keyspec);
 
   return key;
 }
 
 
 /* Generate an ECDSA key on the specified curve and return the complete
    S-expression. */
 static gcry_sexp_t
 ecdsa_gen_key (const char *curve)
 {
   gpg_error_t err;
   gcry_sexp_t keyspec, key;
 
   err = gcry_sexp_build (&keyspec, NULL,
                          "(genkey"
                          "  (ecc"
                          "    (use-fips186)"
                          "    (curve %s)))",
                          curve);
   if (err)
     die ("gcry_sexp_build failed for ECDSA key generation: %s\n",
          gpg_strerror (err));
   err = gcry_pk_genkey (&key, keyspec);
   if (err)
     die ("gcry_pk_genkey failed for ECDSA: %s\n", gpg_strerror (err));
 
   gcry_sexp_release (keyspec);
 
   return key;
 }
 
 
 /* Print the domain parameter as well as the derive information.  KEY
    is the complete key as returned by dsa_gen.  We print to stdout
    with one parameter per line in hex format using this order: p, q,
    g, seed, counter, h. */
 static void
 print_dsa_domain_parameters (gcry_sexp_t key)
 {
   gcry_sexp_t l1, l2;
   gcry_mpi_t mpi;
   int idx;
   const void *data;
   size_t datalen;
   char *string;
 
   l1 = gcry_sexp_find_token (key, "public-key", 0);
   if (!l1)
     die ("public key not found in genkey result\n");
 
   l2 = gcry_sexp_find_token (l1, "dsa", 0);
   if (!l2)
     die ("returned public key not formed as expected\n");
   gcry_sexp_release (l1);
   l1 = l2;
 
   /* Extract the parameters from the S-expression and print them to stdout.  */
   for (idx=0; "pqg"[idx]; idx++)
     {
       l2 = gcry_sexp_find_token (l1, &"pqg"[idx], 1);
       if (!l2)
         die ("no %c parameter in returned public key\n", "pqg"[idx]);
       mpi = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
       if (!mpi)
         die ("no value for %c parameter in returned public key\n","pqg"[idx]);
       gcry_sexp_release (l2);
       if (standalone_mode)
         printf ("%c = ", "PQG"[idx]);
       print_mpi_line (mpi, 1);
       gcry_mpi_release (mpi);
     }
   gcry_sexp_release (l1);
 
   /* Extract the seed values.  */
   l1 = gcry_sexp_find_token (key, "misc-key-info", 0);
   if (!l1)
     die ("misc-key-info not found in genkey result\n");
 
   l2 = gcry_sexp_find_token (l1, "seed-values", 0);
   if (!l2)
     die ("no seed-values in returned key\n");
   gcry_sexp_release (l1);
   l1 = l2;
 
   l2 = gcry_sexp_find_token (l1, "seed", 0);
   if (!l2)
     die ("no seed value in returned key\n");
   data = gcry_sexp_nth_data (l2, 1, &datalen);
   if (!data)
     die ("no seed value in returned key\n");
   if (standalone_mode)
     printf ("Seed = ");
   print_data_line (data, datalen);
   gcry_sexp_release (l2);
 
   l2 = gcry_sexp_find_token (l1, "counter", 0);
   if (!l2)
     die ("no counter value in returned key\n");
   string = gcry_sexp_nth_string (l2, 1);
   if (!string)
     die ("no counter value in returned key\n");
   if (standalone_mode)
     printf ("c = %ld\n", strtoul (string, NULL, 10));
   else
     printf ("%lX\n", strtoul (string, NULL, 10));
   gcry_free (string);
   gcry_sexp_release (l2);
 
   l2 = gcry_sexp_find_token (l1, "h", 0);
   if (!l2)
     die ("no n value in returned key\n");
   mpi = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
   if (!mpi)
     die ("no h value in returned key\n");
   if (standalone_mode)
     printf ("H = ");
   print_mpi_line (mpi, 1);
   gcry_mpi_release (mpi);
   gcry_sexp_release (l2);
 
   gcry_sexp_release (l1);
 }
 
 
 /* Print public key Q (in octet-string format) and private key d.
    KEY is the complete key as returned by ecdsa_gen_key.
    with one parameter per line in hex format using this order: d, Q. */
 static void
 print_ecdsa_dq (gcry_sexp_t key)
 {
   gcry_sexp_t l1, l2;
   gcry_mpi_t mpi;
   int idx;
 
   l1 = gcry_sexp_find_token (key, "private-key", 0);
   if (!l1)
     die ("private key not found in genkey result\n");
 
   l2 = gcry_sexp_find_token (l1, "ecc", 0);
   if (!l2)
     die ("returned private key not formed as expected\n");
   gcry_sexp_release (l1);
   l1 = l2;
 
   /* Extract the parameters from the S-expression and print them to stdout.  */
   for (idx=0; "dq"[idx]; idx++)
     {
       l2 = gcry_sexp_find_token (l1, &"dq"[idx], 1);
       if (!l2)
         die ("no %c parameter in returned public key\n", "dq"[idx]);
       mpi = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
       if (!mpi)
         die ("no value for %c parameter in returned private key\n","dq"[idx]);
       gcry_sexp_release (l2);
       if (standalone_mode)
         printf ("%c = ", "dQ"[idx]);
       print_mpi_line (mpi, 1);
       gcry_mpi_release (mpi);
     }
 
   gcry_sexp_release (l1);
 }
 
 
 /* Generate DSA domain parameters for a modulus size of KEYSIZE.  The
    result is printed to stdout with one parameter per line in hex
    format and in this order: p, q, g, seed, counter, h.  If SEED is
    not NULL this seed value will be used for the generation.  */
 static void
 run_dsa_pqg_gen (int keysize, const void *seed, size_t seedlen)
 {
   gcry_sexp_t key;
 
   if (seed)
     key = dsa_gen_with_seed (keysize, seed, seedlen);
   else
     key = dsa_gen (keysize);
   print_dsa_domain_parameters (key);
   gcry_sexp_release (key);
 }
 
 
 /* Generate a DSA key of size of KEYSIZE and write the private key to
    FILENAME.  Also write the parameters to stdout in the same way as
    run_dsa_pqg_gen.  */
 static void
 run_dsa_gen (int keysize, const char *filename)
 {
   gcry_sexp_t key, private_key;
   FILE *fp;
 
   key = dsa_gen (keysize);
   private_key = gcry_sexp_find_token (key, "private-key", 0);
   if (!private_key)
     die ("private key not found in genkey result\n");
   print_dsa_domain_parameters (key);
 
   fp = fopen (filename, "wb");
   if (!fp)
     die ("can't create `%s': %s\n", filename, strerror (errno));
   print_sexp (private_key, fp);
   fclose (fp);
 
   gcry_sexp_release (private_key);
   gcry_sexp_release (key);
 }
 
 
 
 /* Sign DATA of length DATALEN using the key taken from the S-expression
    encoded KEYFILE. */
 static void
 run_dsa_sign (const void *data, size_t datalen, const char *keyfile)
 
 {
   gpg_error_t err;
   gcry_sexp_t s_data, s_key, s_sig, s_tmp, s_tmp2;
   char hash[20];
   gcry_mpi_t tmpmpi;
 
   gcry_md_hash_buffer (GCRY_MD_SHA1, hash, data, datalen);
   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, hash, 20, NULL);
   if (!err)
     {
       err = gcry_sexp_build (&s_data, NULL,
                              "(data (flags raw)(value %m))", tmpmpi);
       gcry_mpi_release (tmpmpi);
     }
   if (err)
     die ("gcry_sexp_build failed for DSA data input: %s\n",
          gpg_strerror (err));
 
   s_key = read_sexp_from_file (keyfile);
 
   err = gcry_pk_sign (&s_sig, s_data, s_key);
   if (err)
     {
       gcry_sexp_release (read_private_key_file (keyfile, 1));
       die ("gcry_pk_signed failed (datalen=%d,keyfile=%s): %s\n",
            (int)datalen, keyfile, gpg_strerror (err));
     }
   gcry_sexp_release (s_data);
 
   /* We need to return the Y parameter first.  */
   s_tmp = gcry_sexp_find_token (s_key, "private-key", 0);
   if (!s_tmp)
     die ("private key part not found in provided key\n");
 
   s_tmp2 = gcry_sexp_find_token (s_tmp, "dsa", 0);
   if (!s_tmp2)
     die ("private key part is not a DSA key\n");
   gcry_sexp_release (s_tmp);
 
   s_tmp = gcry_sexp_find_token (s_tmp2, "y", 0);
   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
   if (!tmpmpi)
     die ("no y parameter in DSA key\n");
   print_mpi_line (tmpmpi, 1);
   gcry_mpi_release (tmpmpi);
   gcry_sexp_release (s_tmp);
 
   gcry_sexp_release (s_key);
 
 
   /* Now return the actual signature.  */
   s_tmp = gcry_sexp_find_token (s_sig, "sig-val", 0);
   if (!s_tmp)
     die ("no sig-val element in returned S-expression\n");
 
   gcry_sexp_release (s_sig);
   s_sig = s_tmp;
   s_tmp = gcry_sexp_find_token (s_sig, "dsa", 0);
   if (!s_tmp)
     die ("no dsa element in returned S-expression\n");
 
   gcry_sexp_release (s_sig);
   s_sig = s_tmp;
 
   s_tmp = gcry_sexp_find_token (s_sig, "r", 0);
   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
   if (!tmpmpi)
     die ("no r parameter in returned S-expression\n");
   print_mpi_line (tmpmpi, 1);
   gcry_mpi_release (tmpmpi);
   gcry_sexp_release (s_tmp);
 
   s_tmp = gcry_sexp_find_token (s_sig, "s", 0);
   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
   if (!tmpmpi)
     die ("no s parameter in returned S-expression\n");
   print_mpi_line (tmpmpi, 1);
   gcry_mpi_release (tmpmpi);
   gcry_sexp_release (s_tmp);
 
   gcry_sexp_release (s_sig);
 }
 
 
 
 /* Verify DATA of length DATALEN using the public key taken from the
    S-expression in KEYFILE against the S-expression formatted
    signature in SIGFILE.  */
 static void
 run_dsa_verify (const void *data, size_t datalen,
                 const char *keyfile, const char *sigfile)
 
 {
   gpg_error_t err;
   gcry_sexp_t s_data, s_key, s_sig;
   char hash[20];
   gcry_mpi_t tmpmpi;
 
   gcry_md_hash_buffer (GCRY_MD_SHA1, hash, data, datalen);
   /* Note that we can't simply use %b with HASH to build the
      S-expression, because that might yield a negative value.  */
   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, hash, 20, NULL);
   if (!err)
     {
       err = gcry_sexp_build (&s_data, NULL,
                              "(data (flags raw)(value %m))", tmpmpi);
       gcry_mpi_release (tmpmpi);
     }
   if (err)
     die ("gcry_sexp_build failed for DSA data input: %s\n",
          gpg_strerror (err));
 
   s_key = read_sexp_from_file (keyfile);
   s_sig = read_sexp_from_file (sigfile);
 
   err = gcry_pk_verify (s_sig, s_data, s_key);
   if (!err)
     puts ("GOOD signature");
   else if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
     puts ("BAD signature");
   else
     printf ("ERROR (%s)\n", gpg_strerror (err));
 
   gcry_sexp_release (s_sig);
   gcry_sexp_release (s_key);
   gcry_sexp_release (s_data);
 }
 
 
 
 /* Sign DATA of length DATALEN using the key taken from the S-expression
    encoded KEYFILE. */
 static void
 run_ecdsa_sign (const void *data, size_t datalen,
                 const char *keyfile, const int algo)
 
 {
   gpg_error_t err;
   gcry_sexp_t s_data, s_key, s_sig, s_tmp;
   char hash[128];
   gcry_mpi_t tmpmpi;
 
   s_key = read_sexp_from_file (keyfile);
 
   gcry_md_hash_buffer (algo, hash, data, datalen);
   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, hash,
                        gcry_md_get_algo_dlen(algo), NULL);
   if (!err)
     {
       err = gcry_sexp_build (&s_data, NULL,
                              "(data (flags raw)(hash %s %M))",
                              gcry_md_algo_name(algo), tmpmpi);
       gcry_mpi_release (tmpmpi);
     }
   if (err)
     die ("gcry_sexp_build failed for ECDSA data input: %s\n",
          gpg_strerror (err));
 
   err = gcry_pk_sign (&s_sig, s_data, s_key);
   if (err)
     {
       die ("gcry_pk_signed failed: %s\n", gpg_strerror (err));
     }
   gcry_sexp_release (s_data);
   gcry_sexp_release (s_key);
 
   /* Now return the actual signature.  */
   s_tmp = gcry_sexp_find_token (s_sig, "sig-val", 0);
   if (!s_tmp)
     die ("no sig-val element in returned S-expression\n");
 
   gcry_sexp_release (s_sig);
   s_sig = s_tmp;
   s_tmp = gcry_sexp_find_token (s_sig, "ecdsa", 0);
   if (!s_tmp)
     die ("no ecdsa element in returned S-expression\n");
 
   gcry_sexp_release (s_sig);
   s_sig = s_tmp;
 
   s_tmp = gcry_sexp_find_token (s_sig, "r", 0);
   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
   if (!tmpmpi)
     die ("no r parameter in returned S-expression\n");
   print_mpi_line (tmpmpi, 1);
   gcry_mpi_release (tmpmpi);
   gcry_sexp_release (s_tmp);
 
   s_tmp = gcry_sexp_find_token (s_sig, "s", 0);
   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
   if (!tmpmpi)
     die ("no s parameter in returned S-expression\n");
   print_mpi_line (tmpmpi, 1);
   gcry_mpi_release (tmpmpi);
   gcry_sexp_release (s_tmp);
 
   gcry_sexp_release (s_sig);
 }
 
 
 
 /* Verify DATA of length DATALEN using the public key taken from the
    S-expression in KEYFILE against the S-expression formatted
    signature in SIGFILE.  */
 static void
 run_ecdsa_verify (const void *data, size_t datalen,
                 const char *keyfile, const int algo, const char *sigfile)
 
 {
   gpg_error_t err;
   gcry_sexp_t s_data, s_key, s_sig;
   char hash[128];
   gcry_mpi_t tmpmpi;
 
   s_key = read_sexp_from_file (keyfile);
 
   gcry_md_hash_buffer (algo, hash, data, datalen);
   /* Note that we can't simply use %b with HASH to build the
      S-expression, because that might yield a negative value.  */
   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, hash,
                        gcry_md_get_algo_dlen(algo), NULL);
   if (!err)
     {
       err = gcry_sexp_build (&s_data, NULL,
                              "(data (flags raw)(hash %s %M))",
                              gcry_md_algo_name(algo), tmpmpi);
       gcry_mpi_release (tmpmpi);
     }
   if (err)
     die ("gcry_sexp_build failed for DSA data input: %s\n",
          gpg_strerror (err));
 
   s_sig = read_sexp_from_file (sigfile);
 
   err = gcry_pk_verify (s_sig, s_data, s_key);
   if (!err)
     puts ("GOOD signature");
   else if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
     puts ("BAD signature");
   else
     printf ("ERROR (%s)\n", gpg_strerror (err));
 
   gcry_sexp_release (s_sig);
   gcry_sexp_release (s_key);
   gcry_sexp_release (s_data);
 }
 
 
 /* Generate an ECDSA key with specified domain parameters
    and print the d and Q values, in the standard octet-string format. */
 static void
 run_ecdsa_gen_key (const char *curve)
 {
   gcry_sexp_t key;
 
   key = ecdsa_gen_key (curve);
   print_ecdsa_dq (key);
 
   gcry_sexp_release (key);
 }
 
 
 
 static void
 usage (int show_help)
 {
   if (!show_help)
     {
       fputs ("usage: " PGM
              " [OPTION] [FILE] (try --help for more information)\n", stderr);
       exit (2);
     }
   fputs
     ("Usage: " PGM " [OPTIONS] MODE [FILE]\n"
      "Run a crypto operation using hex encoded input and output.\n"
      "MODE:\n"
      "  encrypt, decrypt, digest, random, hmac-sha,\n"
      "  rsa-{derive,gen,sign,verify},\n"
      "  dsa-{pqg-gen,gen,sign,verify}, ecdsa-{gen-key,sign,verify}\n"
      "OPTIONS:\n"
      "  --verbose        Print additional information\n"
      "  --binary         Input and output is in binary form\n"
      "  --no-fips        Do not force FIPS mode\n"
      "  --key KEY        Use the hex encoded KEY\n"
      "  --iv IV          Use the hex encoded IV\n"
      "  --dt DT          Use the hex encoded DT for the RNG\n"
      "  --algo NAME      Use algorithm NAME\n"
      "  --curve NAME     Select ECC curve spec NAME\n"
      "  --keysize N      Use a keysize of N bits\n"
      "  --signature NAME Take signature from file NAME\n"
      "  --chunk N        Read in chunks of N bytes (implies --binary)\n"
      "  --pkcs1          Use PKCS#1 encoding\n"
      "  --pss            Use PSS encoding with a zero length salt\n"
      "  --mct-server     Run a monte carlo test server\n"
      "  --loop           Enable random loop mode\n"
      "  --progress       Print pogress indicators\n"
      "  --help           Print this text\n"
      "With no FILE, or when FILE is -, read standard input.\n"
      "Report bugs to " PACKAGE_BUGREPORT ".\n" , stdout);
   exit (0);
 }
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   gpg_error_t err;
   int no_fips = 0;
   int progress = 0;
   int use_pkcs1 = 0;
   int use_pss = 0;
   const char *mode_string;
   const char *curve_string = NULL;
   const char *key_string = NULL;
   const char *iv_string = NULL;
   const char *dt_string = NULL;
   const char *algo_string = NULL;
   const char *keysize_string = NULL;
   const char *signature_string = NULL;
   FILE *input;
   void *data;
   size_t datalen;
   size_t chunksize = 0;
   int mct_server = 0;
 
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           usage (1);
         }
       else if (!strcmp (*argv, "--version"))
         {
           fputs (PGM " (Libgcrypt) " PACKAGE_VERSION "\n", stdout);
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--binary"))
         {
           binary_input = binary_output = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--no-fips"))
         {
           no_fips++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--loop"))
         {
           loop_mode = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--progress"))
         {
           progress = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--key"))
         {
           argc--; argv++;
           if (!argc)
             usage (0);
           key_string = *argv;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--iv"))
         {
           argc--; argv++;
           if (!argc)
             usage (0);
           iv_string = *argv;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--dt"))
         {
           argc--; argv++;
           if (!argc)
             usage (0);
           dt_string = *argv;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--algo"))
         {
           argc--; argv++;
           if (!argc)
             usage (0);
           algo_string = *argv;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--keysize"))
         {
           argc--; argv++;
           if (!argc)
             usage (0);
           keysize_string = *argv;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--signature"))
         {
           argc--; argv++;
           if (!argc)
             usage (0);
           signature_string = *argv;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--chunk"))
         {
           argc--; argv++;
           if (!argc)
             usage (0);
           chunksize = atoi (*argv);
           binary_input = binary_output = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--curve"))
         {
           argc--; argv++;
           if (!argc)
             usage (0);
           curve_string = *argv;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--pkcs1"))
         {
           use_pkcs1 = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--pss"))
         {
           use_pss = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--mct-server"))
         {
           mct_server = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--standalone"))
         {
           standalone_mode = 1;
           argc--; argv++;
         }
     }
 
   if (!argc || argc > 2)
     usage (0);
 
   mode_string = *argv;
 
   if (use_pkcs1 && use_pss)
     die ("Only one of --pkcs or --pss may be given\n");
 
   if (!strcmp (mode_string, "rsa-derive"))
     binary_input = 1;
 
   if (argc == 2 && strcmp (argv[1], "-"))
     {
       input = fopen (argv[1], binary_input? "rb":"r");
       if (!input)
         die ("can't open `%s': %s\n", argv[1], strerror (errno));
     }
   else
     input = stdin;
 
 #ifndef HAVE_W32_SYSTEM
   if (loop_mode)
     signal (SIGPIPE, SIG_IGN);
 #endif
 
   if (verbose)
     fprintf (stderr, PGM ": started (mode=%s)\n", mode_string);
 
-  xgcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
+  xgcry_control ((GCRYCTL_SET_VERBOSITY, (int)verbose));
   if (!no_fips)
-    xgcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
+    xgcry_control ((GCRYCTL_FORCE_FIPS_MODE, 0));
   if (!gcry_check_version ("1.4.3"))
     die ("Libgcrypt is not sufficient enough\n");
   if (verbose)
     fprintf (stderr, PGM ": using Libgcrypt %s\n", gcry_check_version (NULL));
   if (no_fips)
-    xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+    xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   /* Most operations need some input data.  */
   if (!chunksize
       && !mct_server
       && strcmp (mode_string, "random")
       && strcmp (mode_string, "rsa-gen")
       && strcmp (mode_string, "rsa-keygen")
       && strcmp (mode_string, "rsa-keygen-kat")
       && strcmp (mode_string, "dsa-gen")
       && strcmp (mode_string, "ecdsa-gen-key") )
     {
       data = read_file (input, !binary_input, &datalen);
       if (!data)
         die ("error reading%s input\n", binary_input?"":" and decoding");
       if (verbose)
         fprintf (stderr, PGM ": %u bytes of input data\n",
                  (unsigned int)datalen);
     }
   else
     {
       data = NULL;
       datalen = 0;
     }
 
 
   if (!strcmp (mode_string, "encrypt") || !strcmp (mode_string, "decrypt"))
     {
       int cipher_algo, cipher_mode;
       void  *iv_buffer = NULL;
       void *key_buffer = NULL;
       size_t iv_buflen,  key_buflen;
 
       if (!algo_string)
         die ("option --algo is required in this mode\n");
       cipher_algo = map_openssl_cipher_name (algo_string, &cipher_mode);
       if (!cipher_algo)
         die ("cipher algorithm `%s' is not supported\n", algo_string);
       if (mct_server)
         {
           int iterations;
 
           for (;;)
             {
               gcry_free (key_buffer); key_buffer = NULL;
               gcry_free (iv_buffer); iv_buffer = NULL;
               gcry_free (data); data = NULL;
               if (!(key_buffer = read_textline (input)))
                 {
                   if (feof (input))
                     break;
                   die ("no version info in input\n");
                 }
               if (atoi (key_buffer) != 1)
                 die ("unsupported input version %s\n",
                      (const char*)key_buffer);
               gcry_free (key_buffer);
               if (!(key_buffer = read_textline (input)))
                 die ("no iteration count in input\n");
               iterations = atoi (key_buffer);
               gcry_free (key_buffer);
               if (!(key_buffer = read_hexline (input, &key_buflen)))
                 die ("no key in input\n");
               if (!(iv_buffer = read_hexline (input, &iv_buflen)))
                 die ("no IV in input\n");
               if (!(data = read_hexline (input, &datalen)))
                 die ("no data in input\n");
               skip_to_empty_line (input);
 
               run_cipher_mct_loop ((*mode_string == 'e'),
                                    cipher_algo, cipher_mode,
                                    iv_buffer, iv_buflen,
                                    key_buffer, key_buflen,
                                    data, datalen, iterations);
             }
         }
       else
         {
           if (cipher_mode != GCRY_CIPHER_MODE_ECB)
             {
               if (!iv_string)
                 die ("option --iv is required in this mode\n");
               iv_buffer = hex2buffer (iv_string, &iv_buflen);
               if (!iv_buffer)
                 die ("invalid value for IV\n");
             }
           else
             {
               iv_buffer = NULL;
               iv_buflen = 0;
             }
           if (!key_string)
             die ("option --key is required in this mode\n");
           key_buffer = hex2buffer (key_string, &key_buflen);
           if (!key_buffer)
             die ("invalid value for KEY\n");
 
           run_encrypt_decrypt ((*mode_string == 'e'),
                                cipher_algo, cipher_mode,
                                iv_buffer, iv_buflen,
                                key_buffer, key_buflen,
                                data, data? datalen:chunksize, input);
         }
       gcry_free (key_buffer);
       gcry_free (iv_buffer);
     }
   else if (!strcmp (mode_string, "digest"))
     {
       int algo;
 
       if (!algo_string)
         die ("option --algo is required in this mode\n");
       algo = gcry_md_map_name (algo_string);
       if (!algo)
         die ("digest algorithm `%s' is not supported\n", algo_string);
       if (!data)
         die ("no data available (do not use --chunk)\n");
 
       run_digest (algo, data, datalen);
     }
   else if (!strcmp (mode_string, "random"))
     {
       void *context;
       unsigned char key[16];
       unsigned char seed[16];
       unsigned char dt[16];
       unsigned char buffer[16];
       size_t count = 0;
 
       if (!key_string || hex2bin (key_string, key, 16) < 0 )
         die ("value for --key are not 32 hex digits\n");
       if (!iv_string || hex2bin (iv_string, seed, 16) < 0 )
         die ("value for --iv are not 32 hex digits\n");
       if (!dt_string || hex2bin (dt_string, dt, 16) < 0 )
         die ("value for --dt are not 32 hex digits\n");
 
       /* The flag value 1 disables the dup check, so that the RNG
          returns all generated data.  */
       err = init_external_rng_test (&context, 1, key, 16, seed, 16, dt, 16);
       if (err)
         die ("init external RNG test failed: %s\n", gpg_strerror (err));
 
       do
         {
           err = run_external_rng_test (context, buffer, sizeof buffer);
           if (err)
             die ("running external RNG test failed: %s\n", gpg_strerror (err));
           print_buffer (buffer, sizeof buffer);
           if (progress)
             {
               if (!(++count % 1000))
                 fprintf (stderr, PGM ": %lu random bytes so far\n",
                          (unsigned long int)(count * sizeof buffer));
             }
         }
       while (loop_mode);
 
       if (progress)
         fprintf (stderr, PGM ": %lu random bytes\n",
                  (unsigned long int)(count * sizeof buffer));
 
       deinit_external_rng_test (context);
     }
   else if (!strcmp (mode_string, "hmac-sha"))
     {
       int algo;
       void  *key_buffer;
       size_t key_buflen;
 
       if (!data)
         die ("no data available (do not use --chunk)\n");
       if (!algo_string)
         die ("option --algo is required in this mode\n");
       switch (atoi (algo_string))
         {
         case 1:   algo = GCRY_MD_SHA1; break;
         case 224: algo = GCRY_MD_SHA224; break;
         case 256: algo = GCRY_MD_SHA256; break;
         case 384: algo = GCRY_MD_SHA384; break;
         case 512: algo = GCRY_MD_SHA512; break;
         default:  algo = 0; break;
         }
       if (!algo)
         die ("no digest algorithm found for hmac type `%s'\n", algo_string);
       if (!key_string)
         die ("option --key is required in this mode\n");
       key_buffer = hex2buffer (key_string, &key_buflen);
       if (!key_buffer)
         die ("invalid value for KEY\n");
 
       run_hmac (algo, key_buffer, key_buflen, data, datalen);
 
       gcry_free (key_buffer);
     }
   else if (!strcmp (mode_string, "rsa-derive"))
     {
       if (!data)
         die ("no data available (do not use --chunk)\n");
       run_rsa_derive (data, datalen);
     }
   else if (!strcmp (mode_string, "rsa-keygen"))
     {
       data = read_file (input, 0, &datalen);
       if (!data)
         die ("no data available (do not use --chunk)\n");
       run_rsa_keygen (data, datalen, 0);
     }
   else if (!strcmp (mode_string, "rsa-keygen-kat"))
     {
       data = read_file (input, 0, &datalen);
       if (!data)
         die ("no data available (do not use --chunk)\n");
       run_rsa_keygen (data, datalen, 1);
     }
   else if (!strcmp (mode_string, "rsa-gen"))
     {
       int keysize;
 
       if (!binary_output)
         base64_output = 1;
 
       keysize = keysize_string? atoi (keysize_string) : 0;
       if (keysize < 128 || keysize > 16384)
         die ("invalid keysize specified; needs to be 128 .. 16384\n");
       run_rsa_gen (keysize, 65537);
     }
   else if (!strcmp (mode_string, "rsa-sign"))
     {
       int algo;
 
       if (!key_string)
         die ("option --key is required in this mode\n");
       if (access (key_string, R_OK))
         die ("option --key needs to specify an existing keyfile\n");
       if (!algo_string)
         die ("option --algo is required in this mode\n");
       algo = gcry_md_map_name (algo_string);
       if (!algo)
         die ("digest algorithm `%s' is not supported\n", algo_string);
       if (!data)
         die ("no data available (do not use --chunk)\n");
 
       run_rsa_sign (data, datalen, algo, use_pkcs1, use_pss, key_string);
 
     }
   else if (!strcmp (mode_string, "rsa-verify"))
     {
       int algo;
 
       if (!key_string)
         die ("option --key is required in this mode\n");
       if (access (key_string, R_OK))
         die ("option --key needs to specify an existing keyfile\n");
       if (!algo_string)
         die ("option --algo is required in this mode\n");
       algo = gcry_md_map_name (algo_string);
       if (!algo)
         die ("digest algorithm `%s' is not supported\n", algo_string);
       if (!data)
         die ("no data available (do not use --chunk)\n");
       if (!signature_string)
         die ("option --signature is required in this mode\n");
       if (access (signature_string, R_OK))
         die ("option --signature needs to specify an existing file\n");
 
       run_rsa_verify (data, datalen, algo, use_pkcs1, use_pss, key_string,
                       signature_string);
 
     }
   else if (!strcmp (mode_string, "dsa-pqg-gen"))
     {
       int keysize;
 
       keysize = keysize_string? atoi (keysize_string) : 0;
       if (keysize < 1024 || keysize > 3072)
         die ("invalid keysize specified; needs to be 1024 .. 3072\n");
       run_dsa_pqg_gen (keysize, datalen? data:NULL, datalen);
     }
   else if (!strcmp (mode_string, "dsa-gen"))
     {
       int keysize;
 
       keysize = keysize_string? atoi (keysize_string) : 0;
       if (keysize < 1024 || keysize > 3072)
         die ("invalid keysize specified; needs to be 1024 .. 3072\n");
       if (!key_string)
         die ("option --key is required in this mode\n");
       run_dsa_gen (keysize, key_string);
     }
   else if (!strcmp (mode_string, "dsa-sign"))
     {
       if (!key_string)
         die ("option --key is required in this mode\n");
       if (access (key_string, R_OK))
         die ("option --key needs to specify an existing keyfile\n");
       if (!data)
         die ("no data available (do not use --chunk)\n");
 
       run_dsa_sign (data, datalen, key_string);
     }
   else if (!strcmp (mode_string, "dsa-verify"))
     {
       if (!key_string)
         die ("option --key is required in this mode\n");
       if (access (key_string, R_OK))
         die ("option --key needs to specify an existing keyfile\n");
       if (!data)
         die ("no data available (do not use --chunk)\n");
       if (!signature_string)
         die ("option --signature is required in this mode\n");
       if (access (signature_string, R_OK))
         die ("option --signature needs to specify an existing file\n");
 
       run_dsa_verify (data, datalen, key_string, signature_string);
     }
   else if (!strcmp (mode_string, "ecdsa-gen-key"))
     {
       if (!curve_string)
         die ("option --curve containing name of the specified curve is required in this mode\n");
       run_ecdsa_gen_key (curve_string);
     }
   else if (!strcmp (mode_string, "ecdsa-sign"))
     {
       int algo;
 
       if (!key_string)
         die ("option --key is required in this mode\n");
       if (access (key_string, R_OK))
         die ("option --key needs to specify an existing keyfile\n");
       if (!algo_string)
         die ("use --algo to specify the digest algorithm\n");
       algo = gcry_md_map_name (algo_string);
       if (!algo)
         die ("digest algorithm `%s' is not supported\n", algo_string);
 
       if (!data)
         die ("no data available (do not use --chunk)\n");
 
       run_ecdsa_sign (data, datalen, key_string, algo);
     }
   else if (!strcmp (mode_string, "ecdsa-verify"))
     {
       int algo;
 
       if (!key_string)
         die ("option --key is required in this mode\n");
       if (access (key_string, R_OK))
         die ("option --key needs to specify an existing keyfile\n");
       if (!algo_string)
         die ("use --algo to specify the digest algorithm\n");
       algo = gcry_md_map_name (algo_string);
       if (!algo)
         die ("digest algorithm `%s' is not supported\n", algo_string);
       if (!data)
         die ("no data available (do not use --chunk)\n");
       if (!signature_string)
         die ("option --signature is required in this mode\n");
       if (access (signature_string, R_OK))
         die ("option --signature needs to specify an existing file\n");
 
       run_ecdsa_verify (data, datalen, key_string, algo, signature_string);
     }
   else
     usage (0);
 
   gcry_free (data);
 
   /* Because Libgcrypt does not enforce FIPS mode in all cases we let
      the process die if Libgcrypt is not anymore in FIPS mode after
      the actual operation.  */
   if (!no_fips && !gcry_fips_mode_active ())
     die ("FIPS mode is not anymore active\n");
 
   if (verbose)
     fputs (PGM ": ready\n", stderr);
 
   return 0;
 }
diff --git a/tests/fipsrngdrv.c b/tests/fipsrngdrv.c
index d6023c7f..17cc9204 100644
--- a/tests/fipsrngdrv.c
+++ b/tests/fipsrngdrv.c
@@ -1,271 +1,271 @@
 /* fipsrngdrv.c  -  A driver to test the FIPS RNG.
    Copyright (C) 2008 Free Software Foundation, Inc.
 
    This file is part of Libgcrypt.
 
    Libgcrypt is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2.1 of
    the License, or (at your option) any later version.
 
    Libgcrypt is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <errno.h>
 #include <ctype.h>
 #ifndef HAVE_W32_SYSTEM
 # include <signal.h>
 #endif
 
 #include <gcrypt.h>
 
 #define PGM "fipsrngdrv"
 
 #define my_isascii(c) (!((c) & 0x80))
 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
 #define hexdigitp(a) (digitp (a)                     \
                       || (*(a) >= 'A' && *(a) <= 'F')  \
                       || (*(a) >= 'a' && *(a) <= 'f'))
 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
 
 
 static void
 die (const char *format, ...)
 {
   va_list arg_ptr;
 
   va_start (arg_ptr, format);
   fputs (PGM ": ", stderr);
   vfprintf (stderr, format, arg_ptr);
   va_end (arg_ptr);
   exit (1);
 }
 
 
 /* Convert STRING consisting of hex characters into its binary
    representation and store that at BUFFER.  BUFFER needs to be of
    LENGTH bytes.  The function checks that the STRING will convert
    exactly to LENGTH bytes. The string is delimited by either end of
    string or a white space character.  The function returns -1 on
    error or the length of the parsed string.  */
 static int
 hex2bin (const char *string, void *buffer, size_t length)
 {
   int i;
   const char *s = string;
 
   for (i=0; i < length; )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         return -1;           /* Invalid hex digits. */
       ((unsigned char*)buffer)[i++] = xtoi_2 (s);
       s += 2;
     }
   if (*s && (!my_isascii (*s) || !isspace (*s)) )
     return -1;             /* Not followed by Nul or white space.  */
   if (i != length)
     return -1;             /* Not of expected length.  */
   if (*s)
     s++; /* Skip the delimiter. */
   return s - string;
 }
 
 
 
 
 static gcry_error_t
 init_external_test (void **r_context,
                     unsigned int flags,
                     const void *key, size_t keylen,
                     const void *seed, size_t seedlen,
                     const void *dt, size_t dtlen)
 {
   return gcry_control (58,
                        r_context, flags,
                        key, keylen,
                        seed, seedlen,
                        dt, dtlen);
 }
 
 static gcry_error_t
 run_external_test (void *context, void *buffer, size_t buflen)
 {
   return gcry_control (59, context, buffer, buflen);
 }
 
 static void
 deinit_external_test (void *context)
 {
-  xgcry_control (60, context);
+  xgcry_control ((60, context));
 }
 
 
 static void
 print_buffer (const unsigned char *buffer, size_t length)
 {
   while (length--)
     printf ("%02X", *buffer++);
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   int verbose = 0;
   int binary = 0;
   int loop = 0;
   int progress = 0;
   int no_fips = 0;
   unsigned char key[16];
   unsigned char seed[16];
   unsigned char dt[16];
   void *context;
   gpg_error_t err;
   unsigned char buffer[16];
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           fputs ("usage: " PGM
                  " [--verbose] [--binary] [--loop] [--progress] KEY V DT\n",
                  stdout);
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--no-fips"))
         {
           no_fips++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--binary"))
         {
           binary = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--loop"))
         {
           loop = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--progress"))
         {
           progress = 1;
           argc--; argv++;
         }
     }
 
   if (!argc)
     {
       memcpy (key,  "1234567890123456", 16);
       memcpy (seed, "abcdefghijklmnop", 16);
       memcpy (dt,   "XXXXXXXXXXXXXXXX", 16);
     }
   else if (argc == 3)
     {
       if (    hex2bin (argv[0], key, 16) < 0
            || hex2bin (argv[1], seed, 16) < 0
            || hex2bin (argv[2], dt, 16) < 0 )
         die ("args are not 32 hex digits each\n");
     }
   else
     die ("invalid usage (try --help)\n");
 
 #ifndef HAVE_W32_SYSTEM
   if (loop)
     signal (SIGPIPE, SIG_IGN);
 #endif
 
   if (verbose)
     fputs (PGM ": started\n", stderr);
 
-  xgcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
+  xgcry_control ((GCRYCTL_SET_VERBOSITY, (int)verbose));
   if (!no_fips)
-    xgcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
+    xgcry_control ((GCRYCTL_FORCE_FIPS_MODE, 0));
   if (!gcry_check_version ("1.4.3"))
     die ("version mismatch\n");
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   /* The flag value 1 disables the dup check, so that the RNG returns
      all generated data.  */
   err = init_external_test (&context, 1, key, 16, seed, 16, dt, 16);
   if (err)
     die ("init external test failed: %s\n", gpg_strerror (err));
 
   do
     {
       int writerr = 0;
 
       err = run_external_test (context, buffer, sizeof buffer);
       if (err)
         die ("run external test failed: %s\n", gpg_strerror (err));
       if (binary)
         {
           if (fwrite (buffer, 16, 1, stdout) != 1)
             writerr = 1;
           else
             fflush (stdout);
         }
       else
         {
           print_buffer (buffer, sizeof buffer);
           if (putchar ('\n') == EOF)
             writerr = 1;
         }
       if (writerr)
         {
 #ifndef HAVE_W32_SYSTEM
           if (loop && errno == EPIPE)
             break;
 #endif
           die ("writing output failed: %s\n", strerror (errno));
         }
 
       if (progress)
         {
           putc ('.', stderr);
           fflush (stderr);
         }
     }
   while (loop);
 
   if (progress)
     putc ('\n', stderr);
 
   deinit_external_test (context);
 
   if (verbose)
     fputs (PGM ": ready\n", stderr);
 
   return 0;
 }
diff --git a/tests/gchash.c b/tests/gchash.c
index 83dc7b55..43ce53ba 100644
--- a/tests/gchash.c
+++ b/tests/gchash.c
@@ -1,123 +1,123 @@
 /* gchash.c - Calculate hash values
  * Copyright (C) 2013 Dmitry Eremin-Solenikov
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
 
 #ifdef _GCRYPT_IN_LIBGCRYPT
 # undef _GCRYPT_IN_LIBGCRYPT
 # include "gcrypt.h"
 #else
 # include <gcrypt.h>
 #endif
 
 #define PGM "gchash"
 #include "t-common.h"
 
 
 void
 init_gcrypt (void)
 {
   if (!gcry_check_version (GCRYPT_VERSION)) {
     fputs ("libgcrypt version mismatch\n", stderr);
     exit (2);
   }
 
-  xgcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
+  xgcry_control ((GCRYCTL_SUSPEND_SECMEM_WARN));
 
   /* Allocate a pool of 16k secure memory.  This make the secure memory
    * available and also drops privileges where needed.  */
-  xgcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
+  xgcry_control ((GCRYCTL_INIT_SECMEM, 16384, 0));
 
-  xgcry_control (GCRYCTL_RESUME_SECMEM_WARN);
+  xgcry_control ((GCRYCTL_RESUME_SECMEM_WARN));
 
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 }
 
 int
 main (int argc, char **argv)
 {
   gcry_md_hd_t hd;
   gcry_error_t err;
   int algo;
 
   init_gcrypt();
 
   if (argc < 2 || (argv[1] && !strcmp(argv[1], "--help")))
     {
       fprintf (stderr, "Usage: %s <digest> <file>...\n", argv[0]);
       return 1;
     }
 
   algo = gcry_md_map_name (argv[1]);
   if (algo == GCRY_MD_NONE)
     {
       fprintf (stderr, "Unknown algorithm '%s'\n", argv[1]);
       return 1;
     }
 
   err = gcry_md_open(&hd, algo, 0);
   if (err)
     {
       fprintf (stderr, "LibGCrypt error %s/%s\n",
           gcry_strsource (err),
           gcry_strerror (err));
       exit (1);
     }
 
   for (argv += 2; *argv; argv++)
     {
       FILE *fp;
       unsigned char buf[1024];
       size_t size;
       int i;
       unsigned char *h;
       if (!strcmp (*argv, "-"))
         fp = stdin;
       else
         fp = fopen (*argv, "r");
 
       if (fp == NULL)
         {
           perror ("fopen");
           return 1;
         }
 
       while (!feof (fp))
         {
           size = fread (buf, 1, sizeof(buf), fp);
           gcry_md_write (hd, buf, size);
         }
 
       h  = gcry_md_read(hd, 0);
 
       for (i = 0; i < gcry_md_get_algo_dlen (algo); i++)
         printf("%02x", h[i]);
       printf("  %s\n", *argv);
 
       gcry_md_reset(hd);
     }
 
   gcry_md_close(hd);
   return 0;
 }
diff --git a/tests/hashtest.c b/tests/hashtest.c
index 33945949..4c9704f3 100644
--- a/tests/hashtest.c
+++ b/tests/hashtest.c
@@ -1,451 +1,451 @@
 /* hashtest.c - Check the hash functions
  * Copyright (C) 2013 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdarg.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 
 #include "../src/gcrypt-int.h"
 
 #include "stopwatch.h"
 
 #define PGM "hashtest"
 #include "t-common.h"
 
 static int missing_test_vectors;
 
 static struct {
   int algo;
   int gigs;
   int bytes;
   const char *hex;
 } testvectors[] = {
   { GCRY_MD_SHA1, 256, -64, "92fc51850c7b750e6e774b75f294f6979d4059f0" },
   { GCRY_MD_SHA1, 256,  -1, "4bddeeb4c08683f02d4944d93dbcb02ebab50134" },
   { GCRY_MD_SHA1, 256,  -0, "71b923afde1c8c040884c723a2e3335b333e64c6" },
   { GCRY_MD_SHA1, 256,   1, "2d99f9b5b86e9c9c937104f4242bd6b8bc0927ef" },
   { GCRY_MD_SHA1, 256,  64, "a60dabe8d749f798b7ec3a684cc3eab487451482" },
 
   { GCRY_MD_SHA224, 256, -64,
     "b5672b54d2480a5688a2dc727a1ad4db7a81ef31ce8999e0bbaeffdc" },
   { GCRY_MD_SHA224, 256,  -1,
     "814ea7159473e6ffc1c64b90026a542e13ac6980f7f3ca3c4582a9b8" },
   { GCRY_MD_SHA224, 256,   0,
     "9ec0e1829455db8650ec7a8b06912196f97a7358bc3a73c79911cd4e" },
   { GCRY_MD_SHA224, 256,   1,
     "e578d5d523320876565bbbc892511a485427caee6dd754d57e3e58c2" },
   { GCRY_MD_SHA224, 256,  64,
     "ff0464df248cd298b63765bc4f87f21e25c93c657fdf3656d3c878e5" },
 
   { GCRY_MD_SHA256, 256, -64,
     "87a9828d3de78d55d252341db2a622908c4e0ceaee9961ecf9768700fc799ec8" },
   { GCRY_MD_SHA256, 256,  -1,
     "823bf95f64ef04a4a77579c38760b1d401b56bf3a8e664bdf56ca15afb468a03" },
   { GCRY_MD_SHA256, 256,   0,
     "2d0723878cb2c3d5c59dfad910cdb857f4430a6ba2a7d687938d7a20e63dde47" },
   { GCRY_MD_SHA256, 256,   1,
     "5a2e21b1e79cd866acf53a2a18ca76bd4e02c4b01bf4627354171824c812d95f" },
   { GCRY_MD_SHA256, 256,  64,
     "34444808af8e9d995e67f9e155ed94bf55f195a51dc1d8a989e6bcf95511c8a2" },
 
   { GCRY_MD_SHA512, 256, -64,
     "e01bf8140874bf240e8426cb2bcbc377cbed2e6037334116637149e1cd8cd462"
     "96828b71f32b9f002771d4cb51172ce578b73b7939221e4df655ecd08601e655" },
   { GCRY_MD_SHA512, 256,  -1,
     "4917ff94514b1757705c289fdc3e7d6ffcce5771b20ae237ebc03d2ec9eb435f"
     "b7ce9f0e27272be8cced77a5edae1a01a0ad62b0a44169d88bbee45474a17734" },
   { GCRY_MD_SHA512, 256,   0,
     "1e28e8b3c79f2f47da11f3c0b7da4e7981e7d932db6d17d528a31e191922edda"
     "8fc4bb2df10ea876232db5a1c606bc41886e8b2c570a3e721221f60c8c7dc4ab" },
   { GCRY_MD_SHA512, 256,   1,
     "027d3324dd1cf127770ceb53681f4c70937c9bca4e3acd5fd76cb266c7d4527d"
     "58140290a1822e8d60c4d3ae9725fb923183230d6dfd2d7d73c0d74a4757f34a" },
   { GCRY_MD_SHA512, 256,  64,
     "49920704ea9d6ee19f0742d6c868110fa3eda8ac09f026e9ef22cc731af53020"
     "de40eedef66cb1afd94c61e285fa9327e01336e804903740a9145ab1f065c2d5" },
 
   { GCRY_MD_SHA3_512, 256, -64,
     "c6e082b3db996dbe5f2c5709818a7f325ef4febd883d7e9c545c06bfa7225198"
     "1ecf40103788913cd5a5bdf13246b952ded6651043684b24197eb23544882a97" },
   { GCRY_MD_SHA3_512, 256,  -1,
     "d7bf28e8216bf7d3d0d3969e34078e94b98598e17b6f21f256379389e4eba8ee"
     "74eb288774797263fec00bdfd357d132cea9e408be36b982f5a60ab56ad01613" },
   { GCRY_MD_SHA3_512, 256,  +0,
     "c1270852ba7b1e1a3eaa777969b8a65be28c3894537c61eb8cd22b1df6af703d"
     "b59939f6adadeb64317faece8167d4817e73daf73e28a5ccd26bebee0a35c322" },
   { GCRY_MD_SHA3_512, 256,  +1,
     "8bdfeb3a1a9a1cdcef21172cbc5bb3b87c0d8f7111df0aaf7f1bc03ad4775bd6"
     "a03e0a875c4e7d02d2230c213562c6a57be28d92eaf6e4bea4bc24690454c8ef" },
   { GCRY_MD_SHA3_512, 256, +64,
     "0c91b91665ceaf7af5102e0ed31aa4f050668ab3c57b1f4763946d567efe66b3"
     "ab9a2016cf238dee5b44eae9f0cdfbf7b7a6eb1e759986273243dc35894706b6" },
 
   { GCRY_MD_SM3, 256, -64,
     "4ceb893abeb43965d4cac7626da9a4be895585b5b2f16f302626801308b1c02a" },
   { GCRY_MD_SM3, 256, -1,
     "825f01e4f2b6084136abc356fa1b343a9411d844a4dc1474293aad817cd2a48f" },
   { GCRY_MD_SM3, 256, +0,
     "d948a4025ac3ea0aa8989f43203411bd22ad17eaa5fd92ebdf9cabf869f1ba1b" },
   { GCRY_MD_SM3, 256, +1,
     "4f6d0e260299c1f286ef1dbb4638a0770979f266b6c007c55410ee6849cba2a8" },
   { GCRY_MD_SM3, 256, +64,
     "ed34869dbadd62e3bec1f511004d7bbfc9cafa965477cc48843b248293bbe867" },
 
   { 0 }
 };
 
 
 static void
 showhex (const void *buffer, size_t buflen, const char *format, ...)
 {
   va_list arg_ptr;
   const unsigned char *s;
 
   fprintf (stderr, "%s: ", PGM);
   va_start (arg_ptr, format);
   vfprintf (stderr, format, arg_ptr);
   va_end (arg_ptr);
 
   for (s=buffer; buflen; buflen--, s++)
     fprintf (stderr, "%02x", *s);
   putc ('\n', stderr);
 }
 
 
 static void
 show_note (const char *format, ...)
 {
   va_list arg_ptr;
 
   if (!verbose && getenv ("srcdir"))
     fputs ("      ", stderr);  /* To align above "PASS: ".  */
   else
     fprintf (stderr, "%s: ", PGM);
   va_start (arg_ptr, format);
   vfprintf (stderr, format, arg_ptr);
   if (*format && format[strlen(format)-1] != '\n')
     putc ('\n', stderr);
   va_end (arg_ptr);
 }
 
 /* Convert STRING consisting of hex characters into its binary
    representation and return it as an allocated buffer. The valid
    length of the buffer is returned at R_LENGTH.  The string is
    delimited by end of string.  The function returns NULL on
    error.  */
 static void *
 hex2buffer (const char *string, size_t *r_length)
 {
   const char *s;
   unsigned char *buffer;
   size_t length;
 
   buffer = xmalloc (strlen(string)/2+1);
   length = 0;
   for (s=string; *s; s +=2 )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         return NULL;           /* Invalid hex digits. */
       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     }
   *r_length = length;
   return buffer;
 }
 
 
 static void
 run_selftest (int algo)
 {
   gpg_error_t err;
   size_t n;
 
   n = 1;
   err = gcry_md_algo_info (algo, GCRYCTL_SELFTEST, NULL, &n);
   if (err && gpg_err_code (err) != GPG_ERR_NOT_IMPLEMENTED)
     fail ("extended selftest for %s (%d) failed: %s",
           gcry_md_algo_name (algo), algo, gpg_strerror (err));
   else if (err && verbose)
     info ("extended selftest for %s (%d) not implemented",
           gcry_md_algo_name (algo), algo);
   else if (verbose)
     info ("extended selftest for %s (%d) passed",
           gcry_md_algo_name (algo), algo);
 }
 
 /* Compare DIGEST of length DIGESTLEN generated using ALGO and GIGS
    plus BYTES with the test vector and print an error message if the
    don't match.  Return 0 on match.  */
 static int
 cmp_digest (const unsigned char *digest, size_t digestlen,
             int algo, int gigs, int bytes)
 {
   int idx;
   unsigned char *tv_digest;
   size_t tv_digestlen = 0;
 
   for (idx=0; testvectors[idx].algo; idx++)
     {
       if (testvectors[idx].algo == algo
           && testvectors[idx].gigs == gigs
           && testvectors[idx].bytes == bytes)
         break;
     }
   if (!testvectors[idx].algo)
     {
       info ("%d GiB %+3d %-10s warning: %s",
             gigs, bytes, gcry_md_algo_name (algo), "no test vector");
       missing_test_vectors++;
       return 1;
     }
 
   tv_digest = hex2buffer (testvectors[idx].hex, &tv_digestlen);
   if (tv_digestlen != digestlen) /* Ooops.  */
     {
       fail ("%d GiB %+3d %-10s error: %s",
             gigs, bytes, gcry_md_algo_name (algo), "digest length mismatch");
       xfree (tv_digest);
       return 1;
     }
   if (memcmp (tv_digest, digest, tv_digestlen))
     {
       fail ("%d GiB %+3d %-10s error: %s",
             gigs, bytes, gcry_md_algo_name (algo), "mismatch");
       xfree (tv_digest);
       return 1;
     }
   xfree (tv_digest);
 
   return 0;
 }
 
 
 static void
 run_longtest (int algo, int gigs)
 {
   gpg_error_t err;
   gcry_md_hd_t hd;
   gcry_md_hd_t hd_pre = NULL;
   gcry_md_hd_t hd_pre2 = NULL;
   gcry_md_hd_t hd_post = NULL;
   gcry_md_hd_t hd_post2 = NULL;
   char pattern[1024];
   int i, g;
   const unsigned char *digest;
   unsigned int digestlen;
 
   memset (pattern, 'a', sizeof pattern);
 
   err = gcry_md_open (&hd, algo, 0);
   if (err)
     {
       fail ("gcry_md_open failed for %s (%d): %s",
             gcry_md_algo_name (algo), algo, gpg_strerror (err));
       return;
     }
 
   digestlen = gcry_md_get_algo_dlen (algo);
 
 
   for (g=0; g < gigs; g++)
     {
       if (g == gigs - 1)
         {
           for (i = 0; i < 1024*1023; i++)
             gcry_md_write (hd, pattern, sizeof pattern);
           for (i = 0; i < 1023; i++)
             gcry_md_write (hd, pattern, sizeof pattern);
           err = gcry_md_copy (&hd_pre, hd);
           if (!err)
             err = gcry_md_copy (&hd_pre2, hd);
           if (err)
             die ("gcry_md_copy failed for %s (%d): %s",
                  gcry_md_algo_name (algo), algo, gpg_strerror (err));
           gcry_md_write (hd, pattern, sizeof pattern);
         }
       else
         {
           for (i = 0; i < 1024*1024; i++)
             gcry_md_write (hd, pattern, sizeof pattern);
         }
       if (g && !(g % 16))
         show_note ("%d GiB so far hashed with %s", g, gcry_md_algo_name (algo));
     }
   if (g >= 16)
     show_note ("%d GiB hashed with %s", g, gcry_md_algo_name (algo));
 
   err = gcry_md_copy (&hd_post, hd);
   if (err)
     die ("gcry_md_copy failed for %s (%d): %s",
          gcry_md_algo_name (algo), algo, gpg_strerror (err));
   err = gcry_md_copy (&hd_post2, hd);
   if (err)
     die ("gcry_md_copy failed for %s (%d): %s",
          gcry_md_algo_name (algo), algo, gpg_strerror (err));
 
   gcry_md_write (hd_pre2, pattern, sizeof pattern - 64);
   gcry_md_write (hd_pre, pattern, sizeof pattern - 1);
   gcry_md_write (hd_post, pattern, 1);
   gcry_md_write (hd_post2, pattern, 64);
 
   digest = gcry_md_read (hd_pre2, algo);
   if (cmp_digest (digest, digestlen, algo, gigs, -64) || verbose)
     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
              gigs, -64, gcry_md_algo_name (algo));
   digest = gcry_md_read (hd_pre, algo);
   if (cmp_digest (digest, digestlen, algo, gigs, -1) || verbose)
     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
              gigs, -1, gcry_md_algo_name (algo));
   digest = gcry_md_read (hd, algo);
   if (cmp_digest (digest, digestlen, algo, gigs, 0) || verbose)
     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
              gigs, 0, gcry_md_algo_name (algo));
   digest = gcry_md_read (hd_post, algo);
   if (cmp_digest (digest, digestlen, algo, gigs, 1) || verbose)
     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
              gigs, 1, gcry_md_algo_name (algo));
   digest = gcry_md_read (hd_post2, algo);
   if (cmp_digest (digest, digestlen, algo, gigs, 64) || verbose)
     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
              gigs, 64, gcry_md_algo_name (algo));
 
   gcry_md_close (hd);
   gcry_md_close (hd_pre);
   gcry_md_close (hd_pre2);
   gcry_md_close (hd_post);
   gcry_md_close (hd_post2);
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   int gigs = 0;
   int algo = 0;
   int idx;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           fputs ("usage: " PGM " [options] [algos]\n"
                  "Options:\n"
                  "  --verbose       print timings etc.\n"
                  "  --debug         flyswatter\n"
                  "  --gigs N        Run a test on N GiB\n",
                  stdout);
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose += 2;
           debug++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--gigs"))
         {
           argc--; argv++;
           if (argc)
             {
               gigs = atoi (*argv);
               argc--; argv++;
             }
         }
       else if (!strncmp (*argv, "--", 2))
         die ("unknown option '%s'", *argv);
     }
 
   if (gigs < 0 || gigs > 1024*1024)
     die ("value for --gigs must be in the range 0 to %d", 1024*1024);
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u , 0));
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   /* A quick check that all given algorithms are valid.  */
   for (idx=0; idx < argc; idx++)
     {
       algo = gcry_md_map_name (argv[idx]);
       if (!algo)
         fail ("invalid algorithm '%s'", argv[idx]);
     }
   if (error_count)
     exit (1);
 
   /* Start checking.  */
   start_timer ();
   if (!argc)
     {
       for (algo=1; algo < 400; algo++)
         if (!gcry_md_test_algo (algo))
           {
             if (!gigs)
               run_selftest (algo);
             else
               run_longtest (algo, gigs);
           }
      }
   else
     {
       for (idx=0; idx < argc; idx++)
         {
           algo = gcry_md_map_name (argv[idx]);
           if (!algo)
             die ("invalid algorithm '%s'", argv[idx]);
 
           if (!gigs)
             run_selftest (algo);
           else
             run_longtest (algo, gigs);
         }
     }
   stop_timer ();
 
   if (missing_test_vectors)
     fail ("Some test vectors are missing");
 
   if (verbose)
     info ("All tests completed in %s.  Errors: %d\n",
           elapsed_time (1), error_count);
   return !!error_count;
 }
diff --git a/tests/hmac.c b/tests/hmac.c
index 5852ee4a..2b4c0f9f 100644
--- a/tests/hmac.c
+++ b/tests/hmac.c
@@ -1,203 +1,203 @@
 /* hmac.c -  HMAC regression tests
  *	Copyright (C) 2005 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 
 #define PGM "hmac"
 #include "t-common.h"
 
 
 static void
 check_one_mac (int algo,
                const void *key, size_t keylen,
                const void *data, size_t datalen,
                const char *expect)
 {
   gcry_md_hd_t hd;
   unsigned char *p;
   int mdlen;
   int i;
   gcry_error_t err = 0;
 
   err = gcry_md_open (&hd, algo, GCRY_MD_FLAG_HMAC);
   if (err)
     {
       fail ("algo %d, gcry_md_open failed: %s\n", algo, gpg_strerror (err));
       return;
     }
 
   mdlen = gcry_md_get_algo_dlen (algo);
   if (mdlen < 1 || mdlen > 500)
     {
       fail ("algo %d, gcry_md_get_algo_dlen failed: %d\n", algo, mdlen);
       return;
     }
 
   err = gcry_md_setkey (hd, key, keylen);
   if (err)
     {
       fail ("algo %d, gcry_md_setkey failed: %s\n", algo, gpg_strerror (err));
       return;
     }
 
   gcry_md_write (hd, data, datalen);
 
   p = gcry_md_read (hd, 0);
 
   if (memcmp (p, expect, mdlen))
     {
       printf ("computed: ");
       for (i = 0; i < mdlen; i++)
 	printf ("%02x ", p[i] & 0xFF);
       printf ("\nexpected: ");
       for (i = 0; i < mdlen; i++)
 	printf ("%02x ", expect[i] & 0xFF);
       printf ("\n");
 
       fail ("algo %d, MAC does not match\n", algo);
     }
 
   gcry_md_close (hd);
 }
 
 static void
 check_hmac (void)
 {
   unsigned char key[128];
   int i, j;
 
   if (verbose)
     fprintf (stderr, "checking FIPS-198a, A.1\n");
   for (i=0; i < 64; i++)
     key[i] = i;
   check_one_mac (GCRY_MD_SHA1, key, 64, "Sample #1", 9,
                  "\x4f\x4c\xa3\xd5\xd6\x8b\xa7\xcc\x0a\x12"
                  "\x08\xc9\xc6\x1e\x9c\x5d\xa0\x40\x3c\x0a");
 
   if (verbose)
     fprintf (stderr, "checking FIPS-198a, A.2\n");
   for (i=0, j=0x30; i < 20; i++)
     key[i] = j++;
   check_one_mac (GCRY_MD_SHA1, key, 20, "Sample #2", 9,
                  "\x09\x22\xd3\x40\x5f\xaa\x3d\x19\x4f\x82"
                  "\xa4\x58\x30\x73\x7d\x5c\xc6\xc7\x5d\x24");
 
   if (verbose)
     fprintf (stderr, "checking FIPS-198a, A.3\n");
   for (i=0, j=0x50; i < 100; i++)
     key[i] = j++;
   check_one_mac (GCRY_MD_SHA1, key, 100, "Sample #3", 9,
                  "\xbc\xf4\x1e\xab\x8b\xb2\xd8\x02\xf3\xd0"
                  "\x5c\xaf\x7c\xb0\x92\xec\xf8\xd1\xa3\xaa");
 
   if (verbose)
     fprintf (stderr, "checking FIPS-198a, A.4\n");
   for (i=0, j=0x70; i < 49; i++)
     key[i] = j++;
   check_one_mac (GCRY_MD_SHA1, key, 49, "Sample #4", 9,
                  "\x9e\xa8\x86\xef\xe2\x68\xdb\xec\xce\x42"
                  "\x0c\x75\x24\xdf\x32\xe0\x75\x1a\x2a\x26");
 
 }
 
 
 static void
 check_hmac_multi (void)
 {
   gpg_error_t err;
   unsigned char key[128];
   const char msg[] = "Sample #1";
   const char mac[] = ("\x4f\x4c\xa3\xd5\xd6\x8b\xa7\xcc\x0a\x12"
                       "\x08\xc9\xc6\x1e\x9c\x5d\xa0\x40\x3c\x0a");
   gcry_buffer_t iov[4];
   char digest[64];
   int i;
   int algo;
   int maclen;
 
   if (verbose)
     fprintf (stderr, "checking HMAC using multiple buffers\n");
   for (i=0; i < 64; i++)
     key[i] = i;
 
   memset (iov, 0, sizeof iov);
   iov[0].data = key;
   iov[0].len = 64;
   iov[1].data = (void*)msg;
   iov[1].off = 0;
   iov[1].len = 3;
   iov[2].data = (void*)msg;
   iov[2].off = 3;
   iov[2].len = 1;
   iov[3].data = (void*)msg;
   iov[3].off = 4;
   iov[3].len = 5;
 
   algo = GCRY_MD_SHA1;
   maclen = gcry_md_get_algo_dlen (algo);
   err = gcry_md_hash_buffers (algo, GCRY_MD_FLAG_HMAC, digest, iov, 4);
   if (err)
     {
       fail ("gcry_md_hash_buffers failed for algo %d: %s\n",
             algo, gpg_strerror (err));
       return;
     }
 
   if (memcmp (digest, mac, maclen))
     {
       printf ("computed: ");
       for (i = 0; i < maclen; i++)
 	printf ("%02x ", digest[i] & 0xFF);
       printf ("\nexpected: ");
       for (i = 0; i < maclen; i++)
 	printf ("%02x ", mac[i] & 0xFF);
       printf ("\n");
 
       fail ("gcry_md_hash_buffers, algo %d, MAC does not match\n", algo);
     }
 }
 
 
 int
 main (int argc, char **argv)
 {
   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     verbose = 1;
   else if (argc > 1 && !strcmp (argv[1], "--debug"))
     verbose = debug = 1;
 
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
   check_hmac ();
   check_hmac_multi ();
 
   return error_count ? 1 : 0;
 }
diff --git a/tests/keygen.c b/tests/keygen.c
index 6b6a60a4..4e7dfd35 100644
--- a/tests/keygen.c
+++ b/tests/keygen.c
@@ -1,787 +1,787 @@
 /* keygen.c  -  key generation regression tests
  * Copyright (C) 2003, 2005, 2012 Free Software Foundation, Inc.
  * Copyright (C) 2013, 2015 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include "../src/gcrypt-int.h"
 
 
 #define PGM "keygen"
 #include "t-common.h"
 
 static int in_fips_mode;
 
 
 /* static void */
 /* show_note (const char *format, ...) */
 /* { */
 /*   va_list arg_ptr; */
 
 /*   if (!verbose && getenv ("srcdir")) */
 /*     fputs ("      ", stderr);  /\* To align above "PASS: ".  *\/ */
 /*   else */
 /*     fprintf (stderr, "%s: ", PGM); */
 /*   va_start (arg_ptr, format); */
 /*   vfprintf (stderr, format, arg_ptr); */
 /*   if (*format && format[strlen(format)-1] != '\n') */
 /*     putc ('\n', stderr); */
 /*   va_end (arg_ptr); */
 /* } */
 
 
 static void
 show_sexp (const char *prefix, gcry_sexp_t a)
 {
   char *buf;
   size_t size;
 
   fprintf (stderr, "%s: ", PGM);
   if (prefix)
     fputs (prefix, stderr);
   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   buf = xmalloc (size);
 
   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
   fprintf (stderr, "%.*s", (int)size, buf);
   gcry_free (buf);
 }
 
 
 static void
 show_mpi (const char *prefix, gcry_mpi_t a)
 {
   char *buf;
   void *bufaddr = &buf;
   gcry_error_t rc;
 
   fprintf (stderr, "%s: ", PGM);
   if (prefix)
     fputs (prefix, stderr);
   rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
   if (rc)
     fprintf (stderr, "[error printing number: %s]\n",  gpg_strerror (rc));
   else
     {
       fprintf (stderr, "%s\n", buf);
       gcry_free (buf);
     }
 }
 
 
 static void
 check_generated_rsa_key (gcry_sexp_t key, unsigned long expected_e)
 {
   gcry_sexp_t skey, pkey, list;
 
   pkey = gcry_sexp_find_token (key, "public-key", 0);
   if (!pkey)
     fail ("public part missing in return value\n");
   else
     {
       gcry_mpi_t e = NULL;
 
       list = gcry_sexp_find_token (pkey, "e", 0);
       if (!list || !(e=gcry_sexp_nth_mpi (list, 1, 0)) )
         fail ("public exponent not found\n");
       else if (!expected_e)
         {
           if (verbose)
             show_mpi ("public exponent: ", e);
         }
       else if ( gcry_mpi_cmp_ui (e, expected_e))
         {
           show_mpi ("public exponent: ", e);
           fail ("public exponent is not %lu\n", expected_e);
         }
       gcry_sexp_release (list);
       gcry_mpi_release (e);
       gcry_sexp_release (pkey);
     }
 
   skey = gcry_sexp_find_token (key, "private-key", 0);
   if (!skey)
     fail ("private part missing in return value\n");
   else
     {
       int rc = gcry_pk_testkey (skey);
       if (rc)
         fail ("gcry_pk_testkey failed: %s\n", gpg_strerror (rc));
       gcry_sexp_release (skey);
     }
 }
 
 
 static void
 check_rsa_keys (void)
 {
   gcry_sexp_t keyparm, key;
   int rc;
 
   if (verbose)
     info ("creating 2048 bit RSA key\n");
   rc = gcry_sexp_new (&keyparm,
                       "(genkey\n"
                       " (rsa\n"
                       "  (nbits 4:2048)\n"
                       " ))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc)
     die ("error generating RSA key: %s\n", gpg_strerror (rc));
 
   if (verbose)
     info ("creating 1024 bit RSA key\n");
   rc = gcry_sexp_new (&keyparm,
                       "(genkey\n"
                       " (rsa\n"
                       "  (nbits 4:1024)\n"
                       " ))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
 
   gcry_sexp_release (key);
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc && !in_fips_mode)
     fail ("error generating RSA key: %s\n", gpg_strerror (rc));
   else if (!rc && in_fips_mode)
     fail ("generating 1024 bit RSA key must not work!");
 
   if (!rc)
     {
       if (verbose > 1)
         show_sexp ("1024 bit RSA key:\n", key);
       check_generated_rsa_key (key, 65537);
     }
   gcry_sexp_release (key);
 
   if (verbose)
     info ("creating 2048 bit RSA key with e=65539\n");
   rc = gcry_sexp_new (&keyparm,
                       "(genkey\n"
                       " (rsa\n"
                       "  (nbits 4:2048)\n"
                       "  (rsa-use-e 5:65539)\n"
                       " ))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc)
     fail ("error generating RSA key: %s\n", gpg_strerror (rc));
 
   if (!rc)
     check_generated_rsa_key (key, 65539);
   gcry_sexp_release (key);
 
 
   if (verbose)
     info ("creating 512 bit RSA key with e=257\n");
   rc = gcry_sexp_new (&keyparm,
                       "(genkey\n"
                       " (rsa\n"
                       "  (nbits 3:512)\n"
                       "  (rsa-use-e 3:257)\n"
                       " ))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc && !in_fips_mode)
     fail ("error generating RSA key: %s\n", gpg_strerror (rc));
   else if (!rc && in_fips_mode)
     fail ("generating 512 bit RSA key must not work!");
 
   if (verbose && rc && in_fips_mode)
     info ("... correctly rejected key creation in FIPS mode (%s)\n",
           gpg_strerror (rc));
 
   if (!rc)
     check_generated_rsa_key (key, 257);
   gcry_sexp_release (key);
 
   if (verbose)
     info ("creating 512 bit RSA key with default e\n");
   rc = gcry_sexp_new (&keyparm,
                       "(genkey\n"
                       " (rsa\n"
                       "  (nbits 3:512)\n"
                       "  (rsa-use-e 1:0)\n"
                       " ))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc && !in_fips_mode)
     fail ("error generating RSA key: %s\n", gpg_strerror (rc));
   else if (!rc && in_fips_mode)
     fail ("generating 512 bit RSA key must not work!");
 
   if (verbose && rc && in_fips_mode)
     info ("... correctly rejected key creation in FIPS mode (%s)\n",
           gpg_strerror (rc));
 
 
   if (!rc)
     check_generated_rsa_key (key, 0); /* We don't expect a constant exponent. */
   gcry_sexp_release (key);
 }
 
 
 static void
 check_elg_keys (void)
 {
   gcry_sexp_t keyparm, key;
   int rc;
 
   if (verbose)
     info ("creating 1024 bit Elgamal key\n");
   rc = gcry_sexp_new (&keyparm,
                       "(genkey\n"
                       " (elg\n"
                       "  (nbits 4:1024)\n"
                       " ))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc)
     die ("error generating Elgamal key: %s\n", gpg_strerror (rc));
   if (verbose > 1)
     show_sexp ("1024 bit Elgamal key:\n", key);
   gcry_sexp_release (key);
 }
 
 
 static void
 check_dsa_keys (void)
 {
   gcry_sexp_t keyparm, key;
   int rc;
   int i;
 
   /* Check that DSA generation works and that it can grok the qbits
      argument. */
   if (verbose)
     info ("creating 5 1024 bit DSA keys\n");
   for (i=0; i < 5; i++)
     {
       rc = gcry_sexp_new (&keyparm,
                           "(genkey\n"
                           " (dsa\n"
                           "  (nbits 4:1024)\n"
                           " ))", 0, 1);
       if (rc)
         die ("error creating S-expression: %s\n", gpg_strerror (rc));
       rc = gcry_pk_genkey (&key, keyparm);
       gcry_sexp_release (keyparm);
       if (rc && !in_fips_mode)
         die ("error generating DSA key: %s\n", gpg_strerror (rc));
       else if (!rc && in_fips_mode)
         die ("generating 1024 bit DSA key must not work!");
       if (!i && verbose > 1)
         show_sexp ("1024 bit DSA key:\n", key);
       gcry_sexp_release (key);
     }
 
   if (verbose)
     info ("creating 1536 bit DSA key\n");
   rc = gcry_sexp_new (&keyparm,
                       "(genkey\n"
                       " (dsa\n"
                       "  (nbits 4:1536)\n"
                       "  (qbits 3:224)\n"
                       " ))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc && !in_fips_mode)
     die ("error generating DSA key: %s\n", gpg_strerror (rc));
   else if (!rc && in_fips_mode)
     die ("generating 1536 bit DSA key must not work!");
   if (verbose > 1)
     show_sexp ("1536 bit DSA key:\n", key);
   gcry_sexp_release (key);
 
   if (verbose)
     info ("creating 3072 bit DSA key\n");
   rc = gcry_sexp_new (&keyparm,
                       "(genkey\n"
                       " (dsa\n"
                       "  (nbits 4:3072)\n"
                       "  (qbits 3:256)\n"
                       " ))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc)
     die ("error generating DSA key: %s\n", gpg_strerror (rc));
   if (verbose > 1)
     show_sexp ("3072 bit DSA key:\n", key);
   gcry_sexp_release (key);
 
   if (verbose)
     info ("creating 2048/256 bit DSA key\n");
   rc = gcry_sexp_new (&keyparm,
                       "(genkey\n"
                       " (dsa\n"
                       "  (nbits 4:2048)\n"
                       "  (qbits 3:256)\n"
                       " ))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc)
     die ("error generating DSA key: %s\n", gpg_strerror (rc));
   if (verbose > 1)
     show_sexp ("2048 bit DSA key:\n", key);
   gcry_sexp_release (key);
 
   if (verbose)
     info ("creating 2048/224 bit DSA key\n");
   rc = gcry_sexp_new (&keyparm,
                       "(genkey\n"
                       " (dsa\n"
                       "  (nbits 4:2048)\n"
                       "  (qbits 3:224)\n"
                       " ))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc)
     die ("error generating DSA key: %s\n", gpg_strerror (rc));
   if (verbose > 1)
     show_sexp ("2048 bit DSA key:\n", key);
   gcry_sexp_release (key);
 }
 
 
 static void
 check_generated_ecc_key (gcry_sexp_t key)
 {
   gcry_sexp_t skey, pkey;
 
   pkey = gcry_sexp_find_token (key, "public-key", 0);
   if (!pkey)
     fail ("public part missing in return value\n");
   else
     {
       /* Fixme: Check more stuff.  */
       gcry_sexp_release (pkey);
     }
 
   skey = gcry_sexp_find_token (key, "private-key", 0);
   if (!skey)
     fail ("private part missing in return value\n");
   else
     {
       int rc = gcry_pk_testkey (skey);
       if (rc)
         fail ("gcry_pk_testkey failed: %s\n", gpg_strerror (rc));
       gcry_sexp_release (skey);
     }
 
   /* Finally check that gcry_pk_testkey also works on the entire
      S-expression.  */
   {
     int rc = gcry_pk_testkey (key);
     if (rc)
       fail ("gcry_pk_testkey failed on key pair: %s\n", gpg_strerror (rc));
   }
 }
 
 
 static void
 check_ecc_keys (void)
 {
   const char *curves[] = { "NIST P-521", "NIST P-384", "NIST P-256",
                            "Ed25519", NULL };
   int testno;
   gcry_sexp_t keyparm, key;
   int rc;
 
   for (testno=0; curves[testno]; testno++)
     {
       if (verbose)
         info ("creating ECC key using curve %s\n", curves[testno]);
       if (!strcmp (curves[testno], "Ed25519"))
         {
           /* Ed25519 isn't allowed in fips mode */
           if (in_fips_mode)
             continue;
           rc = gcry_sexp_build (&keyparm, NULL,
                                 "(genkey(ecc(curve %s)(flags param eddsa)))",
                                 curves[testno]);
         }
       else
         rc = gcry_sexp_build (&keyparm, NULL,
                               "(genkey(ecc(curve %s)(flags param)))",
                               curves[testno]);
       if (rc)
         die ("error creating S-expression: %s\n", gpg_strerror (rc));
       rc = gcry_pk_genkey (&key, keyparm);
       gcry_sexp_release (keyparm);
       if (rc)
         die ("error generating ECC key using curve %s: %s\n",
              curves[testno], gpg_strerror (rc));
 
       if (verbose > 1)
         show_sexp ("ECC key:\n", key);
 
       check_generated_ecc_key (key);
 
       gcry_sexp_release (key);
     }
 
   if (verbose)
     info ("creating ECC key using curve Ed25519 for ECDSA\n");
   rc = gcry_sexp_build (&keyparm, NULL, "(genkey(ecc(curve Ed25519)))");
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc && !in_fips_mode)
     die ("error generating ECC key using curve Ed25519 for ECDSA: %s\n",
          gpg_strerror (rc));
   else if (!rc && in_fips_mode)
     fail ("generating Ed25519 key must not work!");
 
   if (verbose && rc && in_fips_mode)
     info ("... correctly rejected key creation in FIPS mode (%s)\n",
           gpg_strerror (rc));
 
   if (!rc)
     {
       if (verbose > 1)
         show_sexp ("ECC key:\n", key);
 
       check_generated_ecc_key (key);
     }
   gcry_sexp_release (key);
 
   if (verbose)
     info ("creating ECC key using curve Ed25519 for ECDSA (nocomp)\n");
   rc = gcry_sexp_build (&keyparm, NULL,
                         "(genkey(ecc(curve Ed25519)(flags nocomp)))");
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc && !in_fips_mode)
     die ("error generating ECC key using curve Ed25519 for ECDSA"
          " (nocomp): %s\n",
          gpg_strerror (rc));
   else if (!rc && in_fips_mode)
     fail ("generating Ed25519 key must not work in FIPS mode!");
 
   if (verbose && rc && in_fips_mode)
     info ("... correctly rejected key creation in FIPS mode (%s)\n",
           gpg_strerror (rc));
   gcry_sexp_release (key);
 
   if (verbose)
     info ("creating ECC key using curve NIST P-384 for ECDSA\n");
 
   /* Must be specified as nistp384 (one word), because ecc_generate
    * uses _gcry_sexp_nth_string which takes the first word of the name
    * and thus libgcrypt can't find it later in its curves table.  */
   rc = gcry_sexp_build (&keyparm, NULL, "(genkey(ecc(curve nistp384)))");
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc)
     die ("error generating ECC key using curve NIST P-384 for ECDSA: %s\n",
          gpg_strerror (rc));
 
   if (verbose > 1)
     show_sexp ("ECC key:\n", key);
 
   check_generated_ecc_key (key);
   gcry_sexp_release (key);
 
   if (verbose)
     info ("creating ECC key using curve NIST P-384 for ECDSA (nocomp)\n");
   rc = gcry_sexp_build (&keyparm, NULL,
                         "(genkey(ecc(curve nistp384)(flags nocomp)))");
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc)
     die ("error generating ECC key using curve NIST P-384 for ECDSA"
          " (nocomp): %s\n",
          gpg_strerror (rc));
 
   if (verbose > 1)
     show_sexp ("ECC key:\n", key);
 
   check_generated_ecc_key (key);
   gcry_sexp_release (key);
 
 
   if (verbose)
     info ("creating ECC key using curve Ed25519 for ECDSA (transient-key)\n");
   rc = gcry_sexp_build (&keyparm, NULL,
                         "(genkey(ecc(curve Ed25519)(flags transient-key)))");
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc && !in_fips_mode)
     die ("error generating ECC key using curve Ed25519 for ECDSA"
          " (transient-key): %s\n",
          gpg_strerror (rc));
   else if (!rc && in_fips_mode)
     fail ("generating Ed25519 key must not work in FIPS mode!");
 
   if (verbose && rc && in_fips_mode)
     info ("... correctly rejected key creation in FIPS mode (%s)\n",
           gpg_strerror (rc));
 
   if (!rc)
     {
       if (verbose > 1)
         show_sexp ("ECC key:\n", key);
       check_generated_ecc_key (key);
     }
   gcry_sexp_release (key);
 
   if (verbose)
     info ("creating ECC key using curve Ed25519 for ECDSA "
           "(transient-key no-keytest)\n");
   rc = gcry_sexp_build (&keyparm, NULL,
                         "(genkey(ecc(curve Ed25519)"
                         "(flags transient-key no-keytest)))");
   if (rc)
     die ("error creating S-expression: %s\n", gpg_strerror (rc));
   rc = gcry_pk_genkey (&key, keyparm);
   gcry_sexp_release (keyparm);
   if (rc && !in_fips_mode)
     die ("error generating ECC key using curve Ed25519 for ECDSA"
          " (transient-key no-keytest): %s\n",
          gpg_strerror (rc));
   else if (!rc && in_fips_mode)
     fail ("generating Ed25519 key must not work in FIPS mode!");
 
   if (verbose && rc && in_fips_mode)
     info ("... correctly rejected key creation in FIPS mode (%s)\n",
           gpg_strerror (rc));
 
   if (!rc)
     {
       if (verbose > 1)
         show_sexp ("ECC key:\n", key);
       check_generated_ecc_key (key);
     }
   gcry_sexp_release (key);
 }
 
 
 static void
 check_nonce (void)
 {
   char a[32], b[32];
   int i,j;
   int oops=0;
 
   if (verbose)
     info ("checking gcry_create_nonce\n");
 
   gcry_create_nonce (a, sizeof a);
   for (i=0; i < 10; i++)
     {
       gcry_create_nonce (b, sizeof b);
       if (!memcmp (a, b, sizeof a))
         die ("identical nonce found\n");
     }
   for (i=0; i < 10; i++)
     {
       gcry_create_nonce (a, sizeof a);
       if (!memcmp (a, b, sizeof a))
         die ("identical nonce found\n");
     }
 
  again:
   for (i=1,j=0; i < sizeof a; i++)
     if (a[0] == a[i])
       j++;
   if (j+1 == sizeof (a))
     {
       if (oops)
         die ("impossible nonce found\n");
       oops++;
       gcry_create_nonce (a, sizeof a);
       goto again;
     }
 }
 
 
 static void
 progress_cb (void *cb_data, const char *what, int printchar,
 		  int current, int total)
 {
   (void)cb_data;
   (void)what;
   (void)current;
   (void)total;
 
   if (printchar == '\n')
     fputs ( "<LF>", stdout);
   else
     putchar (printchar);
   fflush (stdout);
 }
 
 
 static void
 usage (int mode)
 {
   fputs ("usage: " PGM " [options] [{rsa|elg|dsa|ecc|nonce}]\n"
          "Options:\n"
          "  --verbose       be verbose\n"
          "  --debug         flyswatter\n"
          "  --fips          run in FIPS mode\n"
          "  --no-quick      To not use the quick RNG hack\n"
          "  --progress      print progress indicators\n",
          mode? stderr : stdout);
   if (mode)
     exit (1);
 }
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   int opt_fips = 0;
   int with_progress = 0;
   int no_quick = 0;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           usage (0);
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose += 2;
           debug++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--fips"))
         {
           argc--; argv++;
           opt_fips = 1;
         }
       else if (!strcmp (*argv, "--progress"))
         {
           argc--; argv++;
           with_progress = 1;
         }
       else if (!strcmp (*argv, "--no-quick"))
         {
           argc--; argv++;
           no_quick = 1;
         }
       else if (!strncmp (*argv, "--", 2))
         die ("unknown option '%s'", *argv);
       else
         break;
     }
 
-  xgcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
+  xgcry_control ((GCRYCTL_SET_VERBOSITY, (int)verbose));
   if (opt_fips)
-    xgcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
+    xgcry_control ((GCRYCTL_FORCE_FIPS_MODE, 0));
 
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
 
   if (!opt_fips)
-    xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+    xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
 
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u , 0));
   /* No valuable keys are create, so we can speed up our RNG. */
   if (!no_quick)
-    xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+    xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
   if (with_progress)
     gcry_set_progress_handler (progress_cb, NULL);
 
   if ( gcry_fips_mode_active () )
     in_fips_mode = 1;
 
   if (opt_fips && !in_fips_mode)
     die ("failed to switch into FIPS mode\n");
 
   if (!argc)
     {
       check_rsa_keys ();
       check_elg_keys ();
       check_dsa_keys ();
       check_ecc_keys ();
       check_nonce ();
     }
   else
     {
       for (; argc; argc--, argv++)
         if (!strcmp (*argv, "rsa"))
           check_rsa_keys ();
         else if (!strcmp (*argv, "elg"))
           check_elg_keys ();
         else if (!strcmp (*argv, "dsa"))
           check_dsa_keys ();
         else if (!strcmp (*argv, "ecc"))
           check_ecc_keys ();
         else if (!strcmp (*argv, "nonce"))
           check_nonce ();
         else
           usage (1);
     }
 
   return error_count? 1:0;
 }
diff --git a/tests/keygrip.c b/tests/keygrip.c
index 73a6f812..63171502 100644
--- a/tests/keygrip.c
+++ b/tests/keygrip.c
@@ -1,330 +1,330 @@
 /* keygrip.c - verifies that keygrips are calculated as expected
  *	Copyright (C) 2005 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <assert.h>
 
 #define PGM "keygrip"
 #include "t-common.h"
 
 static int repetitions;
 
 
 
 static void
 print_hex (const char *text, const void *buf, size_t n)
 {
   const unsigned char *p = buf;
 
   fputs (text, stdout);
   for (; n; n--, p++)
     printf ("%02X", *p);
   putchar ('\n');
 }
 
 
 
 
 static struct
 {
   int algo;
   const char *key;
   const unsigned char grip[20];
 } key_grips[] =
   {
     {
       GCRY_PK_RSA,
       "(private-key"
       " (rsa"
       "  (n #00B6B509596A9ECABC939212F891E656A626BA07DA8521A9CAD4C08E640C04052FBB87F424EF1A0275A48A9299AC9DB69ABE3D0124E6C756B1F7DFB9B842D6251AEA6EE85390495CADA73D671537FCE5850A932F32BAB60AB1AC1F852C1F83C625E7A7D70CDA9EF16D5C8E47739D77DF59261ABE8454807FF441E143FBD37F8545#)"
       "  (e #010001#)"
       "  (d #077AD3DE284245F4806A1B82B79E616FBDE821C82D691A65665E57B5FAD3F34E67F401E7BD2E28699E89D9C496CF821945AE83AC7A1231176A196BA6027E77D85789055D50404A7A2A95B1512F91F190BBAEF730ED550D227D512F89C0CDB31AC06FA9A19503DDF6B66D0B42B9691BFD6140EC1720FFC48AE00C34796DC899E5#)"
       "  (p #00D586C78E5F1B4BF2E7CD7A04CA091911706F19788B93E44EE20AAF462E8363E98A72253ED845CCBF2481BB351E8557C85BCFFF0DABDBFF8E26A79A0938096F27#)"
       "  (q #00DB0CDF60F26F2A296C88D6BF9F8E5BE45C0DDD713C96CC73EBCB48B061740943F21D2A93D6E42A7211E7F02A95DCED6C390A67AD21ECF739AE8A0CA46FF2EBB3#)"
       "  (u #33149195F16912DB20A48D020DBC3B9E3881B39D722BF79378F6340F43148A6E9FC5F53E2853B7387BA4443BA53A52FCA8173DE6E85B42F9783D4A7817D0680B#)))",
       "\x32\xCF\xFA\x85\xB1\x79\x1F\xBB\x26\x14\xE9\x1A\xFD\xF3\xAF\xE3\x32\x08\x2E\x25"
     },
     {
       GCRY_PK_DSA,
       " (public-key"
       " (dsa"
       "  (p #0084E4C626E16005770BD9509ABF7354492E85B8C0060EFAAAEC617F725B592FAA59DF5460575F41022776A9718CE62EDD542AB73C7720869EBDBC834D174ADCD7136827DF51E2613545A25CA573BC502A61B809000B6E35F5EB7FD6F18C35678C23EA1C3638FB9CFDBA2800EE1B62F41A4479DE824F2834666FBF8DC5B53C2617#)"
       "  (q #00B0E6F710051002A9F425D98A677B18E0E5B038AB#)"
       "  (g #44370CEE0FE8609994183DBFEBA7EEA97D466838BCF65EFF506E35616DA93FA4E572A2F08886B74977BC00CA8CD3DBEA7AEB7DB8CBB180E6975E0D2CA76E023E6DE9F8CCD8826EBA2F72B8516532F6001DEFFAE76AA5E59E0FA33DBA3999B4E92D1703098CDEDCC416CF008801964084CDE1980132B2B78CB4CE9C15A559528B#)"
       "  (y #3D5DD14AFA2BF24A791E285B90232213D0E3BA74AB1109E768AED19639A322F84BB7D959E2BA92EF73DE4C7F381AA9F4053CFA3CD4527EF9043E304E5B95ED0A3A5A9D590AA641C13DB2B6E32B9B964A6A2C730DD3EA7C8E13F7A140AFF1A91CE375E9B9B960384779DC4EA180FA1F827C52288F366C0770A220F50D6D8FD6F6#)))",
       "\x04\xA3\x4F\xA0\x2B\x03\x94\xD7\x32\xAD\xD5\x9B\x50\xAF\xDB\x5D\x57\x22\xA6\x10"
 
     },
     {
       GCRY_PK_DSA,
       "(private-key"
       " (dsa"
       "  (p #0084E4C626E16005770BD9509ABF7354492E85B8C0060EFAAAEC617F725B592FAA59DF5460575F41022776A9718CE62EDD542AB73C7720869EBDBC834D174ADCD7136827DF51E2613545A25CA573BC502A61B809000B6E35F5EB7FD6F18C35678C23EA1C3638FB9CFDBA2800EE1B62F41A4479DE824F2834666FBF8DC5B53C2617#)"
       "  (q #00B0E6F710051002A9F425D98A677B18E0E5B038AB#)"
       "  (g #44370CEE0FE8609994183DBFEBA7EEA97D466838BCF65EFF506E35616DA93FA4E572A2F08886B74977BC00CA8CD3DBEA7AEB7DB8CBB180E6975E0D2CA76E023E6DE9F8CCD8826EBA2F72B8516532F6001DEFFAE76AA5E59E0FA33DBA3999B4E92D1703098CDEDCC416CF008801964084CDE1980132B2B78CB4CE9C15A559528B#)"
       "  (y #3D5DD14AFA2BF24A791E285B90232213D0E3BA74AB1109E768AED19639A322F84BB7D959E2BA92EF73DE4C7F381AA9F4053CFA3CD4527EF9043E304E5B95ED0A3A5A9D590AA641C13DB2B6E32B9B964A6A2C730DD3EA7C8E13F7A140AFF1A91CE375E9B9B960384779DC4EA180FA1F827C52288F366C0770A220F50D6D8FD6F6#)"
       "  (x #0087F9E91BFBCC1163DE71ED86D557708E32F8ADDE#)))",
       "\x04\xA3\x4F\xA0\x2B\x03\x94\xD7\x32\xAD\xD5\x9B\x50\xAF\xDB\x5D\x57\x22\xA6\x10"
     },
     {
       GCRY_PK_ECDSA,
       "(public-key"
       " (ecdsa(flags param)"
       " (p #00FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF#)"
       " (a #00FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC#)"
       " (b #5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B#)"
       " (g #046B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C2964FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5#)"
       " (n #00FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551#)"
       " (h #000000000000000000000000000000000000000000000000000000000000000001#)"
       " (q #04C8A4CEC2E9A9BC8E173531A67B0840DF345C32E261ADD780E6D83D56EFADFD5DE872F8B854819B59543CE0B7F822330464FBC4E6324DADDCD9D059554F63B344#)))",
       "\xE6\xDF\x94\x2D\xBD\x8C\x77\x05\xA3\xDD\x41\x6E\xFC\x04\x01\xDB\x31\x0E\x99\xB6"
     },
     {
       GCRY_PK_ECDSA,
       "(public-key"
       " (ecdsa(flags param)"
       " (p #00FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF#)"
       " (curve \"NIST P-256\")"
       " (b #5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B#)"
       " (g #046B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C2964FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5#)"
       " (n #00FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551#)"
       " (h #000000000000000000000000000000000000000000000000000000000000000001#)"
       " (q #04C8A4CEC2E9A9BC8E173531A67B0840DF345C32E261ADD780E6D83D56EFADFD5DE872F8B854819B59543CE0B7F822330464FBC4E6324DADDCD9D059554F63B344#)))",
       "\xE6\xDF\x94\x2D\xBD\x8C\x77\x05\xA3\xDD\x41\x6E\xFC\x04\x01\xDB\x31\x0E\x99\xB6"
     },
     {
       GCRY_PK_ECDSA,
       "(public-key"
       " (ecdsa"
       " (p #00FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF#)"
       " (curve \"NIST P-256\")"
       " (b #5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B#)"
       " (g #046B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C2964FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5#)"
       " (n #00FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551#)"
       " (h #000000000000000000000000000000000000000000000000000000000000000001#)"
       " (q #04C8A4CEC2E9A9BC8E173531A67B0840DF345C32E261ADD780E6D83D56EFADFD5DE872F8B854819B59543CE0B7F822330464FBC4E6324DADDCD9D059554F63B344#)))",
       "\xE6\xDF\x94\x2D\xBD\x8C\x77\x05\xA3\xDD\x41\x6E\xFC\x04\x01\xDB\x31\x0E\x99\xB6"
     },
     {
       GCRY_PK_ECDSA,
       "(public-key"
       " (ecdsa"
       " (curve secp256r1)"
       " (q #04C8A4CEC2E9A9BC8E173531A67B0840DF345C32E261ADD780E6D83D56EFADFD5DE872F8B854819B59543CE0B7F822330464FBC4E6324DADDCD9D059554F63B344#)))",
       "\xE6\xDF\x94\x2D\xBD\x8C\x77\x05\xA3\xDD\x41\x6E\xFC\x04\x01\xDB\x31\x0E\x99\xB6"
     },
     {
       GCRY_PK_ECC,
       "(public-key"
       " (ecc"
       " (curve secp256r1)"
       " (q #04C8A4CEC2E9A9BC8E173531A67B0840DF345C32E261ADD780E6D83D56EFADFD5DE872F8B854819B59543CE0B7F822330464FBC4E6324DADDCD9D059554F63B344#)))",
       "\xE6\xDF\x94\x2D\xBD\x8C\x77\x05\xA3\xDD\x41\x6E\xFC\x04\x01\xDB\x31\x0E\x99\xB6"
     },
     { /* Ed25519 standard */
       GCRY_PK_ECC,
       "(public-key"
       " (ecc"
       " (curve Ed25519)"
       " (q #04"
       "     1CC662926E7EFF4982B7FB8B928E61CD74CCDD85277CC57196C3AD20B611085F"
       "     47BD24842905C049257673B3F5249524E0A41FAA17B25B818D0F97E625F1A1D0#)"
       "     ))",
       "\x0C\xCA\xB2\xFD\x48\x9A\x33\x40\x2C\xE8"
       "\xE0\x4A\x1F\xB2\x45\xEA\x80\x3D\x0A\xF1"
     },
     { /* Ed25519+EdDSA */
       GCRY_PK_ECC,
       "(public-key"
       " (ecc"
       " (curve Ed25519)(flags eddsa)"
       " (q #773E72848C1FD5F9652B29E2E7AF79571A04990E96F2016BF4E0EC1890C2B7DB#)"
       " ))",
       "\x9D\xB6\xC6\x4A\x38\x83\x0F\x49\x60\x70"
       "\x17\x89\x47\x55\x20\xBE\x8C\x82\x1F\x47"
     },
     { /* Ed25519+EdDSA (with compression prefix) */
       GCRY_PK_ECC,
       "(public-key"
       " (ecc"
       " (curve Ed25519)(flags eddsa)"
       " (q #40"
       "     773E72848C1FD5F9652B29E2E7AF79571A04990E96F2016BF4E0EC1890C2B7DB#)"
       " ))",
       "\x9D\xB6\xC6\x4A\x38\x83\x0F\x49\x60\x70"
       "\x17\x89\x47\x55\x20\xBE\x8C\x82\x1F\x47"
     },
     { /* Ed25519+EdDSA  (same but uncompressed)*/
       GCRY_PK_ECC,
       "(public-key"
       " (ecc"
       " (curve Ed25519)(flags eddsa)"
       " (q #04"
       "     629ad237d1ed04dcd4abe1711dd699a1cf51b1584c4de7a4ef8b8a640180b26f"
       "     5bb7c29018ece0f46b01f2960e99041a5779afe7e2292b65f9d51f8c84723e77#)"
       " ))",
       "\x9D\xB6\xC6\x4A\x38\x83\x0F\x49\x60\x70"
       "\x17\x89\x47\x55\x20\xBE\x8C\x82\x1F\x47"
     },
     { /* Random key  */
       GCRY_PK_RSA,
       "(shadowed-private-key"
       " (rsa"
       " (n #00B493C79928398DA9D99AC0E949FE6EB62F683CB974FFFBFBC01066F5C9A89B"
       "     D3DC48EAD7C65F36EA943C2B2C865C26C4884FF9EDFDA8C99C855B737D77EEF6"
       "     B85DBC0CCEC0E900C1F89A6893A2A93E8B31028469B6927CEB2F08687E547C68"
       "     6B0A2F7E50A194FF7AB7637E03DE0912EF7F6E5F1EC37625BD1620CCC2E7A564"
       "     31E168CDAFBD1D9E61AE47A69A6FA03EF22F844528A710B2392F262B95A3078C"
       "     F321DC8325F92A5691EF69F34FD0DE0B22C79D29DC87723FCADE463829E8E5F7"
       "     D196D73D6C9C180F6A6A0DDBF7B9D8F7FA293C36163B12199EF6A1A95CAE4051"
       "     E3069C522CC6C4A7110F663A5DAD20F66C13A1674D050088208FAE4F33B3AB51"
       "     03#)"
       " (e #00010001#)"
       " (shadowed t1-v1"
       " (#D2760001240102000005000123350000# OPENPGP.1)"
       ")))",
       "\xE5\x6E\xE6\xEE\x5A\x2F\xDC\x3E\x98\x9D"
       "\xFE\x49\xDA\xF5\x67\x43\xE3\x27\x28\x33"
     }
   };
 
 
 static void
 check (void)
 {
   unsigned char buf[20];
   unsigned char *ret;
   gcry_error_t err;
   gcry_sexp_t sexp;
   unsigned int i;
   int repn;
 
   for (i = 0; i < (sizeof (key_grips) / sizeof (*key_grips)); i++)
     {
       if (gcry_pk_test_algo (key_grips[i].algo))
         {
           if (verbose)
             fprintf (stderr, "algo %d not available; test skipped\n",
                      key_grips[i].algo);
           continue;
         }
       err = gcry_sexp_sscan (&sexp, NULL, key_grips[i].key,
 			     strlen (key_grips[i].key));
       if (err)
         die ("scanning data %d failed: %s\n", i, gpg_strerror (err));
 
       if (debug)
         info ("check(%d): s-exp='%s'\n", i, key_grips[i].key);
 
       for (repn=0; repn < repetitions; repn++)
         {
           ret = gcry_pk_get_keygrip (sexp, buf);
           if (!ret)
             die ("gcry_pk_get_keygrip failed for %d\n", i);
 
           if ( memcmp (key_grips[i].grip, buf, sizeof (buf)) )
             {
               print_hex ("keygrip: ", buf, sizeof buf);
               die ("keygrip for %d does not match\n", i);
             }
           else if (debug && !repn)
             print_hex ("keygrip: ", buf, sizeof buf);
         }
 
       gcry_sexp_release (sexp);
     }
 }
 
 
 
 static void
 progress_handler (void *cb_data, const char *what, int printchar,
 		  int current, int total)
 {
   (void)cb_data;
   (void)what;
   (void)current;
   (void)total;
 
   putchar (printchar);
 }
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose = 1;
           debug = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--repetitions"))
         {
           argc--; argv++;
           if (argc)
             {
               repetitions = atoi(*argv);
               argc--; argv++;
             }
         }
     }
 
   if (repetitions < 1)
     repetitions = 1;
 
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
 
   gcry_set_progress_handler (progress_handler, NULL);
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
 
   check ();
 
   return 0;
 }
diff --git a/tests/mpitests.c b/tests/mpitests.c
index 9b4a66c2..96e01551 100644
--- a/tests/mpitests.c
+++ b/tests/mpitests.c
@@ -1,610 +1,610 @@
 /* mpitests.c  -  basic mpi tests
  *	Copyright (C) 2001, 2002, 2003, 2006 Free Software Foundation, Inc.
  * Copyright (C) 2013 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 
 #ifdef _GCRYPT_IN_LIBGCRYPT
 # include "../src/gcrypt-int.h"
 #else
 # include <gcrypt.h>
 #endif
 
 #define PGM "mpitests"
 #include "t-common.h"
 
 
 /* Set up some test patterns */
 
 /* 48 bytes with value 1: this results in 8 limbs for 64bit limbs, 16limb for 32 bit limbs */
 unsigned char ones[] = {
   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
 };
 
 /* 48 bytes with value 2: this results in 8 limbs for 64bit limbs, 16limb for 32 bit limbs */
 unsigned char twos[] = {
   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
 };
 
 /* 48 bytes with value 3: this results in 8 limbs for 64bit limbs, 16limb for 32 bit limbs */
 unsigned char threes[] = {
   0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
   0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
   0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
 };
 
 /* 48 bytes with value 0x80: this results in 8 limbs for 64bit limbs, 16limb for 32 bit limbs */
 unsigned char eighties[] = {
   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80
 };
 
 /* 48 bytes with value 0xff: this results in 8 limbs for 64bit limbs, 16limb for 32 bit limbs */
 unsigned char manyff[] = {
   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
 
 
 static int
 test_const_and_immutable (void)
 {
   gcry_mpi_t one, second_one;
 
   one = gcry_mpi_set_ui (NULL, 1);
   if (gcry_mpi_get_flag (one, GCRYMPI_FLAG_IMMUTABLE)
       || gcry_mpi_get_flag (one, GCRYMPI_FLAG_CONST))
     die ("immutable or const flag initially set\n");
 
   second_one = gcry_mpi_copy (one);
   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_IMMUTABLE))
     die ("immutable flag set after copy\n");
   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_CONST))
     die ("const flag set after copy\n");
   gcry_mpi_release (second_one);
 
   gcry_mpi_set_flag (one, GCRYMPI_FLAG_IMMUTABLE);
   if (!gcry_mpi_get_flag (one, GCRYMPI_FLAG_IMMUTABLE))
     die ("failed to set immutable flag\n");
   if (gcry_mpi_get_flag (one, GCRYMPI_FLAG_CONST))
     die ("const flag unexpectly set\n");
 
   second_one = gcry_mpi_copy (one);
   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_IMMUTABLE))
     die ("immutable flag not cleared after copy\n");
   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_CONST))
     die ("const flag unexpectly set after copy\n");
   gcry_mpi_release (second_one);
 
   gcry_mpi_clear_flag (one, GCRYMPI_FLAG_IMMUTABLE);
   if (gcry_mpi_get_flag (one, GCRYMPI_FLAG_IMMUTABLE))
     die ("failed to clear immutable flag\n");
   if (gcry_mpi_get_flag (one, GCRYMPI_FLAG_CONST))
     die ("const flag unexpectly set\n");
 
   gcry_mpi_set_flag (one, GCRYMPI_FLAG_CONST);
   if (!gcry_mpi_get_flag (one, GCRYMPI_FLAG_CONST))
     die ("failed to set const flag\n");
   if (!gcry_mpi_get_flag (one, GCRYMPI_FLAG_IMMUTABLE))
     die ("failed to set immutable flag with const flag\n");
 
   second_one = gcry_mpi_copy (one);
   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_IMMUTABLE))
     die ("immutable flag not cleared after copy\n");
   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_CONST))
     die ("const flag not cleared after copy\n");
   gcry_mpi_release (second_one);
 
   gcry_mpi_clear_flag (one, GCRYMPI_FLAG_IMMUTABLE);
   if (!gcry_mpi_get_flag (one, GCRYMPI_FLAG_IMMUTABLE))
     die ("clearing immutable flag not ignored for a constant MPI\n");
   if (!gcry_mpi_get_flag (one, GCRYMPI_FLAG_CONST))
     die ("const flag unexpectly cleared\n");
 
 
   second_one = gcry_mpi_set (NULL, GCRYMPI_CONST_ONE);
   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_IMMUTABLE))
     die ("immutable flag not cleared by mpi_set (NULL,x)\n");
   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_CONST))
     die ("const flag not cleared by mpi_set (NULL,x)\n");
   gcry_mpi_release (second_one);
 
   second_one = gcry_mpi_set_ui (NULL, 42);
   gcry_mpi_set (second_one, GCRYMPI_CONST_ONE);
   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_IMMUTABLE))
     die ("immutable flag not cleared after mpi_set (a,x)\n");
   if (gcry_mpi_get_flag (second_one, GCRYMPI_FLAG_CONST))
     die ("const flag not cleared mpi_set (a,x)\n");
   gcry_mpi_release (second_one);
 
 
   /* Due to the the constant flag the release below should be a NOP
      and will leak memory.  */
   gcry_mpi_release (one);
   return 1;
 }
 
 
 static void
 test_opaque (void)
 {
   gcry_mpi_t a;
   char *p;
   unsigned int nbits;
 
   p = gcry_xstrdup ("This is a test buffer");
   a = gcry_mpi_set_opaque (NULL, p, 21*8+1); /* (a non byte aligned length) */
 
   if (!gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
     die ("opaque flag not set\n");
 
   p = gcry_mpi_get_opaque (a, &nbits);
   if (!p)
     die ("gcry_mpi_get_opaque returned NULL\n");
   if (nbits != 21*8+1)
     die ("gcry_mpi_get_opaque returned a changed bit size\n");
   if (strcmp (p, "This is a test buffer"))
     die ("gcry_mpi_get_opaque returned a changed buffer\n");
 
   if (debug)
     gcry_log_debugmpi ("mpi", a);
   gcry_mpi_release (a);
 
   p = gcry_xstrdup ("This is a test buffer");
   a = gcry_mpi_set_opaque_copy (NULL, p, 21*8+1);
   gcry_free (p);
 
   if (!gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
     die ("opaque flag not set\n");
 
   p = gcry_mpi_get_opaque (a, &nbits);
   if (!p)
     die ("gcry_mpi_get_opaque returned NULL\n");
   if (nbits != 21*8+1)
     die ("gcry_mpi_get_opaque returned a changed bit size\n");
   if (strcmp (p, "This is a test buffer"))
     die ("gcry_mpi_get_opaque returned a changed buffer\n");
 
   if (debug)
     gcry_log_debugmpi ("mpi", a);
 
   gcry_mpi_release (a);
 }
 
 
 static void
 test_maxsize (void)
 {
   gpg_error_t err;
   gcry_mpi_t a;
   unsigned int val;
   char buffer[2+2048]; /* For PGP: 2 length bytes and 16384 bits.  */
 
   memset (buffer, 0x55, sizeof buffer);
 
   /* We use a short buffer but a give a too large length to simulate a
    * programming error.  In case this test fails (i.e. die() is
    * called) the scan function may have access data outside of BUFFER
    * which may result in a segv but we ignore that to avoid actually
    * allocating such a long buffer.  */
   err = gcry_mpi_scan (&a, GCRYMPI_FMT_USG, buffer, 16*1024*1024 +1, NULL);
   if (gpg_err_code (err) != GPG_ERR_INV_OBJ)
     die ("gcry_mpi_scan does not detect its generic input limit\n");
 
   /* Now test the PGP limit.  The scan code check the two length bytes
    * from the buffer and thus it is sufficient to fake them.  */
   buffer[0] = (16385 >> 8);
   buffer[1] = (16385 & 0xff);
   err = gcry_mpi_scan (&a, GCRYMPI_FMT_PGP, buffer, sizeof buffer, NULL);
   if (gpg_err_code (err) != GPG_ERR_INV_OBJ)
     die ("gcry_mpi_scan does not detect the PGP input limit\n");
 
   buffer[0] = (16384 >> 8);
   buffer[1] = (16384 & 0xff);
 
   err = gcry_mpi_scan (&a, GCRYMPI_FMT_PGP, buffer, sizeof buffer, NULL);
   if (err)
     die ("gcry_mpi_scan did not parse a large PGP: %s\n", gpg_strerror (err));
 
   /* Let's also test get_ui.  */
   gcry_mpi_set_ui (a, 0);
   val = 4711;
   err = gcry_mpi_get_ui (&val, a);
   if (err || val != 0)
     die ("gcry_mpi_get_ui failed at %d: %s\n", __LINE__, gpg_strerror (err));
 
   gcry_mpi_sub_ui (a, a, 1);
   val = 4711;
   err = gcry_mpi_get_ui (&val, a);
   if (gpg_err_code (err) != GPG_ERR_ERANGE || val != 4711)
     die ("gcry_mpi_get_ui failed at %d: %s\n", __LINE__, gpg_strerror (err));
 
   gcry_mpi_set_ui (a, 0xffffffff);
   val = 4711;
   err = gcry_mpi_get_ui (&val, a);
   if (err || val != 0xffffffff)
     die ("gcry_mpi_get_ui failed at %d: %s\n", __LINE__, gpg_strerror (err));
 
   if (sizeof (val) == 4)
     {
       gcry_mpi_add_ui (a, a, 1);
       err = gcry_mpi_get_ui (&val, a);
       if (gpg_err_code (err) != GPG_ERR_ERANGE)
         die ("gcry_mpi_get_ui failed at %d: %s\n", __LINE__,gpg_strerror (err));
     }
 
   gcry_mpi_release (a);
 
 }
 
 
 static void
 test_cmp (void)
 {
   gpg_error_t rc;
   gcry_mpi_t zero, zero2;
   gcry_mpi_t one;
   gcry_mpi_t two;
   gcry_mpi_t all_ones;
   gcry_mpi_t opa1, opa2;
   gcry_mpi_t opa1s, opa2s;
   gcry_mpi_t opa0, opa02;
 
   zero = gcry_mpi_new (0);
   zero2= gcry_mpi_set_ui (NULL, 0);
   one  = gcry_mpi_set_ui (NULL, 1);
   two  = gcry_mpi_set_ui (NULL, 2);
   rc = gcry_mpi_scan (&all_ones, GCRYMPI_FMT_USG, ones, sizeof(ones), NULL);
   if (rc)
     die ("scanning number failed at line %d", __LINE__);
   opa0  = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("a"), 0);
   opa02 = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("b"), 0);
   opa1  = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("aaaaaaaaaaaaaaaa"), 16*8);
   opa1s = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("a"), 1*8);
   opa2  = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("bbbbbbbbbbbbbbbb"), 16*8);
   opa2s = gcry_mpi_set_opaque (NULL, gcry_xstrdup ("b"), 1*8);
 
 
   /* Single limb test with cmp_ui */
   if (gcry_mpi_cmp_ui (zero, 0))
     fail ("mpi_cmp_ui failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp_ui (zero, 1) < 0))
     fail ("mpi_cmp_ui failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp_ui (zero, (-1)) < 0))
     fail ("mpi_cmp_ui failed at line %d", __LINE__);
 
   if (gcry_mpi_cmp_ui (two, 2))
     fail ("mpi_cmp_ui failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp_ui (two, 3) < 0))
     fail ("mpi_cmp_ui failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp_ui (two, 1) > 0))
     fail ("mpi_cmp_ui failed at line %d", __LINE__);
 
   /* Multi limb tests with cmp_ui.  */
   if (!(gcry_mpi_cmp_ui (all_ones, 0) > 0))
     fail ("mpi_cmp_ui failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp_ui (all_ones, (-1)) > 0))
     fail ("mpi_cmp_ui failed at line %d", __LINE__);
 
   /* Single limb test with cmp */
   if (gcry_mpi_cmp (zero, zero2))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (zero, one) < 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (one, zero) > 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
 
   gcry_mpi_neg (one, one);
   if (!(gcry_mpi_cmp (zero, one) > 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (one, zero) < 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (one, two) < 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   gcry_mpi_neg (one, one);
 
   if (!(gcry_mpi_cmp (one, two) < 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (two, one) > 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (one, all_ones) < 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
 
   /* Tests with opaque values.  */
   if (!(gcry_mpi_cmp (opa1, one) < 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (one, opa1) > 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (opa0, opa02) == 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (opa1s, opa1) < 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (opa2, opa1s) > 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (opa1, opa2) < 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (opa2, opa1) > 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
   if (!(gcry_mpi_cmp (opa1, opa1) == 0))
     fail ("mpi_cmp failed at line %d", __LINE__);
 
 
   gcry_mpi_release(opa2s);
   gcry_mpi_release(opa2);
   gcry_mpi_release(opa1s);
   gcry_mpi_release(opa1);
   gcry_mpi_release(opa02);
   gcry_mpi_release(opa0);
   gcry_mpi_release(all_ones);
   gcry_mpi_release(two);
   gcry_mpi_release(one);
   gcry_mpi_release(zero2);
   gcry_mpi_release(zero);
 }
 
 
 static int
 test_add (void)
 {
   gcry_mpi_t one;
   gcry_mpi_t two;
   gcry_mpi_t ff;
   gcry_mpi_t result;
   unsigned char* pc;
 
   gcry_mpi_scan(&one, GCRYMPI_FMT_USG, ones, sizeof(ones), NULL);
   gcry_mpi_scan(&two, GCRYMPI_FMT_USG, twos, sizeof(twos), NULL);
   gcry_mpi_scan(&ff, GCRYMPI_FMT_USG, manyff, sizeof(manyff), NULL);
   result = gcry_mpi_new(0);
 
   gcry_mpi_add(result, one, two);
   gcry_mpi_aprint(GCRYMPI_FMT_HEX, &pc, NULL, result);
   if (debug)
     gcry_log_debug ("Result of one plus two:\n%s\n", pc);
   gcry_free(pc);
 
   gcry_mpi_add(result, ff, one);
   gcry_mpi_aprint(GCRYMPI_FMT_HEX, &pc, NULL, result);
   if (debug)
     gcry_log_debug ("Result of ff plus one:\n%s\n", pc);
   gcry_free(pc);
 
   gcry_mpi_release(one);
   gcry_mpi_release(two);
   gcry_mpi_release(ff);
   gcry_mpi_release(result);
   return 1;
 }
 
 
 static int
 test_sub (void)
 {
   gcry_mpi_t one;
   gcry_mpi_t two;
   gcry_mpi_t result;
   unsigned char* pc;
 
   gcry_mpi_scan(&one, GCRYMPI_FMT_USG, ones, sizeof(ones), NULL);
   gcry_mpi_scan(&two, GCRYMPI_FMT_USG, twos, sizeof(twos), NULL);
   result = gcry_mpi_new(0);
   gcry_mpi_sub(result, two, one);
 
   gcry_mpi_aprint(GCRYMPI_FMT_HEX, &pc, NULL, result);
   if (debug)
     gcry_log_debug ("Result of two minus one:\n%s\n", pc);
   gcry_free(pc);
 
   gcry_mpi_release(one);
   gcry_mpi_release(two);
   gcry_mpi_release(result);
   return 1;
 }
 
 
 static int
 test_mul (void)
 {
   gcry_mpi_t two;
   gcry_mpi_t three;
   gcry_mpi_t result;
   unsigned char* pc;
 
   gcry_mpi_scan(&two, GCRYMPI_FMT_USG, twos, sizeof(twos), NULL);
   gcry_mpi_scan(&three, GCRYMPI_FMT_USG, threes, sizeof(threes), NULL);
   result = gcry_mpi_new(0);
   gcry_mpi_mul(result, two, three);
 
   gcry_mpi_aprint(GCRYMPI_FMT_HEX, &pc, NULL, result);
   if (debug)
     gcry_log_debug ("Result of two mul three:\n%s\n", pc);
   gcry_free(pc);
 
   gcry_mpi_release(two);
   gcry_mpi_release(three);
   gcry_mpi_release(result);
   return 1;
 }
 
 
 /* What we test here is that we don't overwrite our args and that
    using the same mpi for several args works.  */
 static int
 test_powm (void)
 {
   int b_int = 17;
   int e_int = 3;
   int m_int = 19;
   gcry_mpi_t base = gcry_mpi_set_ui (NULL, b_int);
   gcry_mpi_t exp = gcry_mpi_set_ui (NULL, e_int);
   gcry_mpi_t mod = gcry_mpi_set_ui (NULL, m_int);
   gcry_mpi_t res = gcry_mpi_new (0);
 
   gcry_mpi_powm (res, base, exp, mod);
   if (gcry_mpi_cmp_ui (base, b_int))
     die ("test_powm failed for base at %d\n", __LINE__);
   if (gcry_mpi_cmp_ui (exp, e_int))
     die ("test_powm_ui failed for exp at %d\n", __LINE__);
   if (gcry_mpi_cmp_ui (mod, m_int))
     die ("test_powm failed for mod at %d\n", __LINE__);
 
   /* Check using base for the result.  */
   gcry_mpi_set_ui (base, b_int);
   gcry_mpi_set_ui (exp, e_int);
   gcry_mpi_set_ui(mod, m_int);
   gcry_mpi_powm (base, base, exp, mod);
   if (gcry_mpi_cmp (res, base))
     die ("test_powm failed at %d\n", __LINE__);
   if (gcry_mpi_cmp_ui (exp, e_int))
     die ("test_powm_ui failed for exp at %d\n", __LINE__);
   if (gcry_mpi_cmp_ui (mod, m_int))
     die ("test_powm failed for mod at %d\n", __LINE__);
 
   /* Check using exp for the result.  */
   gcry_mpi_set_ui (base, b_int);
   gcry_mpi_set_ui (exp, e_int);
   gcry_mpi_set_ui(mod, m_int);
   gcry_mpi_powm (exp, base, exp, mod);
   if (gcry_mpi_cmp (res, exp))
     die ("test_powm failed at %d\n", __LINE__);
   if (gcry_mpi_cmp_ui (base, b_int))
     die ("test_powm failed for base at %d\n", __LINE__);
   if (gcry_mpi_cmp_ui (mod, m_int))
     die ("test_powm failed for mod at %d\n", __LINE__);
 
   /* Check using mod for the result.  */
   gcry_mpi_set_ui (base, b_int);
   gcry_mpi_set_ui (exp, e_int);
   gcry_mpi_set_ui(mod, m_int);
   gcry_mpi_powm (mod, base, exp, mod);
   if (gcry_mpi_cmp (res, mod))
     die ("test_powm failed at %d\n", __LINE__);
   if (gcry_mpi_cmp_ui (base, b_int))
     die ("test_powm failed for base at %d\n", __LINE__);
   if (gcry_mpi_cmp_ui (exp, e_int))
     die ("test_powm_ui failed for exp at %d\n", __LINE__);
 
   /* Now check base ^ base mod mod.  */
   gcry_mpi_set_ui (base, b_int);
   gcry_mpi_set_ui(mod, m_int);
   gcry_mpi_powm (res, base, base, mod);
   if (gcry_mpi_cmp_ui (base, b_int))
     die ("test_powm failed for base at %d\n", __LINE__);
   if (gcry_mpi_cmp_ui (mod, m_int))
     die ("test_powm failed for mod at %d\n", __LINE__);
 
   /* Check base ^ base mod mod with base as result.  */
   gcry_mpi_set_ui (base, b_int);
   gcry_mpi_set_ui(mod, m_int);
   gcry_mpi_powm (base, base, base, mod);
   if (gcry_mpi_cmp (res, base))
     die ("test_powm failed at %d\n", __LINE__);
   if (gcry_mpi_cmp_ui (mod, m_int))
     die ("test_powm failed for mod at %d\n", __LINE__);
 
   /* Check base ^ base mod mod with mod as result.  */
   gcry_mpi_set_ui (base, b_int);
   gcry_mpi_set_ui(mod, m_int);
   gcry_mpi_powm (mod, base, base, mod);
   if (gcry_mpi_cmp (res, mod))
     die ("test_powm failed at %d\n", __LINE__);
   if (gcry_mpi_cmp_ui (base, b_int))
     die ("test_powm failed for base at %d\n", __LINE__);
 
   /* Now check base ^ base mod base.  */
   gcry_mpi_set_ui (base, b_int);
   gcry_mpi_powm (res, base, base, base);
   if (gcry_mpi_cmp_ui (base, b_int))
     die ("test_powm failed for base at %d\n", __LINE__);
 
   /* Check base ^ base mod base with base as result.  */
   gcry_mpi_set_ui (base, b_int);
   gcry_mpi_powm (base, base, base, base);
   if (gcry_mpi_cmp (res, base))
     die ("test_powm failed at %d\n", __LINE__);
 
   /* Check for a case: base is negative and expo is even.  */
   gcry_mpi_set_ui (base, b_int);
   gcry_mpi_neg (base, base);
   gcry_mpi_set_ui (exp, e_int * 2);
   gcry_mpi_set_ui(mod, m_int);
   gcry_mpi_powm (res, base, exp, mod);
   /* Result should be positive and it's 7 = (-17)^6 mod 19.  */
   if (gcry_mpi_is_neg (res) || gcry_mpi_cmp_ui (res, 7))
     {
       if (verbose)
         {
           fprintf (stderr, "is_neg: %d\n", gcry_mpi_is_neg (res));
           fprintf (stderr, "mpi: ");
           gcry_mpi_dump (res);
           putc ('\n', stderr);
         }
       die ("test_powm failed for negative base at %d\n", __LINE__);
     }
 
   gcry_mpi_release (base);
   gcry_mpi_release (exp);
   gcry_mpi_release (mod);
   gcry_mpi_release (res);
   /* Fixme: We should add the rest of the cases of course.  */
 
 
 
   return 1;
 }
 
 
 int
 main (int argc, char* argv[])
 {
   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     verbose = 1;
   else if (argc > 1 && !strcmp (argv[1], "--debug"))
     verbose = debug = 1;
 
   if (!gcry_check_version (GCRYPT_VERSION))
     {
       fputs ("version mismatch\n", stderr);
       exit (1);
     }
-  xgcry_control(GCRYCTL_DISABLE_SECMEM);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM));
 
   test_const_and_immutable ();
   test_opaque ();
   test_maxsize ();
   test_cmp ();
   test_add ();
   test_sub ();
   test_mul ();
   test_powm ();
 
   return !!error_count;
 }
diff --git a/tests/pkbench.c b/tests/pkbench.c
index e458b429..a7665f46 100644
--- a/tests/pkbench.c
+++ b/tests/pkbench.c
@@ -1,485 +1,485 @@
 /* pkbench.c - Pubkey menchmarking
  * Copyright (C) 2004, 2005, 2008 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <gcrypt.h>
 #include <assert.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <sys/stat.h>
 #ifndef HAVE_W32_SYSTEM
 # include <sys/times.h>
 #endif /*HAVE_W32_SYSTEM*/
 #include <unistd.h>
 #include <fcntl.h>
 #include <time.h>
 #include <errno.h>
 
 #define PGM "pkbench"
 #include "t-common.h"
 
 
 typedef struct context
 {
   gcry_sexp_t key_secret;
   gcry_sexp_t key_public;
   gcry_sexp_t data;
   gcry_sexp_t data_encrypted;
   gcry_sexp_t data_signed;
 } *context_t;
 
 typedef int (*work_t) (context_t context, unsigned int final);
 
 
 static void
 show_sexp (const char *prefix, gcry_sexp_t a)
 {
   char *buf;
   size_t size;
 
   fputs (prefix, stderr);
   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   buf = gcry_xmalloc (size);
 
   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
   fprintf (stderr, "%.*s", (int)size, buf);
   gcry_free (buf);
 }
 
 
 static void *
 read_file (const char *fname, size_t *r_length)
 {
   FILE *fp;
   struct stat st;
   char *buf;
   size_t buflen;
 
   fp = fopen (fname, "rb");
   if (!fp)
     {
       fail ("can't open `%s': %s\n", fname, strerror (errno));
       return NULL;
     }
 
   if (fstat (fileno(fp), &st))
     {
       fail ("can't stat `%s': %s\n", fname, strerror (errno));
       fclose (fp);
       return NULL;
     }
 
   buflen = st.st_size;
   buf = gcry_xmalloc (buflen+1);
   if (fread (buf, buflen, 1, fp) != 1)
     {
       fail ("error reading `%s': %s\n", fname, strerror (errno));
       fclose (fp);
       gcry_free (buf);
       return NULL;
     }
   fclose (fp);
 
   if (r_length)
     *r_length = buflen;
   return buf;
 }
 
 
 
 static void
 benchmark (work_t worker, context_t context)
 {
   clock_t timer_start, timer_stop;
   unsigned int loop = 10;
   unsigned int i = 0;
   struct tms timer;
   int ret = 0;
 
 #ifdef HAVE_W32_SYSTEM
   timer_start = clock ();
 #else
   times (&timer);
   timer_start = timer.tms_utime;
 #endif
   for (i = 0; i < loop; i++)
     {
       ret = (*worker) (context, (i + 1) == loop);
       if (! ret)
 	break;
     }
 #ifdef HAVE_W32_SYSTEM
   timer_stop = clock ();
 #else
   times (&timer);
   timer_stop = timer.tms_utime;
 #endif
 
   if (ret)
     printf ("%.0f ms\n",
 	    (((double) ((timer_stop - timer_start) / loop)) / CLOCKS_PER_SEC)
 	    * 10000000);
   else
     printf ("[skipped]\n");
 }
 
 static int
 work_encrypt (context_t context, unsigned int final)
 {
   gcry_error_t err = GPG_ERR_NO_ERROR;
   gcry_sexp_t data_encrypted = NULL;
   int ret = 1;
 
   err = gcry_pk_encrypt (&data_encrypted,
 			 context->data, context->key_public);
   if (gpg_err_code (err) == GPG_ERR_NOT_IMPLEMENTED)
     {
       err = GPG_ERR_NO_ERROR;
       ret = 0;
     }
   else
     {
       assert (! err);
 
       if (final)
 	context->data_encrypted = data_encrypted;
       else
 	gcry_sexp_release (data_encrypted);
     }
 
   return ret;
 }
 
 static int
 work_decrypt (context_t context, unsigned int final)
 {
   gcry_error_t err = GPG_ERR_NO_ERROR;
   int ret = 1;
 
   if (! context->data_encrypted)
     ret = 0;
   else
     {
       gcry_sexp_t data_decrypted = NULL;
 
       err = gcry_pk_decrypt (&data_decrypted,
 			     context->data_encrypted,
 			     context->key_secret);
       assert (! err);
       if (final)
 	{
 	  gcry_sexp_release (context->data_encrypted);
 	  context->data_encrypted = NULL;
 	}
       gcry_sexp_release (data_decrypted);
     }
 
   return ret;
 }
 
 static int
 work_sign (context_t context, unsigned int final)
 {
   gcry_error_t err = GPG_ERR_NO_ERROR;
   gcry_sexp_t data_signed = NULL;
   int ret = 1;
 
   err = gcry_pk_sign (&data_signed,
 		      context->data, context->key_secret);
   if (gpg_err_code (err) == GPG_ERR_NOT_IMPLEMENTED)
     {
       err = GPG_ERR_NO_ERROR;
       ret = 0;
     }
   else if (err)
     {
       fail ("pk_sign failed: %s\n", gpg_strerror (err));
       ret = 0;
     }
   else
     {
       if (final)
 	context->data_signed = data_signed;
       else
 	gcry_sexp_release (data_signed);
     }
 
   return ret;
 }
 
 static int
 work_verify (context_t context, unsigned int final)
 {
   gcry_error_t err = GPG_ERR_NO_ERROR;
   int ret = 1;
 
   if (!context->data_signed)
     return 0;
 
   err = gcry_pk_verify (context->data_signed,
                         context->data,
                         context->key_public);
   if (err)
     {
       show_sexp ("data_signed:\n", context->data_signed);
       show_sexp ("data:\n", context->data);
       fail ("pk_verify failed: %s\n", gpg_strerror (err));
       ret = 0;
     }
   else if (final)
     {
       gcry_sexp_release (context->data_signed);
       context->data_signed = NULL;
     }
 
   return ret;
 }
 
 static void
 process_key_pair (context_t context)
 {
   struct
   {
     work_t worker;
     const char *identifier;
   } worker_functions[] = { { work_encrypt, "encrypt" },
 			   { work_decrypt, "decrypt" },
 			   { work_sign,    "sign"    },
 			   { work_verify,  "verify"  } };
   unsigned int i = 0;
 
   for (i = 0; i < (sizeof (worker_functions) / sizeof (*worker_functions)); i++)
     {
       printf ("%s: ", worker_functions[i].identifier);
       benchmark (worker_functions[i].worker, context);
     }
 }
 
 static void
 context_init (context_t context, gcry_sexp_t key_secret, gcry_sexp_t key_public)
 {
   gcry_error_t err = GPG_ERR_NO_ERROR;
   unsigned int key_size = 0;
   gcry_mpi_t data = NULL;
   gcry_sexp_t data_sexp = NULL;
 
   key_size = gcry_pk_get_nbits (key_secret);
   assert (key_size);
 
   data = gcry_mpi_new (key_size);
   assert (data);
 
   gcry_mpi_randomize (data, key_size, GCRY_STRONG_RANDOM);
   gcry_mpi_clear_bit (data, key_size - 1);
   err = gcry_sexp_build (&data_sexp, NULL,
 			 "(data (flags raw) (value %m))",
 			 data);
   assert (! err);
   gcry_mpi_release (data);
 
   context->key_secret = key_secret;
   context->key_public = key_public;
   context->data = data_sexp;
   context->data_encrypted = NULL;
   context->data_signed = NULL;
 }
 
 static void
 context_destroy (context_t context)
 {
   gcry_sexp_release (context->key_secret);
   gcry_sexp_release (context->key_public);
   gcry_sexp_release (context->data);
 }
 
 static void
 process_key_pair_file (const char *key_pair_file)
 {
   gcry_error_t err = GPG_ERR_NO_ERROR;
   void *key_pair_buffer = NULL;
   gcry_sexp_t key_pair_sexp = NULL;
   gcry_sexp_t key_secret_sexp = NULL;
   gcry_sexp_t key_public_sexp = NULL;
   struct context context = { NULL };
   size_t file_length;
 
   key_pair_buffer = read_file (key_pair_file, &file_length);
   if (!key_pair_buffer)
     die ("failed to open `%s'\n", key_pair_file);
 
   err = gcry_sexp_sscan (&key_pair_sexp, NULL,
 			 key_pair_buffer, file_length);
   if (err)
     die ("gcry_sexp_sscan failed\n");
 
   key_secret_sexp = gcry_sexp_find_token (key_pair_sexp, "private-key", 0);
   assert (key_secret_sexp);
   key_public_sexp = gcry_sexp_find_token (key_pair_sexp, "public-key", 0);
   assert (key_public_sexp);
 
   gcry_sexp_release (key_pair_sexp);
 
   context_init (&context, key_secret_sexp, key_public_sexp);
 
   printf ("Key file: %s\n", key_pair_file);
   process_key_pair (&context);
   printf ("\n");
 
   context_destroy (&context);
   gcry_free (key_pair_buffer);
 }
 
 
 static void
 generate_key (const char *algorithm, const char *key_size)
 {
   gcry_error_t err = GPG_ERR_NO_ERROR;
   size_t key_pair_buffer_size = 0;
   char *key_pair_buffer = NULL;
   gcry_sexp_t key_spec = NULL;
   gcry_sexp_t key_pair = NULL;
 
   if (isdigit ((unsigned int)*key_size))
     err = gcry_sexp_build (&key_spec, NULL,
                            "(genkey (%s (nbits %s)))",
                            algorithm, key_size);
   else
     err = gcry_sexp_build (&key_spec, NULL,
                            "(genkey (%s (curve %s)))",
                            algorithm, key_size);
   if (err)
     die ("sexp_build failed: %s\n", gpg_strerror (err));
 
   err = gcry_pk_genkey (&key_pair, key_spec);
   if (err)
     {
       show_sexp ("request:\n", key_spec);
       die ("pk_genkey failed: %s\n", gpg_strerror (err));
     }
 
   key_pair_buffer_size = gcry_sexp_sprint (key_pair, GCRYSEXP_FMT_ADVANCED,
 					   NULL, 0);
   key_pair_buffer = gcry_xmalloc (key_pair_buffer_size);
 
   gcry_sexp_sprint (key_pair, GCRYSEXP_FMT_ADVANCED,
 		    key_pair_buffer, key_pair_buffer_size);
 
   printf ("%.*s", (int)key_pair_buffer_size, key_pair_buffer);
   gcry_free (key_pair_buffer);
 }
 
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   int genkey_mode = 0;
   int fips_mode = 0;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           puts ("Usage: " PGM " [OPTIONS] [FILES]\n"
                 "Various public key tests:\n\n"
                 "  Default is to process all given key files\n\n"
                 "  --genkey ALGONAME SIZE  Generate a public key\n"
                 "\n"
                 "  --verbose    enable extra informational output\n"
                 "  --debug      enable additional debug output\n"
                 "  --help       display this help and exit\n\n");
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose = debug = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--genkey"))
         {
           genkey_mode = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--fips"))
         {
           fips_mode = 1;
           argc--; argv++;
         }
     }
 
-  xgcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
+  xgcry_control ((GCRYCTL_SET_VERBOSITY, (int)verbose));
 
   if (fips_mode)
-    xgcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
+    xgcry_control ((GCRYCTL_FORCE_FIPS_MODE, 0));
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM));
   if (!gcry_check_version (GCRYPT_VERSION))
     {
       fprintf (stderr, PGM ": version mismatch\n");
       exit (1);
     }
 
   if (genkey_mode)
     {
       /* No valuable keys are create, so we can speed up our RNG. */
-      xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+      xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
     }
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
 
   if (genkey_mode && argc == 2)
     {
       generate_key (argv[0], argv[1]);
     }
   else if (!genkey_mode && argc)
     {
       int i;
 
       for (i = 0; i < argc; i++)
 	process_key_pair_file (argv[i]);
     }
   else
     {
       fprintf (stderr, "usage: " PGM
                " [OPTIONS] [FILES] (try --help for more information)\n");
       exit (1);
     }
 
   return error_count ? 1 : 0;
 }
diff --git a/tests/pkcs1v2.c b/tests/pkcs1v2.c
index b52bff81..968d3fea 100644
--- a/tests/pkcs1v2.c
+++ b/tests/pkcs1v2.c
@@ -1,676 +1,676 @@
 /* pkcs1v2.c - Test OAEP and PSS padding
  * Copyright (C) 2011 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 
 #ifdef _GCRYPT_IN_LIBGCRYPT
 # include "../src/gcrypt-int.h"
 #else
 # include <gcrypt.h>
 #endif
 
 
 #define PGM "pkcs1v2"
 #include "t-common.h"
 
 
 static void
 show_sexp (const char *prefix, gcry_sexp_t a)
 {
   char *buf;
   size_t size;
 
   if (prefix)
     fputs (prefix, stderr);
   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   buf = gcry_xmalloc (size);
 
   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
   fprintf (stderr, "%.*s", (int)size, buf);
   gcry_free (buf);
 }
 
 
 /* Convert STRING consisting of hex characters into its binary
    representation and return it as an allocated buffer. The valid
    length of the buffer is returned at R_LENGTH.  The string is
    delimited by end of string.  The function returns NULL on
    error.  */
 static void *
 data_from_hex (const char *string, size_t *r_length)
 {
   const char *s;
   unsigned char *buffer;
   size_t length;
 
   buffer = gcry_xmalloc (strlen(string)/2+1);
   length = 0;
   for (s=string; *s; s +=2 )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         die ("error parsing hex string `%s'\n", string);
       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     }
   *r_length = length;
   return buffer;
 }
 
 
 static int
 extract_cmp_data (gcry_sexp_t sexp, const char *name, const char *expected,
                   const char *description)
 {
   gcry_sexp_t l1;
   const void *a;
   size_t alen;
   void *b;
   size_t blen;
   int rc = 0;
 
   l1 = gcry_sexp_find_token (sexp, name, 0);
   a = gcry_sexp_nth_data (l1, 1, &alen);
   b = data_from_hex (expected, &blen);
   if (!a)
     {
       info ("%s: parameter \"%s\" missing in key\n", description, name);
       rc = 1;
     }
   else if ( alen != blen || memcmp (a, b, alen) )
     {
       info ("%s: parameter \"%s\" does not match expected value\n",
             description, name);
       rc = 1;
     }
   gcry_free (b);
   gcry_sexp_release (l1);
   return rc;
 }
 
 
 /* Check against the OAEP test vectors from
    ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1d2-vec.zip .  */
 static void
 check_oaep (void)
 {
 #include "pkcs1v2-oaep.h"
   gpg_error_t err;
   int tno, mno;
 
   for (tno = 0; tno < DIM (tbl); tno++)
     {
       void *rsa_n, *rsa_e, *rsa_d;
       size_t rsa_n_len, rsa_e_len, rsa_d_len;
       gcry_sexp_t sec_key, pub_key;
 
       if (verbose > 1)
         info ("(%s)\n", tbl[tno].desc);
 
       rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
       rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
       rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
       err = gcry_sexp_build (&sec_key, NULL,
                              "(private-key (rsa (n %b)(e %b)(d %b)))",
                              (int)rsa_n_len, rsa_n,
                              (int)rsa_e_len, rsa_e,
                              (int)rsa_d_len, rsa_d);
       if (err)
         die ("constructing private key failed: %s\n", gpg_strerror (err));
       err = gcry_sexp_build (&pub_key, NULL,
                              "(public-key (rsa (n %b)(e %b)))",
                              (int)rsa_n_len, rsa_n,
                              (int)rsa_e_len, rsa_e);
       if (err)
         die ("constructing public key failed: %s\n", gpg_strerror (err));
       gcry_free (rsa_n);
       gcry_free (rsa_e);
       gcry_free (rsa_d);
 
       for (mno = 0; mno < DIM (tbl[0].m); mno++)
         {
           void *mesg, *seed, *encr;
           size_t mesg_len, seed_len, encr_len;
           gcry_sexp_t plain, ciph;
 
           if (verbose)
             info ("running test: %s\n", tbl[tno].m[mno].desc);
 
           mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
           seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
 
           err = gcry_sexp_build (&plain, NULL,
                                  "(data (flags oaep)(hash-algo sha1)"
                                  "(value %b)(random-override %b))",
                                  (int)mesg_len, mesg,
                                  (int)seed_len, seed);
           if (err)
             die ("constructing plain data failed: %s\n", gpg_strerror (err));
           gcry_free (mesg);
           gcry_free (seed);
 
           err = gcry_pk_encrypt (&ciph, plain, pub_key);
           if (err)
             {
               show_sexp ("plain:\n", ciph);
               fail ("gcry_pk_encrypt failed: %s\n", gpg_strerror (err));
             }
           else
             {
               if (extract_cmp_data (ciph, "a", tbl[tno].m[mno].encr,
                                     tbl[tno].m[mno].desc))
                 {
                   show_sexp ("encrypt result:\n", ciph);
                   fail ("mismatch in gcry_pk_encrypt\n");
                 }
               gcry_sexp_release (ciph);
               ciph = NULL;
             }
           gcry_sexp_release (plain);
           plain = NULL;
 
           /* Now test the decryption.  */
           seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
           encr = data_from_hex (tbl[tno].m[mno].encr, &encr_len);
 
           err = gcry_sexp_build (&ciph, NULL,
                                  "(enc-val (flags oaep)(hash-algo sha1)"
                                  "(random-override %b)"
                                  "(rsa (a %b)))",
                                  (int)seed_len, seed,
                                  (int)encr_len, encr);
           if (err)
             die ("constructing cipher data failed: %s\n", gpg_strerror (err));
           gcry_free (encr);
           gcry_free (seed);
 
           err = gcry_pk_decrypt (&plain, ciph, sec_key);
           if (err)
             {
               show_sexp ("ciph:\n", ciph);
               fail ("gcry_pk_decrypt failed: %s\n", gpg_strerror (err));
             }
           else
             {
               if (extract_cmp_data (plain, "value", tbl[tno].m[mno].mesg,
                                     tbl[tno].m[mno].desc))
                 {
                   show_sexp ("decrypt result:\n", plain);
                   fail ("mismatch in gcry_pk_decrypt\n");
                 }
               gcry_sexp_release (plain);
               plain = NULL;
             }
           gcry_sexp_release (ciph);
           ciph = NULL;
         }
 
       gcry_sexp_release (sec_key);
       gcry_sexp_release (pub_key);
     }
 }
 
 
 /* Check against the PSS test vectors from
    ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1d2-vec.zip .  */
 static void
 check_pss (void)
 {
 #include "pkcs1v2-pss.h"
   gpg_error_t err;
   int tno, mno;
 
   for (tno = 0; tno < DIM (tbl); tno++)
     {
       void *rsa_n, *rsa_e, *rsa_d;
       size_t rsa_n_len, rsa_e_len, rsa_d_len;
       gcry_sexp_t sec_key, pub_key;
 
       if (verbose > 1)
         info ("(%s)\n", tbl[tno].desc);
 
       rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
       rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
       rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
       err = gcry_sexp_build (&sec_key, NULL,
                              "(private-key (rsa (n %b)(e %b)(d %b)))",
                              (int)rsa_n_len, rsa_n,
                              (int)rsa_e_len, rsa_e,
                              (int)rsa_d_len, rsa_d);
       if (err)
         die ("constructing private key failed: %s\n", gpg_strerror (err));
       err = gcry_sexp_build (&pub_key, NULL,
                              "(public-key (rsa (n %b)(e %b)))",
                              (int)rsa_n_len, rsa_n,
                              (int)rsa_e_len, rsa_e);
       if (err)
         die ("constructing public key failed: %s\n", gpg_strerror (err));
       gcry_free (rsa_n);
       gcry_free (rsa_e);
       gcry_free (rsa_d);
 
       for (mno = 0; mno < DIM (tbl[0].m); mno++)
         {
           void *mesg, *salt, *sign;
           size_t mesg_len, salt_len, sign_len;
           gcry_sexp_t sigtmpl, sig;
           char mhash[20];
 
           if (verbose)
             info ("running test: %s\n", tbl[tno].m[mno].desc);
 
           mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
           salt = data_from_hex (tbl[tno].m[mno].salt, &salt_len);
 
           gcry_md_hash_buffer (GCRY_MD_SHA1, mhash, mesg, mesg_len);
           err = gcry_sexp_build (&sigtmpl, NULL,
                                  "(data (flags pss)"
                                  "(hash sha1 %b)"
                                  "(random-override %b))",
                                  20, mhash,
                                  (int)salt_len, salt);
           if (err)
             die ("constructing sig template failed: %s\n", gpg_strerror (err));
           gcry_free (mesg);
           gcry_free (salt);
 
           err = gcry_pk_sign (&sig, sigtmpl, sec_key);
           if (err)
             {
               show_sexp ("sigtmpl:\n", sigtmpl);
               fail ("gcry_pk_sign failed: %s\n", gpg_strerror (err));
             }
           else
             {
               if (extract_cmp_data (sig, "s", tbl[tno].m[mno].sign,
                                     tbl[tno].m[mno].desc))
                 {
                   show_sexp ("sign result:\n", sig);
                   fail ("mismatch in gcry_pk_sign\n");
                 }
               gcry_sexp_release (sig);
               sig = NULL;
             }
           gcry_sexp_release (sigtmpl);
           sigtmpl = NULL;
 
           /* Now test the verification.  */
           salt = data_from_hex (tbl[tno].m[mno].salt, &salt_len);
           sign = data_from_hex (tbl[tno].m[mno].sign, &sign_len);
 
           err = gcry_sexp_build (&sig, NULL,
                                  "(sig-val(rsa(s %b)))",
                                  (int)sign_len, sign);
           if (err)
             die ("constructing verify data failed: %s\n", gpg_strerror (err));
           err = gcry_sexp_build (&sigtmpl, NULL,
                                  "(data (flags pss)"
                                  "(hash sha1 %b)"
                                  "(random-override %b))",
                                  20, mhash,
                                  (int)salt_len, salt);
           if (err)
             die ("constructing verify tmpl failed: %s\n", gpg_strerror (err));
           gcry_free (sign);
           gcry_free (salt);
 
           err = gcry_pk_verify (sig, sigtmpl, pub_key);
           if (err)
             {
               show_sexp ("sig:\n", sig);
               show_sexp ("sigtmpl:\n", sigtmpl);
               fail ("gcry_pk_verify failed: %s\n", gpg_strerror (err));
             }
           gcry_sexp_release (sig);
           sig = NULL;
           gcry_sexp_release (sigtmpl);
           sigtmpl = NULL;
         }
 
       gcry_sexp_release (sec_key);
       gcry_sexp_release (pub_key);
     }
 }
 
 
 /* Check against PKCS#1 v1.5 encryption test  vectors as found at
    ftp://ftp.rsa.com/pub/rsalabs/tmp/pkcs1v15crypt-vectors.txt .  */
 static void
 check_v15crypt (void)
 {
 #include "pkcs1v2-v15c.h"
   gpg_error_t err;
   int tno, mno;
 
   for (tno = 0; tno < DIM (tbl); tno++)
     {
       void *rsa_n, *rsa_e, *rsa_d;
       size_t rsa_n_len, rsa_e_len, rsa_d_len;
       gcry_sexp_t sec_key, pub_key;
 
       if (verbose > 1)
         info ("(%s)\n", tbl[tno].desc);
 
       rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
       rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
       rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
       err = gcry_sexp_build (&sec_key, NULL,
                              "(private-key (rsa (n %b)(e %b)(d %b)))",
                              (int)rsa_n_len, rsa_n,
                              (int)rsa_e_len, rsa_e,
                              (int)rsa_d_len, rsa_d);
       if (err)
         die ("constructing private key failed: %s\n", gpg_strerror (err));
       err = gcry_sexp_build (&pub_key, NULL,
                              "(public-key (rsa (n %b)(e %b)))",
                              (int)rsa_n_len, rsa_n,
                              (int)rsa_e_len, rsa_e);
       if (err)
         die ("constructing public key failed: %s\n", gpg_strerror (err));
       gcry_free (rsa_n);
       gcry_free (rsa_e);
       gcry_free (rsa_d);
 
       for (mno = 0; mno < DIM (tbl[0].m); mno++)
         {
           void *mesg, *seed, *encr;
           size_t mesg_len, seed_len, encr_len;
           gcry_sexp_t plain, ciph;
 
           if (verbose)
             info ("running test: %s\n", tbl[tno].m[mno].desc);
 
           mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
           seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
 
           err = gcry_sexp_build (&plain, NULL,
                                  "(data (flags pkcs1)(hash-algo sha1)"
                                  "(value %b)(random-override %b))",
                                  (int)mesg_len, mesg,
                                  (int)seed_len, seed);
           if (err)
             die ("constructing plain data failed: %s\n", gpg_strerror (err));
           gcry_free (mesg);
           gcry_free (seed);
 
           err = gcry_pk_encrypt (&ciph, plain, pub_key);
           if (err)
             {
               show_sexp ("plain:\n", ciph);
               fail ("gcry_pk_encrypt failed: %s\n", gpg_strerror (err));
             }
           else
             {
               if (extract_cmp_data (ciph, "a", tbl[tno].m[mno].encr,
                                     tbl[tno].m[mno].desc))
                 {
                   show_sexp ("encrypt result:\n", ciph);
                   fail ("mismatch in gcry_pk_encrypt\n");
                 }
               gcry_sexp_release (ciph);
               ciph = NULL;
             }
           gcry_sexp_release (plain);
           plain = NULL;
 
           /* Now test the decryption.  */
           seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
           encr = data_from_hex (tbl[tno].m[mno].encr, &encr_len);
 
           err = gcry_sexp_build (&ciph, NULL,
                                  "(enc-val (flags pkcs1)(hash-algo sha1)"
                                  "(random-override %b)"
                                  "(rsa (a %b)))",
                                  (int)seed_len, seed,
                                  (int)encr_len, encr);
           if (err)
             die ("constructing cipher data failed: %s\n", gpg_strerror (err));
           gcry_free (encr);
           gcry_free (seed);
 
           err = gcry_pk_decrypt (&plain, ciph, sec_key);
           if (err)
             {
               show_sexp ("ciph:\n", ciph);
               fail ("gcry_pk_decrypt failed: %s\n", gpg_strerror (err));
             }
           else
             {
               if (extract_cmp_data (plain, "value", tbl[tno].m[mno].mesg,
                                     tbl[tno].m[mno].desc))
                 {
                   show_sexp ("decrypt result:\n", plain);
                   fail ("mismatch in gcry_pk_decrypt\n");
                 }
               gcry_sexp_release (plain);
               plain = NULL;
             }
           gcry_sexp_release (ciph);
           ciph = NULL;
         }
 
       gcry_sexp_release (sec_key);
       gcry_sexp_release (pub_key);
     }
 }
 
 
 /* Check against PKCS#1 v1.5 signature test vectors as found at
    ftp://ftp.rsa.com/pub/rsalabs/tmp/pkcs1v15sign-vectors.txt .  */
 static void
 check_v15sign (void)
 {
 #include "pkcs1v2-v15s.h"
   gpg_error_t err;
   int tno, mno;
 
   for (tno = 0; tno < DIM (tbl); tno++)
     {
       void *rsa_n, *rsa_e, *rsa_d;
       size_t rsa_n_len, rsa_e_len, rsa_d_len;
       gcry_sexp_t sec_key, pub_key;
 
       if (verbose > 1)
         info ("(%s)\n", tbl[tno].desc);
 
       rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
       rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
       rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
       err = gcry_sexp_build (&sec_key, NULL,
                              "(private-key (rsa (n %b)(e %b)(d %b)))",
                              (int)rsa_n_len, rsa_n,
                              (int)rsa_e_len, rsa_e,
                              (int)rsa_d_len, rsa_d);
       if (err)
         die ("constructing private key failed: %s\n", gpg_strerror (err));
       err = gcry_sexp_build (&pub_key, NULL,
                              "(public-key (rsa (n %b)(e %b)))",
                              (int)rsa_n_len, rsa_n,
                              (int)rsa_e_len, rsa_e);
       if (err)
         die ("constructing public key failed: %s\n", gpg_strerror (err));
       gcry_free (rsa_n);
       gcry_free (rsa_e);
       gcry_free (rsa_d);
 
       for (mno = 0; mno < DIM (tbl[0].m); mno++)
         {
           void *mesg, *sign;
           size_t mesg_len, sign_len;
           gcry_sexp_t sigtmpl, sig;
           char mhash[20];
 
           if (verbose)
             info ("running test: %s\n", tbl[tno].m[mno].desc);
 
           mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
 
           gcry_md_hash_buffer (GCRY_MD_SHA1, mhash, mesg, mesg_len);
           err = gcry_sexp_build (&sigtmpl, NULL,
                                  "(data (flags pkcs1)"
                                  "(hash sha1 %b))",
                                  20, mhash);
           if (err)
             die ("constructing sig template failed: %s\n", gpg_strerror (err));
           gcry_free (mesg);
 
           err = gcry_pk_sign (&sig, sigtmpl, sec_key);
           if (err)
             {
               show_sexp ("sigtmpl:\n", sigtmpl);
               fail ("gcry_pk_sign failed: %s\n", gpg_strerror (err));
             }
           else
             {
               if (extract_cmp_data (sig, "s", tbl[tno].m[mno].sign,
                                     tbl[tno].m[mno].desc))
                 {
                   show_sexp ("sign result:\n", sig);
                   fail ("mismatch in gcry_pk_sign\n");
                 }
               gcry_sexp_release (sig);
               sig = NULL;
             }
           gcry_sexp_release (sigtmpl);
           sigtmpl = NULL;
 
           /* Now test the verification.  */
           sign = data_from_hex (tbl[tno].m[mno].sign, &sign_len);
 
           err = gcry_sexp_build (&sig, NULL,
                                  "(sig-val(rsa(s %b)))",
                                  (int)sign_len, sign);
           if (err)
             die ("constructing verify data failed: %s\n", gpg_strerror (err));
           err = gcry_sexp_build (&sigtmpl, NULL,
                                  "(data (flags pkcs1)"
                                  "(hash sha1 %b))",
                                  20, mhash);
           if (err)
             die ("constructing verify tmpl failed: %s\n", gpg_strerror (err));
           gcry_free (sign);
 
           err = gcry_pk_verify (sig, sigtmpl, pub_key);
           if (err)
             {
               show_sexp ("sig:\n", sig);
               show_sexp ("sigtmpl:\n", sigtmpl);
               fail ("gcry_pk_verify failed: %s\n", gpg_strerror (err));
             }
           gcry_sexp_release (sig);
           sig = NULL;
           gcry_sexp_release (sigtmpl);
           sigtmpl = NULL;
         }
 
       gcry_sexp_release (sec_key);
       gcry_sexp_release (pub_key);
     }
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   int run_oaep = 0;
   int run_pss = 0;
   int run_v15c = 0;
   int run_v15s = 0;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose = 2;
           debug = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--die"))
         {
           die_on_error = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--oaep"))
         {
           run_oaep = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--pss"))
         {
           run_pss = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--v15c"))
         {
           run_v15c = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--v15s"))
         {
           run_v15s = 1;
           argc--; argv++;
         }
     }
 
   if (!run_oaep && !run_pss && !run_v15c && !run_v15s)
     run_oaep = run_pss = run_v15c = run_v15s = 1;
 
-  xgcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  xgcry_control ((GCRYCTL_SET_VERBOSITY, (int)verbose));
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
   if (!gcry_check_version ("1.5.0"))
     die ("version mismatch\n");
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
   /* No valuable keys are create, so we can speed up our RNG. */
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
 
   if (run_oaep)
     check_oaep ();
   if (run_pss)
     check_pss ();
   if (run_v15c)
     check_v15crypt ();
   if (run_v15s)
     check_v15sign ();
 
   if (verbose)
     fprintf (stderr, "\nAll tests completed.  Errors: %i\n", error_count);
 
   return error_count ? 1 : 0;
 }
diff --git a/tests/prime.c b/tests/prime.c
index 5e90ce06..42264980 100644
--- a/tests/prime.c
+++ b/tests/prime.c
@@ -1,241 +1,241 @@
 /* prime.c - part of the Libgcrypt test suite.
    Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
    USA.  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 
 #define PGM "prime"
 #include "t-common.h"
 
 static void
 check_primes (void)
 {
   gcry_error_t err = GPG_ERR_NO_ERROR;
   gcry_mpi_t *factors = NULL;
   gcry_mpi_t prime = NULL;
   gcry_mpi_t g;
   unsigned int i = 0;
   struct prime_spec
   {
     unsigned int prime_bits;
     unsigned int factor_bits;
     unsigned int flags;
   } prime_specs[] =
     {
       { 1024, 100, GCRY_PRIME_FLAG_SPECIAL_FACTOR },
       { 128, 0, 0 },
       { 0 },
     };
 
   for (i = 0; prime_specs[i].prime_bits; i++)
     {
       err = gcry_prime_generate (&prime,
 				 prime_specs[i].prime_bits,
 				 prime_specs[i].factor_bits,
 				 &factors,
 				 NULL, NULL,
 				 GCRY_WEAK_RANDOM,
 				 prime_specs[i].flags);
       assert (! err);
       if (verbose)
         {
           fprintf (stderr, "test %d: p = ", i);
           gcry_mpi_dump (prime);
           putc ('\n', stderr);
         }
 
       err = gcry_prime_check (prime, 0);
       assert (! err);
 
       err = gcry_prime_group_generator (&g, prime, factors, NULL);
       assert (!err);
       gcry_prime_release_factors (factors); factors = NULL;
 
       if (verbose)
         {
           fprintf (stderr, "     %d: g = ", i);
           gcry_mpi_dump (g);
           putc ('\n', stderr);
         }
       gcry_mpi_release (g);
 
 
       gcry_mpi_add_ui (prime, prime, 1);
       err = gcry_prime_check (prime, 0);
       assert (err);
       gcry_mpi_release (prime); prime = NULL;
     }
 }
 
 
 /* Print an MPI S-expression.  */
 static void
 print_mpi (const char *name, gcry_mpi_t a)
 {
   gcry_error_t err;
   unsigned char *buf;
   int writerr = 0;
 
   err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buf, NULL, a);
   if (err)
     die ("gcry_mpi_aprint failed: %s\n", gcry_strerror (err));
 
   printf ("  (%s #%s#)\n", name, buf);
   if (ferror (stdout))
     writerr++;
   if (!writerr && fflush (stdout) == EOF)
     writerr++;
   if (writerr)
     die ("writing output failed\n");
   gcry_free (buf);
 }
 
 
 /* Create the key for our public standard dummy CA.  */
 static void
 create_42prime (void)
 {
   gcry_error_t err;
   char string[128*2+1];
   int i;
   gcry_mpi_t start = NULL;
   gcry_mpi_t p, q, n, t1, t2, phi, f, g, e, d, u;
 
 
   /* Our start value is a string of 0x42 values, with the exception
      that the two high order bits are set.  This is to resemble the
      way Lingcrypt generates RSA primes.  */
   for (i=0; i < 128;)
     {
       string[i++] = '4';
       string[i++] = '2';
     }
   string[i] = 0;
   string[0] = 'C';
 
   err = gcry_mpi_scan (&start, GCRYMPI_FMT_HEX, string, 0, NULL);
   if (err)
     die ("gcry_mpi_scan failed: %s\n", gcry_strerror (err));
   fputs ("start:", stderr); gcry_mpi_dump (start); putc ('\n', stderr);
 
   /* Generate two primes with p < q.  We take the first primes below
      and above a start value. */
   p = gcry_mpi_copy (start);
   gcry_mpi_sub_ui (p, p, 1);
   while (gcry_prime_check (p, 0))
     gcry_mpi_sub_ui (p, p, 2);
   fputs ("    p:", stderr); gcry_mpi_dump (p); putc ('\n', stderr);
   q = gcry_mpi_copy (start);
   gcry_mpi_add_ui (q, q, 1);
   while (gcry_prime_check (q, 0))
     gcry_mpi_add_ui (q, q, 2);
   fputs ("    q:", stderr); gcry_mpi_dump (q); putc ('\n', stderr);
 
   /* Compute the modulus.  */
   n = gcry_mpi_new (1024);
   gcry_mpi_mul (n, p, q);
   fputs ("    n:", stderr); gcry_mpi_dump (n); putc ('\n', stderr);
   if (gcry_mpi_get_nbits (n) != 1024)
     die ("Oops: the size of N is not 1024 but %u\n", gcry_mpi_get_nbits (n));
 
   /* Calculate Euler totient: phi = (p-1)(q-1) */
   t1 = gcry_mpi_new (0);
   t2 = gcry_mpi_new (0);
   phi = gcry_mpi_new (0);
   g   = gcry_mpi_new (0);
   f   = gcry_mpi_new (0);
   gcry_mpi_sub_ui (t1, p, 1);
   gcry_mpi_sub_ui (t2, q, 1);
   gcry_mpi_mul (phi, t1, t2);
   gcry_mpi_gcd (g, t1, t2);
   gcry_mpi_div (f, NULL, phi, g, -1);
 
   /* Check the public exponent.  */
   e = gcry_mpi_set_ui (NULL, 65537);
   if (!gcry_mpi_gcd (t1, e, phi))
     die ("Oops: E is not a generator\n");
   fputs ("    e:", stderr); gcry_mpi_dump (e); putc ('\n', stderr);
 
   /* Compute the secret key:  d = e^-1 mod phi */
   d = gcry_mpi_new (0);
   gcry_mpi_invm (d, e, f );
   fputs ("    d:", stderr); gcry_mpi_dump (d); putc ('\n', stderr);
 
   /* Compute the inverse of p and q. */
   u = gcry_mpi_new (0);
   gcry_mpi_invm (u, p, q);
   fputs ("    u:", stderr); gcry_mpi_dump (u); putc ('\n', stderr);
 
   /* Print the S-expression.  */
   fputs ("(private-key\n (rsa\n", stdout);
   print_mpi ("n", n);
   print_mpi ("e", e);
   print_mpi ("d", d);
   print_mpi ("p", p);
   print_mpi ("q", q);
   print_mpi ("u", u);
   fputs ("))\n", stdout);
 
   gcry_mpi_release (p);
   gcry_mpi_release (q);
   gcry_mpi_release (n);
   gcry_mpi_release (t1);
   gcry_mpi_release (t2);
   gcry_mpi_release (phi);
   gcry_mpi_release (f);
   gcry_mpi_release (g);
   gcry_mpi_release (e);
   gcry_mpi_release (d);
   gcry_mpi_release (u);
 }
 
 
 
 
 int
 main (int argc, char **argv)
 {
   int mode42 = 0;
 
   if ((argc > 1) && (! strcmp (argv[1], "--verbose")))
     verbose = 1;
   else if ((argc > 1) && (! strcmp (argv[1], "--debug")))
     verbose = debug = 1;
   else if ((argc > 1) && (! strcmp (argv[1], "--42")))
     verbose = debug = mode42 = 1;
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
   if (! gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
 
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
 
   if (mode42)
     create_42prime ();
   else
     check_primes ();
 
   return 0;
 }
diff --git a/tests/pubkey.c b/tests/pubkey.c
index fbb7bbb5..748d051e 100644
--- a/tests/pubkey.c
+++ b/tests/pubkey.c
@@ -1,1202 +1,1202 @@
 /* pubkey.c - Public key encryption/decryption tests
  *	Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 
 #define PGM "pubkey"
 #include "t-common.h"
 
 
 /* Sample RSA keys, taken from basic.c.  */
 
 static const char sample_private_key_1[] =
 "(private-key\n"
 " (openpgp-rsa\n"
 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
 "  (e #010001#)\n"
 "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
       "7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
       "C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
       "C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
 "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
       "fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424f1#)\n"
 "  (q #00f7a7ca5367c661f8e62df34f0d05c10c88e5492348dd7bddc942c9a8f369f9"
       "35a07785d2db805215ed786e4285df1658eed3ce84f469b81b50d358407b4ad361#)\n"
 "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
       "ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b#)\n"
 " )\n"
 ")\n";
 
 /* The same key as above but without p, q and u to test the non CRT case. */
 static const char sample_private_key_1_1[] =
 "(private-key\n"
 " (openpgp-rsa\n"
 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
 "  (e #010001#)\n"
 "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
       "7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
       "C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
       "C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
 " )\n"
 ")\n";
 
 /* The same key as above but just without q to test the non CRT case.  This
    should fail. */
 static const char sample_private_key_1_2[] =
 "(private-key\n"
 " (openpgp-rsa\n"
 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
 "  (e #010001#)\n"
 "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
       "7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
       "C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
       "C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
 "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
       "fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424f1#)\n"
 "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
       "ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b#)\n"
 " )\n"
 ")\n";
 
 static const char sample_public_key_1[] =
 "(public-key\n"
 " (rsa\n"
 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
 "  (e #010001#)\n"
 " )\n"
 ")\n";
 
 
 static void
 show_sexp (const char *prefix, gcry_sexp_t a)
 {
   char *buf;
   size_t size;
 
   if (prefix)
     fputs (prefix, stderr);
   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   buf = gcry_xmalloc (size);
 
   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
   fprintf (stderr, "%.*s", (int)size, buf);
   gcry_free (buf);
 }
 
 /* from ../cipher/pubkey-util.c */
 static gpg_err_code_t
 _gcry_pk_util_get_nbits (gcry_sexp_t list, unsigned int *r_nbits)
 {
   char buf[50];
   const char *s;
   size_t n;
 
   *r_nbits = 0;
 
   list = gcry_sexp_find_token (list, "nbits", 0);
   if (!list)
     return 0; /* No NBITS found.  */
 
   s = gcry_sexp_nth_data (list, 1, &n);
   if (!s || n >= DIM (buf) - 1 )
     {
       /* NBITS given without a cdr.  */
       gcry_sexp_release (list);
       return GPG_ERR_INV_OBJ;
     }
   memcpy (buf, s, n);
   buf[n] = 0;
   *r_nbits = (unsigned int)strtoul (buf, NULL, 0);
   gcry_sexp_release (list);
   return 0;
 }
 
 /* Convert STRING consisting of hex characters into its binary
    representation and return it as an allocated buffer. The valid
    length of the buffer is returned at R_LENGTH.  The string is
    delimited by end of string.  The function returns NULL on
    error.  */
 static void *
 data_from_hex (const char *string, size_t *r_length)
 {
   const char *s;
   unsigned char *buffer;
   size_t length;
 
   buffer = gcry_xmalloc (strlen(string)/2+1);
   length = 0;
   for (s=string; *s; s +=2 )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         die ("error parsing hex string `%s'\n", string);
       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     }
   *r_length = length;
   return buffer;
 }
 
 
 static void
 extract_cmp_data (gcry_sexp_t sexp, const char *name, const char *expected)
 {
   gcry_sexp_t l1;
   const void *a;
   size_t alen;
   void *b;
   size_t blen;
 
   l1 = gcry_sexp_find_token (sexp, name, 0);
   a = gcry_sexp_nth_data (l1, 1, &alen);
   b = data_from_hex (expected, &blen);
   if (!a)
     fail ("parameter \"%s\" missing in key\n", name);
   else if ( alen != blen || memcmp (a, b, alen) )
     {
       fail ("parameter \"%s\" does not match expected value\n", name);
       if (verbose)
         {
           info ("expected: %s\n", expected);
           show_sexp ("sexp: ", sexp);
         }
     }
   gcry_free (b);
   gcry_sexp_release (l1);
 }
 
 
 static void
 check_keys_crypt (gcry_sexp_t pkey, gcry_sexp_t skey,
 		  gcry_sexp_t plain0, gpg_err_code_t decrypt_fail_code)
 {
   gcry_sexp_t plain1, cipher, l;
   gcry_mpi_t x0, x1;
   int rc;
   int have_flags;
 
   /* Extract data from plaintext.  */
   l = gcry_sexp_find_token (plain0, "value", 0);
   x0 = gcry_sexp_nth_mpi (l, 1, GCRYMPI_FMT_USG);
   gcry_sexp_release (l);
 
   /* Encrypt data.  */
   rc = gcry_pk_encrypt (&cipher, plain0, pkey);
   if (rc)
     die ("encryption failed: %s\n", gcry_strerror (rc));
 
   l = gcry_sexp_find_token (cipher, "flags", 0);
   have_flags = !!l;
   gcry_sexp_release (l);
 
   /* Decrypt data.  */
   rc = gcry_pk_decrypt (&plain1, cipher, skey);
   gcry_sexp_release (cipher);
   if (rc)
     {
       if (decrypt_fail_code && gpg_err_code (rc) == decrypt_fail_code)
 	{
 	  gcry_mpi_release (x0);
 	  return; /* This is the expected failure code.  */
 	}
       die ("decryption failed: %s\n", gcry_strerror (rc));
     }
 
   /* Extract decrypted data.  Note that for compatibility reasons, the
      output of gcry_pk_decrypt depends on whether a flags lists (even
      if empty) occurs in its input data.  Because we passed the output
      of encrypt directly to decrypt, such a flag value won't be there
      as of today.  We check it anyway. */
   l = gcry_sexp_find_token (plain1, "value", 0);
   if (l)
     {
       if (!have_flags)
         die ("compatibility mode of pk_decrypt broken\n");
       gcry_sexp_release (plain1);
       x1 = gcry_sexp_nth_mpi (l, 1, GCRYMPI_FMT_USG);
       gcry_sexp_release (l);
     }
   else
     {
       if (have_flags)
         die ("compatibility mode of pk_decrypt broken\n");
       x1 = gcry_sexp_nth_mpi (plain1, 0, GCRYMPI_FMT_USG);
       gcry_sexp_release (plain1);
     }
 
   /* Compare.  */
   if (gcry_mpi_cmp (x0, x1))
     die ("data corrupted\n");
   gcry_mpi_release (x0);
   gcry_mpi_release (x1);
 }
 
 static void
 check_keys (gcry_sexp_t pkey, gcry_sexp_t skey, unsigned int nbits_data,
             gpg_err_code_t decrypt_fail_code)
 {
   gcry_sexp_t plain;
   gcry_mpi_t x;
   int rc;
 
   /* Create plain text.  */
   x = gcry_mpi_new (nbits_data);
   gcry_mpi_randomize (x, nbits_data, GCRY_WEAK_RANDOM);
 
   rc = gcry_sexp_build (&plain, NULL, "(data (flags raw) (value %m))", x);
   if (rc)
     die ("converting data for encryption failed: %s\n",
 	 gcry_strerror (rc));
 
   check_keys_crypt (pkey, skey, plain, decrypt_fail_code);
   gcry_sexp_release (plain);
   gcry_mpi_release (x);
 
   /* Create plain text.  */
   x = gcry_mpi_new (nbits_data);
   gcry_mpi_randomize (x, nbits_data, GCRY_WEAK_RANDOM);
 
   rc = gcry_sexp_build (&plain, NULL,
                         "(data (flags raw no-blinding) (value %m))", x);
   gcry_mpi_release (x);
   if (rc)
     die ("converting data for encryption failed: %s\n",
 	 gcry_strerror (rc));
 
   check_keys_crypt (pkey, skey, plain, decrypt_fail_code);
   gcry_sexp_release (plain);
 }
 
 static void
 get_keys_sample (gcry_sexp_t *pkey, gcry_sexp_t *skey, int secret_variant)
 {
   gcry_sexp_t pub_key, sec_key;
   int rc;
   static const char *secret;
 
 
   switch (secret_variant)
     {
     case 0: secret = sample_private_key_1; break;
     case 1: secret = sample_private_key_1_1; break;
     case 2: secret = sample_private_key_1_2; break;
     default: die ("BUG\n");
     }
 
   rc = gcry_sexp_sscan (&pub_key, NULL, sample_public_key_1,
 			strlen (sample_public_key_1));
   if (!rc)
     rc = gcry_sexp_sscan (&sec_key, NULL, secret, strlen (secret));
   if (rc)
     die ("converting sample keys failed: %s\n", gcry_strerror (rc));
 
   *pkey = pub_key;
   *skey = sec_key;
 }
 
 static void
 get_keys_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
 {
   gcry_sexp_t key_spec, key, pub_key, sec_key;
   int rc;
 
   rc = gcry_sexp_new (&key_spec,
 		      "(genkey (rsa (nbits 4:2048)))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gcry_strerror (rc));
   rc = gcry_pk_genkey (&key, key_spec);
   gcry_sexp_release (key_spec);
   if (rc)
     die ("error generating RSA key: %s\n", gcry_strerror (rc));
 
   if (verbose > 1)
     show_sexp ("generated RSA key:\n", key);
 
   pub_key = gcry_sexp_find_token (key, "public-key", 0);
   if (! pub_key)
     die ("public part missing in key\n");
 
   sec_key = gcry_sexp_find_token (key, "private-key", 0);
   if (! sec_key)
     die ("private part missing in key\n");
 
   gcry_sexp_release (key);
   *pkey = pub_key;
   *skey = sec_key;
 }
 
 
 static void
 get_keys_x931_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
 {
   gcry_sexp_t key_spec, key, pub_key, sec_key;
   int rc;
 
   rc = gcry_sexp_new (&key_spec,
 		      "(genkey (rsa (nbits 4:2048)(use-x931)))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gcry_strerror (rc));
   rc = gcry_pk_genkey (&key, key_spec);
   gcry_sexp_release (key_spec);
   if (rc)
     die ("error generating RSA key: %s\n", gcry_strerror (rc));
 
   if (verbose > 1)
     show_sexp ("generated RSA (X9.31) key:\n", key);
 
   pub_key = gcry_sexp_find_token (key, "public-key", 0);
   if (!pub_key)
     die ("public part missing in key\n");
 
   sec_key = gcry_sexp_find_token (key, "private-key", 0);
   if (!sec_key)
     die ("private part missing in key\n");
 
   gcry_sexp_release (key);
   *pkey = pub_key;
   *skey = sec_key;
 }
 
 
 static void
 get_elg_key_new (gcry_sexp_t *pkey, gcry_sexp_t *skey, int fixed_x)
 {
   gcry_sexp_t key_spec, key, pub_key, sec_key;
   int rc;
 
   rc = gcry_sexp_new
     (&key_spec,
      (fixed_x
       ? "(genkey (elg (nbits 4:1024)(xvalue my.not-so-secret.key)))"
       : "(genkey (elg (nbits 3:512)))"),
      0, 1);
 
   if (rc)
     die ("error creating S-expression: %s\n", gcry_strerror (rc));
   rc = gcry_pk_genkey (&key, key_spec);
   gcry_sexp_release (key_spec);
   if (rc)
     die ("error generating Elgamal key: %s\n", gcry_strerror (rc));
 
   if (verbose > 1)
     show_sexp ("generated ELG key:\n", key);
 
   pub_key = gcry_sexp_find_token (key, "public-key", 0);
   if (!pub_key)
     die ("public part missing in key\n");
 
   sec_key = gcry_sexp_find_token (key, "private-key", 0);
   if (!sec_key)
     die ("private part missing in key\n");
 
   gcry_sexp_release (key);
   *pkey = pub_key;
   *skey = sec_key;
 }
 
 
 static void
 get_dsa_key_new (gcry_sexp_t *pkey, gcry_sexp_t *skey, int transient_key)
 {
   gcry_sexp_t key_spec, key, pub_key, sec_key;
   int rc;
 
   rc = gcry_sexp_new (&key_spec,
                       transient_key
                       ? "(genkey (dsa (nbits 4:2048)(transient-key)))"
                       : "(genkey (dsa (nbits 4:2048)))",
                       0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gcry_strerror (rc));
   rc = gcry_pk_genkey (&key, key_spec);
   gcry_sexp_release (key_spec);
   if (rc)
     die ("error generating DSA key: %s\n", gcry_strerror (rc));
 
   if (verbose > 1)
     show_sexp ("generated DSA key:\n", key);
 
   pub_key = gcry_sexp_find_token (key, "public-key", 0);
   if (!pub_key)
     die ("public part missing in key\n");
 
   sec_key = gcry_sexp_find_token (key, "private-key", 0);
   if (!sec_key)
     die ("private part missing in key\n");
 
   gcry_sexp_release (key);
   *pkey = pub_key;
   *skey = sec_key;
 }
 
 
 static void
 get_dsa_key_fips186_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
 {
   gcry_sexp_t key_spec, key, pub_key, sec_key;
   int rc;
 
   rc = gcry_sexp_new
     (&key_spec, "(genkey (dsa (nbits 4:2048)(use-fips186)))",  0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gcry_strerror (rc));
   rc = gcry_pk_genkey (&key, key_spec);
   gcry_sexp_release (key_spec);
   if (rc)
     die ("error generating DSA key: %s\n", gcry_strerror (rc));
 
   if (verbose > 1)
     show_sexp ("generated DSA key (fips 186):\n", key);
 
   pub_key = gcry_sexp_find_token (key, "public-key", 0);
   if (!pub_key)
     die ("public part missing in key\n");
 
   sec_key = gcry_sexp_find_token (key, "private-key", 0);
   if (!sec_key)
     die ("private part missing in key\n");
 
   gcry_sexp_release (key);
   *pkey = pub_key;
   *skey = sec_key;
 }
 
 
 static void
 get_dsa_key_with_domain_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
 {
   gcry_sexp_t key_spec, key, pub_key, sec_key;
   int rc;
 
   rc = gcry_sexp_new
     (&key_spec,
      "(genkey (dsa (transient-key)(domain"
      "(p #d3aed1876054db831d0c1348fbb1ada72507e5fbf9a62cbd47a63aeb7859d6921"
      "4adeb9146a6ec3f43520f0fd8e3125dd8bbc5d87405d1ac5f82073cd762a3f8d7"
      "74322657c9da88a7d2f0e1a9ceb84a39cb40876179e6a76e400498de4bb9379b0"
      "5f5feb7b91eb8fea97ee17a955a0a8a37587a272c4719d6feb6b54ba4ab69#)"
      "(q #9c916d121de9a03f71fb21bc2e1c0d116f065a4f#)"
      "(g #8157c5f68ca40b3ded11c353327ab9b8af3e186dd2e8dade98761a0996dda99ab"
      "0250d3409063ad99efae48b10c6ab2bba3ea9a67b12b911a372a2bba260176fad"
      "b4b93247d9712aad13aa70216c55da9858f7a298deb670a403eb1e7c91b847f1e"
      "ccfbd14bd806fd42cf45dbb69cd6d6b43add2a78f7d16928eaa04458dea44#)"
      ")))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gcry_strerror (rc));
   rc = gcry_pk_genkey (&key, key_spec);
   gcry_sexp_release (key_spec);
   if (rc)
     die ("error generating DSA key: %s\n", gcry_strerror (rc));
 
   if (verbose > 1)
     show_sexp ("generated DSA key:\n", key);
 
   pub_key = gcry_sexp_find_token (key, "public-key", 0);
   if (!pub_key)
     die ("public part missing in key\n");
 
   sec_key = gcry_sexp_find_token (key, "private-key", 0);
   if (!sec_key)
     die ("private part missing in key\n");
 
   gcry_sexp_release (key);
   *pkey = pub_key;
   *skey = sec_key;
 }
 
 #if 0
 static void
 get_dsa_key_fips186_with_domain_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
 {
   gcry_sexp_t key_spec, key, pub_key, sec_key;
   int rc;
 
   rc = gcry_sexp_new
     (&key_spec,
      "(genkey (dsa (transient-key)(use-fips186)(domain"
      "(p #d3aed1876054db831d0c1348fbb1ada72507e5fbf9a62cbd47a63aeb7859d6921"
      "4adeb9146a6ec3f43520f0fd8e3125dd8bbc5d87405d1ac5f82073cd762a3f8d7"
      "74322657c9da88a7d2f0e1a9ceb84a39cb40876179e6a76e400498de4bb9379b0"
      "5f5feb7b91eb8fea97ee17a955a0a8a37587a272c4719d6feb6b54ba4ab69#)"
      "(q #9c916d121de9a03f71fb21bc2e1c0d116f065a4f#)"
      "(g #8157c5f68ca40b3ded11c353327ab9b8af3e186dd2e8dade98761a0996dda99ab"
      "0250d3409063ad99efae48b10c6ab2bba3ea9a67b12b911a372a2bba260176fad"
      "b4b93247d9712aad13aa70216c55da9858f7a298deb670a403eb1e7c91b847f1e"
      "ccfbd14bd806fd42cf45dbb69cd6d6b43add2a78f7d16928eaa04458dea44#)"
      ")))", 0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gcry_strerror (rc));
   rc = gcry_pk_genkey (&key, key_spec);
   gcry_sexp_release (key_spec);
   if (rc)
     die ("error generating DSA key: %s\n", gcry_strerror (rc));
 
   if (verbose > 1)
     show_sexp ("generated DSA key:\n", key);
 
   pub_key = gcry_sexp_find_token (key, "public-key", 0);
   if (!pub_key)
     die ("public part missing in key\n");
 
   sec_key = gcry_sexp_find_token (key, "private-key", 0);
   if (!sec_key)
     die ("private part missing in key\n");
 
   gcry_sexp_release (key);
   *pkey = pub_key;
   *skey = sec_key;
 }
 #endif /*0*/
 
 static void
 get_dsa_key_fips186_with_seed_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
 {
   gcry_sexp_t key_spec, key, pub_key, sec_key;
   int rc;
 
   rc = gcry_sexp_new
     (&key_spec,
      "(genkey"
      "  (dsa"
      "    (nbits 4:2048)"
      "    (use-fips186)"
      "    (transient-key)"
      "    (derive-parms"
      "      (seed #0cb1990c1fd3626055d7a0096f8fa99807399871#))))",
      0, 1);
   if (rc)
     die ("error creating S-expression: %s\n", gcry_strerror (rc));
   rc = gcry_pk_genkey (&key, key_spec);
   gcry_sexp_release (key_spec);
   if (rc)
     die ("error generating DSA key: %s\n", gcry_strerror (rc));
 
   if (verbose > 1)
     show_sexp ("generated DSA key (fips 186 with seed):\n", key);
 
   pub_key = gcry_sexp_find_token (key, "public-key", 0);
   if (!pub_key)
     die ("public part missing in key\n");
 
   sec_key = gcry_sexp_find_token (key, "private-key", 0);
   if (!sec_key)
     die ("private part missing in key\n");
 
   gcry_sexp_release (key);
   *pkey = pub_key;
   *skey = sec_key;
 }
 
 
 static void
 check_run (void)
 {
   gpg_error_t err;
   gcry_sexp_t pkey, skey;
   int variant;
 
   for (variant=0; variant < 3; variant++)
     {
       if (verbose)
         fprintf (stderr, "Checking sample key (%d).\n", variant);
       get_keys_sample (&pkey, &skey, variant);
       /* Check gcry_pk_testkey which requires all elements.  */
       err = gcry_pk_testkey (skey);
       if ((variant == 0 && err)
           || (variant > 0 && gpg_err_code (err) != GPG_ERR_NO_OBJ))
           die ("gcry_pk_testkey failed: %s\n", gpg_strerror (err));
       /* Run the usual check but expect an error from variant 2.  */
       check_keys (pkey, skey, 800, variant == 2? GPG_ERR_NO_OBJ : 0);
       gcry_sexp_release (pkey);
       gcry_sexp_release (skey);
     }
 
   if (verbose)
     fprintf (stderr, "Checking generated RSA key.\n");
   get_keys_new (&pkey, &skey);
   check_keys (pkey, skey, 800, 0);
   gcry_sexp_release (pkey);
   gcry_sexp_release (skey);
 
   if (verbose)
     fprintf (stderr, "Checking generated RSA key (X9.31).\n");
   get_keys_x931_new (&pkey, &skey);
   check_keys (pkey, skey, 800, 0);
   gcry_sexp_release (pkey);
   gcry_sexp_release (skey);
 
   if (verbose)
     fprintf (stderr, "Checking generated Elgamal key.\n");
   get_elg_key_new (&pkey, &skey, 0);
   check_keys (pkey, skey, 400, 0);
   gcry_sexp_release (pkey);
   gcry_sexp_release (skey);
 
   if (verbose)
     fprintf (stderr, "Checking passphrase generated Elgamal key.\n");
   get_elg_key_new (&pkey, &skey, 1);
   check_keys (pkey, skey, 800, 0);
   gcry_sexp_release (pkey);
   gcry_sexp_release (skey);
 
   if (verbose)
     fprintf (stderr, "Generating DSA key.\n");
   get_dsa_key_new (&pkey, &skey, 0);
   /* Fixme:  Add a check function for DSA keys.  */
   gcry_sexp_release (pkey);
   gcry_sexp_release (skey);
 
   if (!gcry_fips_mode_active ())
     {
       if (verbose)
         fprintf (stderr, "Generating transient DSA key.\n");
       get_dsa_key_new (&pkey, &skey, 1);
       /* Fixme:  Add a check function for DSA keys.  */
       gcry_sexp_release (pkey);
       gcry_sexp_release (skey);
     }
 
   if (verbose)
     fprintf (stderr, "Generating DSA key (FIPS 186).\n");
   get_dsa_key_fips186_new (&pkey, &skey);
   /* Fixme:  Add a check function for DSA keys.  */
   gcry_sexp_release (pkey);
   gcry_sexp_release (skey);
 
   if (verbose)
     fprintf (stderr, "Generating DSA key with given domain.\n");
   get_dsa_key_with_domain_new (&pkey, &skey);
   /* Fixme:  Add a check function for DSA keys.  */
   gcry_sexp_release (pkey);
   gcry_sexp_release (skey);
 
   /* We need new test vectors for get_dsa_key_fips186_with_domain_new.  */
   if (verbose)
     fprintf (stderr, "Generating DSA key with given domain (FIPS 186)"
              " - skipped.\n");
   /* get_dsa_key_fips186_with_domain_new (&pkey, &skey); */
   /* /\* Fixme:  Add a check function for DSA keys.  *\/ */
   /* gcry_sexp_release (pkey); */
   /* gcry_sexp_release (skey); */
 
   if (verbose)
     fprintf (stderr, "Generating DSA key with given seed (FIPS 186).\n");
   get_dsa_key_fips186_with_seed_new (&pkey, &skey);
   /* Fixme:  Add a check function for DSA keys.  */
   gcry_sexp_release (pkey);
   gcry_sexp_release (skey);
 }
 
 
 
 static gcry_mpi_t
 key_param_from_sexp (gcry_sexp_t sexp, const char *topname, const char *name)
 {
   gcry_sexp_t l1, l2;
   gcry_mpi_t result;
 
   l1 = gcry_sexp_find_token (sexp, topname, 0);
   if (!l1)
     return NULL;
 
   l2 = gcry_sexp_find_token (l1, name, 0);
   if (!l2)
     {
       gcry_sexp_release (l1);
       return NULL;
     }
 
   result = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
   gcry_sexp_release (l2);
   gcry_sexp_release (l1);
   return result;
 }
 
 
 static void
 check_x931_derived_key (int what)
 {
   static struct {
     const char *param;
     const char *expected_d;
   } testtable[] = {
     { /* First example from X9.31 (D.1.1).  */
       "(genkey\n"
       "  (rsa\n"
       "    (nbits 4:1024)\n"
       "    (rsa-use-e 1:3)\n"
       "    (derive-parms\n"
       "      (Xp1 #1A1916DDB29B4EB7EB6732E128#)\n"
       "      (Xp2 #192E8AAC41C576C822D93EA433#)\n"
       "      (Xp  #D8CD81F035EC57EFE822955149D3BFF70C53520D\n"
       "            769D6D76646C7A792E16EBD89FE6FC5B605A6493\n"
       "            39DFC925A86A4C6D150B71B9EEA02D68885F5009\n"
       "            B98BD984#)\n"
       "      (Xq1 #1A5CF72EE770DE50CB09ACCEA9#)\n"
       "      (Xq2 #134E4CAA16D2350A21D775C404#)\n"
       "      (Xq  #CC1092495D867E64065DEE3E7955F2EBC7D47A2D\n"
       "            7C9953388F97DDDC3E1CA19C35CA659EDC2FC325\n"
       "            6D29C2627479C086A699A49C4C9CEE7EF7BD1B34\n"
       "            321DE34A#))))\n",
       "1CCDA20BCFFB8D517EE9666866621B11822C7950D55F4BB5BEE37989A7D173"
       "12E326718BE0D79546EAAE87A56623B919B1715FFBD7F16028FC4007741961"
       "C88C5D7B4DAAAC8D36A98C9EFBB26C8A4A0E6BC15B358E528A1AC9D0F042BE"
       "B93BCA16B541B33F80C933A3B769285C462ED5677BFE89DF07BED5C127FD13"
       "241D3C4B"
     },
 
     { /* Second example from X9.31 (D.2.1).  */
       "(genkey\n"
       "  (rsa\n"
       "    (nbits 4:1536)\n"
       "    (rsa-use-e 1:3)\n"
       "    (derive-parms\n"
       "      (Xp1 #18272558B61316348297EACA74#)\n"
       "      (Xp2 #1E970E8C6C97CEF91F05B0FA80#)\n"
       "      (Xp  #F7E943C7EF2169E930DCF23FE389EF7507EE8265\n"
       "            0D42F4A0D3A3CEFABE367999BB30EE680B2FE064\n"
       "            60F707F46005F8AA7CBFCDDC4814BBE7F0F8BC09\n"
       "            318C8E51A48D134296E40D0BBDD282DCCBDDEE1D\n"
       "            EC86F0B1C96EAFF5CDA70F9AEB6EE31E#)\n"
       "      (Xq1 #11FDDA6E8128DC1629F75192BA#)\n"
       "      (Xq2 #18AB178ECA907D72472F65E480#)\n"
       "      (Xq  #C47560011412D6E13E3E7D007B5C05DBF5FF0D0F\n"
       "            CFF1FA2070D16C7ABA93EDFB35D8700567E5913D\n"
       "            B734E3FBD15862EBC59FA0425DFA131E549136E8\n"
       "            E52397A8ABE4705EC4877D4F82C4AAC651B33DA6\n"
       "            EA14B9D5F2A263DC65626E4D6CEAC767#))))\n",
       "1FB56069985F18C4519694FB71055721A01F14422DC901C35B03A64D4A5BD1"
       "259D573305F5B056AC931B82EDB084E39A0FD1D1A86CC5B147A264F7EF4EB2"
       "0ED1E7FAAE5CAE4C30D5328B7F74C3CAA72C88B70DED8EDE207B8629DA2383"
       "B78C3CE1CA3F9F218D78C938B35763AF2A8714664CC57F5CECE2413841F5E9"
       "EDEC43B728E25A41BF3E1EF8D9EEE163286C9F8BF0F219D3B322C3E4B0389C"
       "2E8BB28DC04C47DA2BF38823731266D2CF6CC3FC181738157624EF051874D0"
       "BBCCB9F65C83"
       /* Note that this example in X9.31 gives this value for D:
 
         "7ED581A6617C6311465A53EDC4155C86807C5108B724070D6C0E9935296F44"
         "96755CCC17D6C15AB24C6E0BB6C2138E683F4746A1B316C51E8993DFBD3AC8"
         "3B479FEAB972B930C354CA2DFDD30F2A9CB222DC37B63B7881EE18A7688E0E"
         "DE30F38728FE7C8635E324E2CD5D8EBCAA1C51993315FD73B38904E107D7A7"
         "B7B10EDCA3896906FCF87BE367BB858CA1B27E2FC3C8674ECC8B0F92C0E270"
         "BA2ECA3701311F68AFCE208DCC499B4B3DB30FF0605CE055D893BC1461D342"
         "EF32E7D9720B"
 
         This is a bug in X9.31, obviously introduced by using
 
            d = e^{-1} mod (p-1)(q-1)
 
          instead of using the universal exponent as required by 4.1.3:
 
            d = e^{-1} mod lcm(p-1,q-1)
 
          The examples in X9.31 seem to be pretty buggy, see
          cipher/primegen.c for another bug.  Not only that I had to
          spend 100 USD for the 66 pages of the document, it also took
          me several hours to figure out that the bugs are in the
          document and not in my code.
        */
     },
 
     { /* First example from NIST RSAVS (B.1.1).  */
       "(genkey\n"
       "  (rsa\n"
       "    (nbits 4:1024)\n"
       "    (rsa-use-e 1:3)\n"
       "    (derive-parms\n"
       "      (Xp1 #1ed3d6368e101dab9124c92ac8#)\n"
       "      (Xp2 #16e5457b8844967ce83cab8c11#)\n"
       "      (Xp  #b79f2c2493b4b76f329903d7555b7f5f06aaa5ea\n"
       "            ab262da1dcda8194720672a4e02229a0c71f60ae\n"
       "            c4f0d2ed8d49ef583ca7d5eeea907c10801c302a\n"
       "            cab44595#)\n"
       "      (Xq1 #1a5d9e3fa34fb479bedea412f6#)\n"
       "      (Xq2 #1f9cca85f185341516d92e82fd#)\n"
       "      (Xq  #c8387fd38fa33ddcea6a9de1b2d55410663502db\n"
       "            c225655a9310cceac9f4cf1bce653ec916d45788\n"
       "            f8113c46bc0fa42bf5e8d0c41120c1612e2ea8bb\n"
       "            2f389eda#))))\n",
       "17ef7ad4fd96011b62d76dfb2261b4b3270ca8e07bc501be954f8719ef586b"
       "f237e8f693dd16c23e7adecc40279dc6877c62ab541df5849883a5254fccfd"
       "4072a657b7f4663953930346febd6bbd82f9a499038402cbf97fd5f068083a"
       "c81ad0335c4aab0da19cfebe060a1bac7482738efafea078e21df785e56ea0"
       "dc7e8feb"
     },
 
     { /* Second example from NIST RSAVS (B.1.1).  */
       "(genkey\n"
       "  (rsa\n"
       "    (nbits 4:1536)\n"
       "    (rsa-use-e 1:3)\n"
       "    (derive-parms\n"
       "      (Xp1 #1e64c1af460dff8842c22b64d0#)\n"
       "      (Xp2 #1e948edcedba84039c81f2ac0c#)\n"
       "      (Xp  #c8c67df894c882045ede26a9008ab09ea0672077\n"
       "            d7bc71d412511cd93981ddde8f91b967da404056\n"
       "            c39f105f7f239abdaff92923859920f6299e82b9\n"
       "            5bd5b8c959948f4a034d81613d6235a3953b49ce\n"
       "            26974eb7bb1f14843841281b363b9cdb#)\n"
       "      (Xq1 #1f3df0f017ddd05611a97b6adb#)\n"
       "      (Xq2 #143edd7b22d828913abf24ca4d#)\n"
       "      (Xq  #f15147d0e7c04a1e3f37adde802cdc610999bf7a\n"
       "            b0088434aaeda0c0ab3910b14d2ce56cb66bffd9\n"
       "            7552195fae8b061077e03920814d8b9cfb5a3958\n"
       "            b3a82c2a7fc97e55db543948d3396289245336ec\n"
       "            9e3cb308cc655aebd766340da8921383#))))\n",
       "1f8b19f3f5f2ac9fc599f110cad403dcd9bdf5f7f00fb2790e78e820398184"
       "1f3fb3dd230fb223d898f45719d9b2d3525587ff2b8bcc7425e40550a5b536"
       "1c8e9c1d26e83fbd9c33c64029c0e878b829d55def12912b73d94fd758c461"
       "0f473e230c41b5e4c86e27c5a5029d82c811c88525d0269b95bd2ff272994a"
       "dbd80f2c2ecf69065feb8abd8b445b9c6d306b1585d7d3d7576d49842bc7e2"
       "8b4a2f88f4a47e71c3edd35fdf83f547ea5c2b532975c551ed5268f748b2c4"
       "2ccf8a84835b"
     }
   };
   gpg_error_t err;
   gcry_sexp_t key_spec = NULL, key = NULL, pub_key = NULL, sec_key = NULL;
   gcry_mpi_t d_expected = NULL, d_have = NULL;
 
   if (what < 0 && what >= sizeof testtable)
     die ("invalid WHAT value\n");
 
   err = gcry_sexp_new (&key_spec, testtable[what].param, 0, 1);
   if (err)
     die ("error creating S-expression [%d]: %s\n", what, gpg_strerror (err));
 
   {
     unsigned nbits;
     err = _gcry_pk_util_get_nbits(key_spec, &nbits);
     if (err)
       die ("nbits not found\n");
     if (gcry_fips_mode_active() && nbits < 2048)
       {
         info("RSA key test with %d bits skipped in fips mode\n", nbits);
         goto leave;
       }
   }
 
   err = gcry_pk_genkey (&key, key_spec);
   gcry_sexp_release (key_spec);
   if (err)
     {
       fail ("error generating RSA key [%d]: %s\n", what, gpg_strerror (err));
       goto leave;
     }
 
   pub_key = gcry_sexp_find_token (key, "public-key", 0);
   if (!pub_key)
     die ("public part missing in key [%d]\n", what);
 
   sec_key = gcry_sexp_find_token (key, "private-key", 0);
   if (!sec_key)
     die ("private part missing in key [%d]\n", what);
 
   err = gcry_mpi_scan
     (&d_expected, GCRYMPI_FMT_HEX, testtable[what].expected_d, 0, NULL);
   if (err)
     die ("error converting string [%d]\n", what);
 
   if (verbose > 1)
     show_sexp ("generated key:\n", key);
 
   d_have = key_param_from_sexp (sec_key, "rsa", "d");
   if (!d_have)
     die ("parameter d not found in RSA secret key [%d]\n", what);
   if (gcry_mpi_cmp (d_expected, d_have))
     {
       show_sexp (NULL, sec_key);
       die ("parameter d does match expected value [%d]\n", what);
     }
 leave:
   gcry_mpi_release (d_expected);
   gcry_mpi_release (d_have);
 
   gcry_sexp_release (key);
   gcry_sexp_release (pub_key);
   gcry_sexp_release (sec_key);
 }
 
 
 
 static void
 check_ecc_sample_key (void)
 {
   static const char ecc_private_key[] =
     "(private-key\n"
     " (ecdsa\n"
     "  (curve \"NIST P-256\")\n"
     "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2BEB6644D3609FC781"
     "B71F9A8072F58CB66AE2F89BB12451873ABF7D91F9E1FBF96BF2F70E73AAC9A283#)\n"
     "  (d #5A1EF0035118F19F3110FB81813D3547BCE1E5BCE77D1F744715E1D5BBE70378#)"
     "))";
   static const char ecc_private_key_wo_q[] =
     "(private-key\n"
     " (ecdsa\n"
     "  (curve \"NIST P-256\")\n"
     "  (d #5A1EF0035118F19F3110FB81813D3547BCE1E5BCE77D1F744715E1D5BBE70378#)"
     "))";
   static const char ecc_public_key[] =
     "(public-key\n"
     " (ecdsa\n"
     "  (curve \"NIST P-256\")\n"
     "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2BEB6644D3609FC781"
     "B71F9A8072F58CB66AE2F89BB12451873ABF7D91F9E1FBF96BF2F70E73AAC9A283#)"
     "))";
   static const char hash_string[] =
     "(data (flags raw)\n"
     " (value #00112233445566778899AABBCCDDEEFF"
     /* */    "000102030405060708090A0B0C0D0E0F#))";
   static const char hash2_string[] =
     "(data (flags raw)\n"
     " (hash sha1 #00112233445566778899AABBCCDDEEFF"
     /* */    "000102030405060708090A0B0C0D0E0F"
     /* */    "000102030405060708090A0B0C0D0E0F"
     /* */    "00112233445566778899AABBCCDDEEFF#))";
   /* hash2, but longer than curve length, so it will be truncated */
   static const char hash3_string[] =
     "(data (flags raw)\n"
     " (hash sha1 #00112233445566778899AABBCCDDEEFF"
     /* */    "000102030405060708090A0B0C0D0E0F"
     /* */    "000102030405060708090A0B0C0D0E0F"
     /* */    "00112233445566778899AABBCCDDEEFF"
     /* */    "000102030405060708090A0B0C0D0E0F#))";
 
   gpg_error_t err;
   gcry_sexp_t key, hash, hash2, hash3, sig, sig2;
 
   if (verbose)
     fprintf (stderr, "Checking sample ECC key.\n");
 
   if ((err = gcry_sexp_new (&hash, hash_string, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
 
   if ((err = gcry_sexp_new (&hash2, hash2_string, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
 
   if ((err = gcry_sexp_new (&hash3, hash3_string, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
 
   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
 
   if ((err = gcry_pk_sign (&sig, hash, key)))
     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
 
   gcry_sexp_release (key);
   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
 
   if ((err = gcry_pk_verify (sig, hash, key)))
     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
 
   /* Verify hash truncation */
   gcry_sexp_release (key);
   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
 
   if ((err = gcry_pk_sign (&sig2, hash2, key)))
     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
 
   gcry_sexp_release (sig);
   if ((err = gcry_pk_sign (&sig, hash3, key)))
     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
 
   gcry_sexp_release (key);
   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
 
   if ((err = gcry_pk_verify (sig, hash2, key)))
     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
 
   if ((err = gcry_pk_verify (sig2, hash3, key)))
     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
 
   /* Now try signing without the Q parameter.  */
 
   gcry_sexp_release (key);
   if ((err = gcry_sexp_new (&key, ecc_private_key_wo_q, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
 
   gcry_sexp_release (sig);
   if ((err = gcry_pk_sign (&sig, hash, key)))
     die ("gcry_pk_sign without Q failed: %s", gpg_strerror (err));
 
   gcry_sexp_release (key);
   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
 
   if ((err = gcry_pk_verify (sig, hash, key)))
     die ("gcry_pk_verify signed without Q failed: %s", gpg_strerror (err));
 
   gcry_sexp_release (sig);
   gcry_sexp_release (sig2);
   gcry_sexp_release (key);
   gcry_sexp_release (hash);
   gcry_sexp_release (hash2);
   gcry_sexp_release (hash3);
 }
 
 
 static void
 check_ed25519ecdsa_sample_key (void)
 {
   static const char ecc_private_key[] =
     "(private-key\n"
     " (ecc\n"
     "  (curve \"Ed25519\")\n"
     "  (q #044C056555BE4084BB3D8D8895FDF7C2893DFE0256251923053010977D12658321"
     "        156D1ADDC07987713A418783658B476358D48D582DB53233D9DED3C1C2577B04#)"
     "  (d #09A0C38E0F1699073541447C19DA12E3A07A7BFDB0C186E4AC5BCE6F23D55252#)"
     "))";
   static const char ecc_private_key_wo_q[] =
     "(private-key\n"
     " (ecc\n"
     "  (curve \"Ed25519\")\n"
     "  (d #09A0C38E0F1699073541447C19DA12E3A07A7BFDB0C186E4AC5BCE6F23D55252#)"
     "))";
   static const char ecc_public_key[] =
     "(public-key\n"
     " (ecc\n"
     "  (curve \"Ed25519\")\n"
     "  (q #044C056555BE4084BB3D8D8895FDF7C2893DFE0256251923053010977D12658321"
     "        156D1ADDC07987713A418783658B476358D48D582DB53233D9DED3C1C2577B04#)"
     "))";
   static const char ecc_public_key_comp[] =
     "(public-key\n"
     " (ecc\n"
     "  (curve \"Ed25519\")\n"
     "  (q #047b57c2c1d3ded93332b52d588dd45863478b658387413a718779c0dd1a6d95#)"
     "))";
   static const char hash_string[] =
     "(data (flags rfc6979)\n"
     " (hash sha256 #00112233445566778899AABBCCDDEEFF"
     /* */          "000102030405060708090A0B0C0D0E0F#))";
 
   gpg_error_t err;
   gcry_sexp_t key, hash, sig;
 
   if (verbose)
     fprintf (stderr, "Checking sample Ed25519/ECDSA key.\n");
 
   /* Sign.  */
   if ((err = gcry_sexp_new (&hash, hash_string, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
   if ((err = gcry_pk_sign (&sig, hash, key)))
     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
 
   /* Verify.  */
   gcry_sexp_release (key);
   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
   if ((err = gcry_pk_verify (sig, hash, key)))
     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
 
   /* Verify again using a compressed public key.  */
   gcry_sexp_release (key);
   if ((err = gcry_sexp_new (&key, ecc_public_key_comp, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
   if ((err = gcry_pk_verify (sig, hash, key)))
     die ("gcry_pk_verify failed (comp): %s", gpg_strerror (err));
 
   /* Sign without a Q parameter.  */
   gcry_sexp_release (key);
   if ((err = gcry_sexp_new (&key, ecc_private_key_wo_q, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
   gcry_sexp_release (sig);
   if ((err = gcry_pk_sign (&sig, hash, key)))
     die ("gcry_pk_sign w/o Q failed: %s", gpg_strerror (err));
 
   /* Verify.  */
   gcry_sexp_release (key);
   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
   if ((err = gcry_pk_verify (sig, hash, key)))
     die ("gcry_pk_verify signed w/o Q failed: %s", gpg_strerror (err));
 
   /* Verify again using a compressed public key.  */
   gcry_sexp_release (key);
   if ((err = gcry_sexp_new (&key, ecc_public_key_comp, 0, 1)))
     die ("line %d: %s", __LINE__, gpg_strerror (err));
   if ((err = gcry_pk_verify (sig, hash, key)))
     die ("gcry_pk_verify signed w/o Q failed (comp): %s", gpg_strerror (err));
 
   extract_cmp_data (sig, "r", ("a63123a783ef29b8276e08987daca4"
                                "655d0179e22199bf63691fd88eb64e15"));
   extract_cmp_data (sig, "s", ("0d9b45c696ab90b96b08812b485df185"
                                "623ddaf5d02fa65ca5056cb6bd0f16f1"));
 
   gcry_sexp_release (sig);
   gcry_sexp_release (key);
   gcry_sexp_release (hash);
 }
 
 
 int
 main (int argc, char **argv)
 {
   int i;
 
   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     verbose = 1;
   else if (argc > 1 && !strcmp (argv[1], "--debug"))
     {
       verbose = 2;
       debug = 1;
     }
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u , 0));
   /* No valuable keys are create, so we can speed up our RNG. */
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
 
   for (i=0; i < 2; i++)
     check_run ();
 
   for (i=0; i < 4; i++)
     check_x931_derived_key (i);
 
   check_ecc_sample_key ();
   if (!gcry_fips_mode_active ())
     check_ed25519ecdsa_sample_key ();
 
   return !!error_count;
 }
diff --git a/tests/random.c b/tests/random.c
index 2f48323f..22927a61 100644
--- a/tests/random.c
+++ b/tests/random.c
@@ -1,766 +1,766 @@
 /* random.c - part of the Libgcrypt test suite.
    Copyright (C) 2005 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
    USA.  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <unistd.h>
 #ifndef HAVE_W32_SYSTEM
 # include <signal.h>
 # include <sys/wait.h>
 #endif
 
 #include "stopwatch.h"
 
 
 #define PGM "random"
 #define NEED_EXTRA_TEST_SUPPORT 1
 #include "t-common.h"
 
 static int with_progress;
 
 
 /* Prepend FNAME with the srcdir environment variable's value and
  * return an allocated filename.  */
 static char *
 prepend_srcdir (const char *fname)
 {
   static const char *srcdir;
   char *result;
 
   if (!srcdir && !(srcdir = getenv ("srcdir")))
     srcdir = ".";
 
   result = xmalloc (strlen (srcdir) + 1 + strlen (fname) + 1);
   strcpy (result, srcdir);
   strcat (result, "/");
   strcat (result, fname);
   return result;
 }
 
 
 static void
 print_hex (const char *text, const void *buf, size_t n)
 {
   const unsigned char *p = buf;
 
   info ("%s", text);
   for (; n; n--, p++)
     fprintf (stderr, "%02X", *p);
   putc ('\n', stderr);
 }
 
 
 static void
 progress_cb (void *cb_data, const char *what, int printchar,
              int current, int total)
 {
   (void)cb_data;
 
   info ("progress (%s %c %d %d)\n", what, printchar, current, total);
   fflush (stderr);
 }
 
 
 #ifndef HAVE_W32_SYSTEM
 static int
 writen (int fd, const void *buf, size_t nbytes)
 {
   size_t nleft = nbytes;
   int nwritten;
 
   while (nleft > 0)
     {
       nwritten = write (fd, buf, nleft);
       if (nwritten < 0)
         {
           if (errno == EINTR)
             nwritten = 0;
           else
             return -1;
         }
       nleft -= nwritten;
       buf = (const char*)buf + nwritten;
     }
 
   return 0;
 }
 #endif /*!HAVE_W32_SYSTEM*/
 
 
 #ifndef HAVE_W32_SYSTEM
 static int
 readn (int fd, void *buf, size_t buflen, size_t *ret_nread)
 {
   size_t nleft = buflen;
   int nread;
 
   while ( nleft > 0 )
     {
       nread = read ( fd, buf, nleft );
       if (nread < 0)
         {
           if (nread == EINTR)
             nread = 0;
           else
             return -1;
         }
       else if (!nread)
         break; /* EOF */
       nleft -= nread;
       buf = (char*)buf + nread;
     }
   if (ret_nread)
     *ret_nread = buflen - nleft;
   return 0;
 }
 #endif /*!HAVE_W32_SYSTEM*/
 
 
 /* Check that forking won't return the same random. */
 static void
 check_forking (void)
 {
 #ifdef HAVE_W32_SYSTEM
   if (verbose)
     info ("check_forking skipped: not applicable on Windows\n");
 #else /*!HAVE_W32_SYSTEM*/
   pid_t pid;
   int rp[2];
   int i, status;
   size_t nread;
   char tmp1[16], tmp1c[16], tmp1p[16];
 
   if (verbose)
     info ("checking that a fork won't cause the same random output\n");
 
   /* We better make sure that the RNG has been initialzied. */
   gcry_randomize (tmp1, sizeof tmp1, GCRY_STRONG_RANDOM);
   if (verbose)
     print_hex ("initial random: ", tmp1, sizeof tmp1);
 
   if (pipe (rp) == -1)
     die ("pipe failed: %s\n", strerror (errno));
 
   pid = fork ();
   if (pid == (pid_t)(-1))
     die ("fork failed: %s\n", strerror (errno));
   if (!pid)
     {
       gcry_randomize (tmp1c, sizeof tmp1c, GCRY_STRONG_RANDOM);
       if (writen (rp[1], tmp1c, sizeof tmp1c))
         die ("write failed: %s\n", strerror (errno));
       if (verbose)
         {
           print_hex ("  child random: ", tmp1c, sizeof tmp1c);
           fflush (stdout);
         }
       _exit (0);
     }
   gcry_randomize (tmp1p, sizeof tmp1p, GCRY_STRONG_RANDOM);
   if (verbose)
     print_hex (" parent random: ", tmp1p, sizeof tmp1p);
 
   close (rp[1]);
   if (readn (rp[0], tmp1c, sizeof tmp1c, &nread))
     die ("read failed: %s\n", strerror (errno));
   if (nread != sizeof tmp1c)
     die ("read too short\n");
 
   while ( (i=waitpid (pid, &status, 0)) == -1 && errno == EINTR)
     ;
   if (i != (pid_t)(-1)
       && WIFEXITED (status) && !WEXITSTATUS (status))
     ;
   else
     die ("child failed\n");
 
   if (!memcmp (tmp1p, tmp1c, sizeof tmp1c))
     die ("parent and child got the same random number\n");
 #endif  /*!HAVE_W32_SYSTEM*/
 }
 
 
 
 /* Check that forking won't return the same nonce. */
 static void
 check_nonce_forking (void)
 {
 #ifdef HAVE_W32_SYSTEM
   if (verbose)
     info ("check_nonce_forking skipped: not applicable on Windows\n");
 #else /*!HAVE_W32_SYSTEM*/
   pid_t pid;
   int rp[2];
   int i, status;
   size_t nread;
   char nonce1[10], nonce1c[10], nonce1p[10];
 
   if (verbose)
     info ("checking that a fork won't cause the same nonce output\n");
 
   /* We won't get the same nonce back if we never initialized the
      nonce subsystem, thus we get one nonce here and forget about
      it. */
   gcry_create_nonce (nonce1, sizeof nonce1);
   if (verbose)
     print_hex ("initial nonce: ", nonce1, sizeof nonce1);
 
   if (pipe (rp) == -1)
     die ("pipe failed: %s\n", strerror (errno));
 
   pid = fork ();
   if (pid == (pid_t)(-1))
     die ("fork failed: %s\n", strerror (errno));
   if (!pid)
     {
       gcry_create_nonce (nonce1c, sizeof nonce1c);
       if (writen (rp[1], nonce1c, sizeof nonce1c))
         die ("write failed: %s\n", strerror (errno));
       if (verbose)
         {
           print_hex ("  child nonce: ", nonce1c, sizeof nonce1c);
           fflush (stdout);
         }
       _exit (0);
     }
   gcry_create_nonce (nonce1p, sizeof nonce1p);
   if (verbose)
     print_hex (" parent nonce: ", nonce1p, sizeof nonce1p);
 
   close (rp[1]);
   if (readn (rp[0], nonce1c, sizeof nonce1c, &nread))
     die ("read failed: %s\n", strerror (errno));
   if (nread != sizeof nonce1c)
     die ("read too short\n");
 
   while ( (i=waitpid (pid, &status, 0)) == -1 && errno == EINTR)
     ;
   if (i != (pid_t)(-1)
       && WIFEXITED (status) && !WEXITSTATUS (status))
     ;
   else
     die ("child failed\n");
 
   if (!memcmp (nonce1p, nonce1c, sizeof nonce1c))
     die ("parent and child got the same nonce\n");
 #endif  /*!HAVE_W32_SYSTEM*/
 }
 
 
 /* Check that a closed random device os re-opened if needed. */
 static void
 check_close_random_device (void)
 {
 #ifdef HAVE_W32_SYSTEM
   if (verbose)
     info ("check_close_random_device skipped: not applicable on Windows\n");
 #else /*!HAVE_W32_SYSTEM*/
   pid_t pid;
   int i, status;
   char buf[4];
 
   if (verbose)
     info ("checking that close_random_device works\n");
 
   gcry_randomize (buf, sizeof buf, GCRY_STRONG_RANDOM);
   if (verbose)
     print_hex ("parent random: ", buf, sizeof buf);
 
   pid = fork ();
   if (pid == (pid_t)(-1))
     die ("fork failed: %s\n", strerror (errno));
   if (!pid)
     {
-      xgcry_control (GCRYCTL_CLOSE_RANDOM_DEVICE, 0);
+      xgcry_control ((GCRYCTL_CLOSE_RANDOM_DEVICE, 0));
 
       /* The next call will re-open the device.  */
       gcry_randomize (buf, sizeof buf, GCRY_STRONG_RANDOM);
       if (verbose)
         {
           print_hex ("child random : ", buf, sizeof buf);
           fflush (stdout);
         }
       _exit (0);
     }
 
   while ( (i=waitpid (pid, &status, 0)) == -1 && errno == EINTR)
     ;
   if (i != (pid_t)(-1)
       && WIFEXITED (status) && !WEXITSTATUS (status))
     ;
   else
     die ("child failed\n");
 
 #endif  /*!HAVE_W32_SYSTEM*/
 }
 
 
 static int
 rng_type (void)
 {
   int rngtype;
   if (gcry_control (GCRYCTL_GET_CURRENT_RNG_TYPE, &rngtype))
     die ("retrieving RNG type failed\n");
   return rngtype;
 }
 
 
 static void
 check_rng_type_switching (void)
 {
   int rngtype, initial;
   char tmp1[4];
 
   if (verbose)
     info ("checking whether RNG type switching works\n");
 
   rngtype = rng_type ();
   if (debug)
     info ("rng type: %d\n", rngtype);
   initial = rngtype;
   gcry_randomize (tmp1, sizeof tmp1, GCRY_STRONG_RANDOM);
   if (debug)
     print_hex ("  sample: ", tmp1, sizeof tmp1);
   if (rngtype != rng_type ())
     die ("RNG type unexpectedly changed\n");
 
-  xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_SYSTEM);
+  xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_SYSTEM));
 
   rngtype = rng_type ();
   if (debug)
     info ("rng type: %d\n", rngtype);
   if (rngtype != initial)
     die ("switching to System RNG unexpectedly succeeded\n");
   gcry_randomize (tmp1, sizeof tmp1, GCRY_STRONG_RANDOM);
   if (debug)
     print_hex ("  sample: ", tmp1, sizeof tmp1);
   if (rngtype != rng_type ())
     die ("RNG type unexpectedly changed\n");
 
-  xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_FIPS);
+  xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_FIPS));
 
   rngtype = rng_type ();
   if (debug)
     info ("rng type: %d\n", rngtype);
   if (rngtype != initial)
     die ("switching to FIPS RNG unexpectedly succeeded\n");
   gcry_randomize (tmp1, sizeof tmp1, GCRY_STRONG_RANDOM);
   if (debug)
     print_hex ("  sample: ", tmp1, sizeof tmp1);
   if (rngtype != rng_type ())
     die ("RNG type unexpectedly changed\n");
 
-  xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_STANDARD);
+  xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_STANDARD));
 
   rngtype = rng_type ();
   if (debug)
     info ("rng type: %d\n", rngtype);
   if (rngtype != GCRY_RNG_TYPE_STANDARD)
     die ("switching to standard RNG failed\n");
   gcry_randomize (tmp1, sizeof tmp1, GCRY_STRONG_RANDOM);
   if (debug)
     print_hex ("  sample: ", tmp1, sizeof tmp1);
   if (rngtype != rng_type ())
     die ("RNG type unexpectedly changed\n");
 }
 
 
 static void
 check_early_rng_type_switching (void)
 {
   int rngtype, initial;
 
   if (verbose)
     info ("checking whether RNG type switching works in the early stage\n");
 
   rngtype = rng_type ();
   if (debug)
     info ("rng type: %d\n", rngtype);
   initial = rngtype;
 
-  xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_SYSTEM);
+  xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_SYSTEM));
 
   rngtype = rng_type ();
   if (debug)
     info ("rng type: %d\n", rngtype);
   if (initial >= GCRY_RNG_TYPE_SYSTEM && rngtype != GCRY_RNG_TYPE_SYSTEM)
     die ("switching to System RNG failed\n");
 
-  xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_FIPS);
+  xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_FIPS));
 
   rngtype = rng_type ();
   if (debug)
     info ("rng type: %d\n", rngtype);
   if (initial >= GCRY_RNG_TYPE_FIPS && rngtype != GCRY_RNG_TYPE_FIPS)
     die ("switching to FIPS RNG failed\n");
 
-  xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_STANDARD);
+  xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_STANDARD));
 
   rngtype = rng_type ();
   if (debug)
     info ("rng type: %d\n", rngtype);
   if (rngtype != GCRY_RNG_TYPE_STANDARD)
     die ("switching to standard RNG failed\n");
 }
 
 
 static void
 check_drbg_reinit (void)
 {
   static struct { const char *flags; } tv[] = {
     { NULL },
     { "" },
     { "sha1" },
     { "sha1 pr" },
     { "sha256" },
     { "sha256 pr" },
     { "sha512" },
     { "sha512 pr" },
     { "hmac sha1" },
     { "hmac sha1 pr" },
     { "hmac sha256" },
     { "hmac sha256 pr" },
     { "hmac sha512" },
     { "hmac sha512 pr" },
     { "aes sym128" },
     { "aes sym128 pr" },
     { "aes sym192" },
     { "aes sym192 pr" },
     { "aes sym256" },
     { "aes sym256 pr" }
   };
   int tidx;
   gpg_error_t err;
   char pers_string[] = "I'm a doctor, not an engineer.";
   gcry_buffer_t pers[1];
 
   if (verbose)
     info ("checking DRBG_REINIT\n");
 
   memset (pers, 0, sizeof pers);
   pers[0].data = pers_string;
   pers[0].len = strlen (pers_string);
 
   err = gcry_control (GCRYCTL_DRBG_REINIT, "", NULL, 0, &err);
   if (gpg_err_code (err) != GPG_ERR_INV_ARG)
     die ("gcry_control(DRBG_REINIT) guard value did not work\n");
 
   err = gcry_control (GCRYCTL_DRBG_REINIT, "", NULL, -1, NULL);
   if (gpg_err_code (err) != GPG_ERR_INV_ARG)
     die ("gcry_control(DRBG_REINIT) npers negative detection failed\n");
 
   if (rng_type () != GCRY_RNG_TYPE_FIPS)
     {
       err = gcry_control (GCRYCTL_DRBG_REINIT, "", NULL, 0, NULL);
       if (gpg_err_code (err) != GPG_ERR_NOT_SUPPORTED)
         die ("DRBG_REINIT worked despite that DRBG is not active\n");
       return;
     }
 
   err = gcry_control (GCRYCTL_DRBG_REINIT, "", NULL, 1, NULL);
   if (gpg_err_code (err) != GPG_ERR_INV_ARG)
     die ("_gcry_rngdrbg_reinit failed to detact: (!pers && npers)\n");
   err = gcry_control (GCRYCTL_DRBG_REINIT, "", pers, 2, NULL);
   if (gpg_err_code (err) != GPG_ERR_INV_ARG)
     die ("_gcry_rngdrbg_reinit failed to detect: (pers && npers != 1)\n");
 
   err = gcry_control (GCRYCTL_DRBG_REINIT, "aes sym128 bad pr ", pers, 1, NULL);
   if (gpg_err_code (err) != GPG_ERR_INV_FLAG)
     die ("_gcry_rngdrbg_reinit failed to detect a bad flag\n");
 
   for (tidx=0; tidx < DIM(tv); tidx++)
     {
       err = gcry_control (GCRYCTL_DRBG_REINIT, tv[tidx].flags, NULL, 0, NULL);
       if (err)
         die ("_gcry_rngdrbg_reinit failed for \"%s\" w/o pers: %s\n",
 
              tv[tidx].flags, gpg_strerror (err));
       err = gcry_control (GCRYCTL_DRBG_REINIT, tv[tidx].flags, pers, 1, NULL);
       if (err)
         die ("_gcry_rngdrbg_reinit failed for \"%s\" with pers: %s\n",
              tv[tidx].flags, gpg_strerror (err));
       /* fixme: We should extract some random after each test.  */
     }
 }
 
 
 /* Because we want to check initialization behaviour, we need to
    fork/exec this program with several command line arguments.  We use
    system, so that these tests work also on Windows.  */
 static void
 run_all_rng_tests (const char *program)
 {
   static const char *options[] = {
     "--early-rng-check",
     "--early-rng-check --prefer-standard-rng",
     "--early-rng-check --prefer-fips-rng",
     "--early-rng-check --prefer-system-rng",
     "--prefer-standard-rng",
     "--prefer-fips-rng",
     "--prefer-system-rng",
     NULL
   };
   int idx;
   size_t len, maxlen;
   char *cmdline;
 
   maxlen = 0;
   for (idx=0; options[idx]; idx++)
     {
       len = strlen (options[idx]);
       if (len > maxlen)
         maxlen = len;
     }
   maxlen += strlen (program);
   maxlen += strlen (" --in-recursion --verbose --debug --progress");
   maxlen++;
   cmdline = malloc (maxlen + 1);
   if (!cmdline)
     die ("out of core\n");
 
   for (idx=0; options[idx]; idx++)
     {
       if (verbose)
         info ("now running with options '%s'\n", options[idx]);
       strcpy (cmdline, program);
       strcat (cmdline, " --in-recursion");
       if (verbose)
         strcat (cmdline, " --verbose");
       if (debug)
         strcat (cmdline, " --debug");
       if (with_progress)
         strcat (cmdline, " --progress");
       strcat (cmdline, " ");
       strcat (cmdline, options[idx]);
       if (system (cmdline))
         die ("running '%s' failed\n", cmdline);
     }
 
   free (cmdline);
 }
 
 
 static void
 run_benchmark (void)
 {
   char rndbuf[32];
   int i, j;
 
   if (verbose)
     info ("benchmarking GCRY_STRONG_RANDOM (/dev/urandom)\n");
 
   start_timer ();
   gcry_randomize (rndbuf, sizeof rndbuf, GCRY_STRONG_RANDOM);
   stop_timer ();
 
   info ("getting first 256 bits: %s", elapsed_time (1));
 
   for (j=0; j < 5; j++)
     {
       start_timer ();
       for (i=0; i < 100; i++)
         gcry_randomize (rndbuf, sizeof rndbuf, GCRY_STRONG_RANDOM);
       stop_timer ();
 
       info ("100 calls of 256 bits each: %s", elapsed_time (100));
     }
 
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   int early_rng = 0;
   int in_recursion = 0;
   int benchmark = 0;
   int with_seed_file = 0;
   const char *program = NULL;
 
   if (argc)
     {
       program = *argv;
       argc--; argv++;
     }
   else
     die ("argv[0] missing\n");
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           fputs ("usage: random [options]\n", stdout);
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           debug = verbose = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--progress"))
         {
           argc--; argv++;
           with_progress = 1;
         }
       else if (!strcmp (*argv, "--in-recursion"))
         {
           in_recursion = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--benchmark"))
         {
           benchmark = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--early-rng-check"))
         {
           early_rng = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--with-seed-file"))
         {
           with_seed_file = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--prefer-standard-rng"))
         {
           /* This is anyway the default, but we may want to use it for
              debugging. */
-          xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE,
-                         GCRY_RNG_TYPE_STANDARD);
+          xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE,
+                          GCRY_RNG_TYPE_STANDARD));
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--prefer-fips-rng"))
         {
-          xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_FIPS);
+          xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_FIPS));
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--prefer-system-rng"))
         {
-          xgcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_SYSTEM);
+          xgcry_control ((GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_SYSTEM));
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--disable-hwf"))
         {
           argc--;
           argv++;
           if (argc)
             {
               if (gcry_control (GCRYCTL_DISABLE_HWF, *argv, NULL))
                 die ("unknown hardware feature `%s'\n", *argv);
               argc--;
               argv++;
             }
         }
     }
 
 #ifndef HAVE_W32_SYSTEM
   signal (SIGPIPE, SIG_IGN);
 #endif
 
   if (benchmark && !verbose)
     verbose = 1;
 
   if (early_rng)
     {
       /* Don't switch RNG in fips mode. */
       if (!gcry_fips_mode_active())
         check_early_rng_type_switching ();
     }
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
 
   if (with_progress)
     gcry_set_progress_handler (progress_cb, NULL);
 
   if (with_seed_file)
     {
       char *fname = prepend_srcdir ("random.seed");
 
       if (access (fname, F_OK))
         info ("random seed file '%s' not found\n", fname);
       gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, fname);
       xfree (fname);
     }
 
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
 
   if (benchmark)
     {
       run_benchmark ();
     }
   else if (!in_recursion)
     {
       check_forking ();
       check_nonce_forking ();
       check_close_random_device ();
     }
   /* For now we do not run the drgb_reinit check from "make check" due
      to its high requirement for entropy.  */
   if (!benchmark && !getenv ("GCRYPT_IN_REGRESSION_TEST"))
     check_drbg_reinit ();
 
   /* Don't switch RNG in fips mode.  */
   if (!benchmark && !gcry_fips_mode_active())
     check_rng_type_switching ();
 
   if (!in_recursion && !benchmark)
     run_all_rng_tests (program);
 
   /* Print this info last so that it does not influence the
    * initialization and thus the benchmarking.  */
   if (!in_recursion && verbose)
     {
       char *buf;
       char *fields[5];
 
       buf = gcry_get_config (0, "rng-type");
       if (buf
           && split_fields_colon (buf, fields, DIM (fields)) >= 5
           && atoi (fields[4]) > 0)
         info ("The JENT RNG was active\n");
       gcry_free (buf);
     }
 
   if (debug)
-    xgcry_control (GCRYCTL_DUMP_RANDOM_STATS);
+    xgcry_control ((GCRYCTL_DUMP_RANDOM_STATS));
 
   return 0;
 }
diff --git a/tests/rsacvt.c b/tests/rsacvt.c
index 3d832640..3cc50d79 100644
--- a/tests/rsacvt.c
+++ b/tests/rsacvt.c
@@ -1,399 +1,399 @@
 /* rsacvt.c  -  A debug tool to convert RSA formats.
    Copyright (C) 2009 Free Software Foundation, Inc.
 
    This file is part of Libgcrypt.
 
    Libgcrypt is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2.1 of
    the License, or (at your option) any later version.
 
    Libgcrypt is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 /* Input data format:
 
 =======
 # A hash denotes a comment line
 e861b700e17e8afe68[...]f1
 f7a7ca5367c661f8e6[...]61
 10001
 
 # After an empty line another input block may follow.
 7861b700e17e8afe68[...]f3
 e7a7ca5367c661f8e6[...]71
 3
 =========
 
 */
 
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <errno.h>
 #include <ctype.h>
 #ifdef HAVE_W32_SYSTEM
 # include <fcntl.h> /* We need setmode().  */
 #else
 # include <signal.h>
 #endif
 #include <assert.h>
 #include <unistd.h>
 
 #ifdef _GCRYPT_IN_LIBGCRYPT
 # include "../src/gcrypt-int.h"
 #else
 # include <gcrypt.h>
 # define PACKAGE_BUGREPORT "devnull@example.org"
 # define PACKAGE_VERSION "[build on " __DATE__ " " __TIME__ "]"
 #endif
 
 
 #define PGM "rsacvt"
 #include "t-common.h"
 
 
 /* Prefix output with labels.  */
 static int with_labels;
 
 /* Do not suppress leading zeroes.  */
 static int keep_lz;
 
 /* Create parameters as specified by OpenPGP (rfc4880).  That is we
    don't store dmp1 and dmp1 but d and make sure that p is less than  q.  */
 static int openpgp_mode;
 
 
 static char *
 read_textline (FILE *fp)
 {
   char line[4096];
   char *p;
   int any = 0;
 
   /* Read line but skip over initial empty lines.  */
   do
     {
       do
         {
           if (!fgets (line, sizeof line, fp))
             {
               if (feof (fp))
                 return NULL;
               die ("error reading input line: %s\n", strerror (errno));
             }
           p = strchr (line, '\n');
           if (p)
             *p = 0;
           p = line + (*line? (strlen (line)-1):0);
           for ( ;p > line; p--)
             if (my_isascii (*p) && isspace (*p))
               *p = 0;
         }
       while (!any && !*line);
       any = 1;
     }
   while (*line == '#');  /* Always skip comment lines.  */
   if (verbose > 1)
     fprintf (stderr, PGM ": received line: %s\n", line);
   return gcry_xstrdup (line);
 }
 
 
 static gcry_mpi_t
 read_hexmpi_line (FILE *fp, int *got_eof)
 {
   gpg_error_t err;
   gcry_mpi_t a;
   char *line;
 
   *got_eof = 0;
   line = read_textline (fp);
   if (!line)
     {
       *got_eof = 1;
       return NULL;
     }
   err = gcry_mpi_scan (&a, GCRYMPI_FMT_HEX, line, 0, NULL);
   gcry_free (line);
   if (err)
     a = NULL;
   return a;
 }
 
 
 static int
 skip_to_empty_line (FILE *fp)
 {
   char line[256];
   char *p;
 
   do
     {
       if (!fgets (line, sizeof line, fp))
         {
           if (feof (fp))
             return -1;
           die ("error reading input line: %s\n", strerror (errno));
         }
       p = strchr (line, '\n');
       if (p)
         *p =0;
     }
   while (*line);
   return 0;
 }
 
 
 /* Print an MPI on a line.  */
 static void
 print_mpi_line (const char *label, gcry_mpi_t a)
 {
   unsigned char *buf, *p;
   gcry_error_t err;
   int writerr = 0;
 
   if (with_labels && label)
     printf ("%s = ", label);
 
   err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buf, NULL, a);
   if (err)
     die ("gcry_mpi_aprint failed: %s\n", gpg_strerror (err));
 
   p = buf;
   if (!keep_lz && p[0] == '0' && p[1] == '0' && p[2])
     p += 2;
 
   printf ("%s\n", p);
   if (ferror (stdout))
     writerr++;
   if (!writerr && fflush (stdout) == EOF)
     writerr++;
   if (writerr)
     die ("writing output failed: %s\n", strerror (errno));
   gcry_free (buf);
 }
 
 
 /* Compute and print missing RSA parameters.  */
 static void
 compute_missing (gcry_mpi_t rsa_p, gcry_mpi_t rsa_q, gcry_mpi_t rsa_e)
 {
   gcry_mpi_t rsa_n, rsa_d, rsa_pm1, rsa_qm1, rsa_u;
   gcry_mpi_t phi, tmp_g, tmp_f;
 
   rsa_n = gcry_mpi_new (0);
   rsa_d = gcry_mpi_new (0);
   rsa_pm1 = gcry_mpi_new (0);
   rsa_qm1 = gcry_mpi_new (0);
   rsa_u = gcry_mpi_new (0);
 
   phi = gcry_mpi_new (0);
   tmp_f = gcry_mpi_new (0);
   tmp_g = gcry_mpi_new (0);
 
   /* Check that p < q; if not swap p and q.  */
   if (openpgp_mode && gcry_mpi_cmp (rsa_p, rsa_q) > 0)
     {
       fprintf (stderr, PGM ": swapping p and q\n");
       gcry_mpi_swap (rsa_p, rsa_q);
     }
 
   gcry_mpi_mul (rsa_n, rsa_p, rsa_q);
 
 
   /* Compute the Euler totient:  phi = (p-1)(q-1)  */
   gcry_mpi_sub_ui (rsa_pm1, rsa_p, 1);
   gcry_mpi_sub_ui (rsa_qm1, rsa_q, 1);
   gcry_mpi_mul (phi, rsa_pm1, rsa_qm1);
 
   if (!gcry_mpi_gcd (tmp_g, rsa_e, phi))
     die ("parameter 'e' does match 'p' and 'q'\n");
 
   /* Compute: f = lcm(p-1,q-1) = phi / gcd(p-1,q-1) */
   gcry_mpi_gcd (tmp_g, rsa_pm1, rsa_qm1);
   gcry_mpi_div (tmp_f, NULL, phi, tmp_g, -1);
 
   /* Compute the secret key:  d = e^{-1} mod lcm(p-1,q-1) */
   gcry_mpi_invm (rsa_d, rsa_e, tmp_f);
 
   /* Compute the CRT helpers: d mod (p-1), d mod (q-1)   */
   gcry_mpi_mod (rsa_pm1, rsa_d, rsa_pm1);
   gcry_mpi_mod (rsa_qm1, rsa_d, rsa_qm1);
 
   /* Compute the CRT value:   OpenPGP:    u = p^{-1} mod q
                              Standard: iqmp = q^{-1} mod p */
   if (openpgp_mode)
     gcry_mpi_invm (rsa_u, rsa_p, rsa_q);
   else
     gcry_mpi_invm (rsa_u, rsa_q, rsa_p);
 
   gcry_mpi_release (phi);
   gcry_mpi_release (tmp_f);
   gcry_mpi_release (tmp_g);
 
   /* Print everything.  */
   print_mpi_line ("n", rsa_n);
   print_mpi_line ("e", rsa_e);
   if (openpgp_mode)
     print_mpi_line ("d", rsa_d);
   print_mpi_line ("p", rsa_p);
   print_mpi_line ("q", rsa_q);
   if (openpgp_mode)
     print_mpi_line ("u", rsa_u);
   else
     {
       print_mpi_line ("dmp1", rsa_pm1);
       print_mpi_line ("dmq1", rsa_qm1);
       print_mpi_line ("iqmp", rsa_u);
     }
 
   gcry_mpi_release (rsa_n);
   gcry_mpi_release (rsa_d);
   gcry_mpi_release (rsa_pm1);
   gcry_mpi_release (rsa_qm1);
   gcry_mpi_release (rsa_u);
 }
 
 
 
 static void
 usage (int show_help)
 {
   if (!show_help)
     {
       fputs ("usage: " PGM
              " [OPTION] [FILE] (try --help for more information)\n", stderr);
       exit (2);
     }
   fputs
     ("Usage: " PGM " [OPTIONS] [FILE]\n"
      "Take RSA parameters p, n, e and compute missing parameters.\n"
      "OPTIONS:\n"
      "  --openpgp        Compute as specified by RFC4880\n"
      "  --labels         Prefix output with labels\n"
      "  --keep-lz        Keep all leading zeroes in the output\n"
      "  --verbose        Print additional information\n"
      "  --version        Print version information\n"
      "  --help           Print this text\n"
      "With no FILE, or if FILE is -, read standard input.\n"
      "Report bugs to " PACKAGE_BUGREPORT ".\n" , stdout);
   exit (0);
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   FILE *input;
   gcry_mpi_t  rsa_p, rsa_q, rsa_e;
   int got_eof;
   int any = 0;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           usage (1);
         }
       else if (!strcmp (*argv, "--version"))
         {
           fputs (PGM " (Libgcrypt) " PACKAGE_VERSION "\n", stdout);
           printf ("libgcrypt %s\n", gcry_check_version (NULL));
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--labels"))
         {
           with_labels = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--keep-lz"))
         {
           keep_lz = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--openpgp"))
         {
           openpgp_mode = 1;
           argc--; argv++;
         }
     }
 
   if (argc > 1)
     usage (0);
 
 #if !defined (HAVE_W32_SYSTEM) && !defined (_WIN32)
   signal (SIGPIPE, SIG_IGN);
 #endif
 
   if (argc == 1 && strcmp (argv[0], "-"))
     {
       input = fopen (argv[0], "r");
       if (!input)
         die ("can't open `%s': %s\n", argv[0], strerror (errno));
     }
   else
     input = stdin;
 
-  xgcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
+  xgcry_control ((GCRYCTL_SET_VERBOSITY, (int)verbose));
   if (!gcry_check_version ("1.4.0"))
     die ("Libgcrypt is not sufficient enough\n");
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   do
     {
       rsa_p = read_hexmpi_line (input, &got_eof);
       if (!rsa_p && got_eof)
         break;
       if (!rsa_p)
         die ("RSA parameter 'p' missing or not properly hex encoded\n");
       rsa_q = read_hexmpi_line (input, &got_eof);
       if (!rsa_q)
         die ("RSA parameter 'q' missing or not properly hex encoded\n");
       rsa_e = read_hexmpi_line (input, &got_eof);
       if (!rsa_e)
         die ("RSA parameter 'e' missing or not properly hex encoded\n");
       got_eof = skip_to_empty_line (input);
 
       if (any)
         putchar ('\n');
 
       compute_missing (rsa_p, rsa_q, rsa_e);
 
       gcry_mpi_release (rsa_p);
       gcry_mpi_release (rsa_q);
       gcry_mpi_release (rsa_e);
 
       any = 1;
     }
   while (!got_eof);
 
   return 0;
 }
diff --git a/tests/t-common.h b/tests/t-common.h
index 2040f099..e356c39a 100644
--- a/tests/t-common.h
+++ b/tests/t-common.h
@@ -1,198 +1,198 @@
 /* t-common.h - Common code for the tests.
  * Copyright (C) 2013 g10 Code GmbH
  *
  * This file is part of libgpg-error.
  *
  * libgpg-error is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
  * as published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * libgpg-error is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <stdarg.h>
 
 #include "../src/gcrypt.h"
 
 #ifndef PGM
 # error Macro PGM not defined.
 #endif
 #ifndef _GCRYPT_CONFIG_H_INCLUDED
 # error config.h not included
 #endif
 
 /* A couple of useful macros.  */
 #ifndef DIM
 # define DIM(v)		     (sizeof(v)/sizeof((v)[0]))
 #endif
 #define DIMof(type,member)   DIM(((type *)0)->member)
 #define xmalloc(a)    gcry_xmalloc ((a))
 #define xcalloc(a,b)  gcry_xcalloc ((a),(b))
 #define xstrdup(a)    gcry_xstrdup ((a))
 #define xfree(a)      gcry_free ((a))
 #define my_isascii(c) (!((c) & 0x80))
 #define digitp(p)     (*(p) >= '0' && *(p) <= '9')
 #define hexdigitp(a)  (digitp (a)                     \
                        || (*(a) >= 'A' && *(a) <= 'F')  \
                        || (*(a) >= 'a' && *(a) <= 'f'))
 #define xtoi_1(p)     (*(p) <= '9'? (*(p)- '0'): \
                        *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
 #define xtoi_2(p)     ((xtoi_1(p) * 16) + xtoi_1((p)+1))
 #define xmalloc(a)    gcry_xmalloc ((a))
 #define xcalloc(a,b)  gcry_xcalloc ((a),(b))
 #define xstrdup(a)    gcry_xstrdup ((a))
 #define xfree(a)      gcry_free ((a))
 #define pass()        do { ; } while (0)
 
 
 /* Standard global variables.  */
 static const char *wherestr;
 static int verbose;
 static int debug;
 static int error_count;
 static int die_on_error;
 
 /* If we have a decent libgpg-error we can use some gcc attributes.  */
 #ifdef GPGRT_ATTR_NORETURN
 static void die (const char *format, ...)
   GPGRT_ATTR_UNUSED GPGRT_ATTR_NR_PRINTF(1,2);
 static void fail (const char *format, ...)
   GPGRT_ATTR_UNUSED GPGRT_ATTR_PRINTF(1,2);
 static void info (const char *format, ...) \
   GPGRT_ATTR_UNUSED GPGRT_ATTR_PRINTF(1,2);
 #endif /*GPGRT_ATTR_NORETURN*/
 
 
 /* Reporting functions.  */
 static void
 die (const char *format, ...)
 {
   va_list arg_ptr ;
 
   /* Avoid warning.  */
   (void) debug;
 
   fflush (stdout);
 #ifdef HAVE_FLOCKFILE
   flockfile (stderr);
 #endif
   fprintf (stderr, "%s: ", PGM);
   if (wherestr)
     fprintf (stderr, "%s: ", wherestr);
   va_start (arg_ptr, format) ;
   vfprintf (stderr, format, arg_ptr);
   va_end (arg_ptr);
   if (*format && format[strlen(format)-1] != '\n')
     putc ('\n', stderr);
 #ifdef HAVE_FLOCKFILE
   funlockfile (stderr);
 #endif
   exit (1);
 }
 
 
 static void
 fail (const char *format, ...)
 {
   va_list arg_ptr;
 
   fflush (stdout);
 #ifdef HAVE_FLOCKFILE
   flockfile (stderr);
 #endif
   fprintf (stderr, "%s: ", PGM);
   if (wherestr)
     fprintf (stderr, "%s: ", wherestr);
   va_start (arg_ptr, format);
   vfprintf (stderr, format, arg_ptr);
   va_end (arg_ptr);
   if (*format && format[strlen(format)-1] != '\n')
     putc ('\n', stderr);
 #ifdef HAVE_FLOCKFILE
   funlockfile (stderr);
 #endif
   if (die_on_error)
     exit (1);
   error_count++;
   if (error_count >= 50)
     die ("stopped after 50 errors.");
 }
 
 
 static void
 info (const char *format, ...)
 {
   va_list arg_ptr;
 
   if (!verbose)
     return;
 #ifdef HAVE_FLOCKFILE
   flockfile (stderr);
 #endif
   fprintf (stderr, "%s: ", PGM);
   if (wherestr)
     fprintf (stderr, "%s: ", wherestr);
   va_start (arg_ptr, format);
   vfprintf (stderr, format, arg_ptr);
   if (*format && format[strlen(format)-1] != '\n')
     putc ('\n', stderr);
   va_end (arg_ptr);
 #ifdef HAVE_FLOCKFILE
   funlockfile (stderr);
 #endif
 }
 
 
 /* Convenience macro for initializing gcrypt with error checking.  */
-#define xgcry_control(cmd...)                                   \
+#define xgcry_control(cmd)                                      \
   do {                                                          \
-    gcry_error_t err__ = gcry_control (cmd);                    \
+    gcry_error_t err__ = gcry_control cmd;                      \
     if (err__)                                                  \
       die ("line %d: gcry_control (%s) failed: %s",             \
            __LINE__, #cmd, gcry_strerror (err__));              \
   } while (0)
 
 
 /* Split a string into colon delimited fields A pointer to each field
  * is stored in ARRAY.  Stop splitting at ARRAYSIZE fields.  The
  * function modifies STRING.  The number of parsed fields is returned.
  * Note that leading and trailing spaces are not removed from the fields.
  * Example:
  *
  *   char *fields[2];
  *   if (split_fields (string, fields, DIM (fields)) < 2)
  *     return  // Not enough args.
  *   foo (fields[0]);
  *   foo (fields[1]);
  */
 #ifdef NEED_EXTRA_TEST_SUPPORT
 static int
 split_fields_colon (char *string, char **array, int arraysize)
 {
   int n = 0;
   char *p, *pend;
 
   p = string;
   do
     {
       if (n == arraysize)
         break;
       array[n++] = p;
       pend = strchr (p, ':');
       if (!pend)
         break;
       *pend++ = 0;
       p = pend;
     }
   while (*p);
 
   return n;
 }
 #endif /*NEED_EXTRA_TEST_SUPPORT*/
diff --git a/tests/t-convert.c b/tests/t-convert.c
index 121039c7..4450a9e3 100644
--- a/tests/t-convert.c
+++ b/tests/t-convert.c
@@ -1,534 +1,534 @@
 /* t-convert.c  - Tests for mpi print and scna functions
  * Copyright (C) 2013 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <stdarg.h>
 
 #define PGM "t-convert"
 #include "t-common.h"
 
 
 static void
 showhex (const char *prefix, const void *buffer, size_t buflen)
 {
   const unsigned char *s;
 
   if (!verbose)
     return;
   fprintf (stderr, "%s: %s ", PGM, prefix);
   for (s= buffer; buflen; buflen--, s++)
     fprintf (stderr, "%02x", *s);
   putc ('\n', stderr);
 }
 
 
 /* Allocate a bit string consisting of '0' and '1' from the MPI A.  Do
    not return any leading zero bits.  Caller needs to gcry_free the
    result. */
 static char *
 mpi2bitstr_nlz (gcry_mpi_t a)
 {
   char *p, *buf;
   size_t length = gcry_mpi_get_nbits (a);
 
   if (!length)
     {
       buf = p = xmalloc (3);
       *p++ = ' ';
       *p++ = '0';
     }
   else
     {
       buf = p = xmalloc (length + 1 + 1);
       *p++ = gcry_mpi_is_neg (a)? '-':' ';
       while (length-- > 1)
         *p++ = gcry_mpi_test_bit (a, length) ? '1':'0';
       *p++ = gcry_mpi_test_bit (a, 0) ? '1':'0';
     }
   *p = 0;
   return buf;
 }
 
 
 static void
 showmpi (const char *prefix, gcry_mpi_t a)
 {
   char *bitstr;
 
   if (!verbose)
     return;
   bitstr = mpi2bitstr_nlz (a);
   fprintf (stderr, "%s: %s%s\n", PGM, prefix, bitstr);
   xfree (bitstr);
 }
 
 
 /* Check that mpi_print does not return a negative zero.  */
 static void
 negative_zero (void)
 {
   gpg_error_t err;
   gcry_mpi_t a;
   char *buf;
   void *bufaddr = &buf;
   struct { const char *name; enum gcry_mpi_format format; } fmts[] =
     {
       { "STD", GCRYMPI_FMT_STD },
       { "PGP", GCRYMPI_FMT_PGP },
       { "SSH", GCRYMPI_FMT_SSH },
       { "HEX", GCRYMPI_FMT_HEX },
       { "USG", GCRYMPI_FMT_USG },
       { NULL, 0 }
     };
   int i;
 
   if (debug)
     info ("negative zero printing\n");
 
   a = gcry_mpi_new (0);
   for (i=0; fmts[i].name; i++)
     {
       err = gcry_mpi_aprint (fmts[i].format, bufaddr, NULL, a);
       if (err)
         fail ("error printing a zero as %s: %s\n",
               fmts[i].name,gpg_strerror (err) );
       else
         gcry_free (buf);
     }
 
   /* With the current version of libgcrypt the next two statements
      should set a to -0. */
   gcry_mpi_sub_ui (a, a, 1);
   gcry_mpi_add_ui (a, a, 1);
 
   for (i=0; fmts[i].name; i++)
     {
       err = gcry_mpi_aprint (fmts[i].format, bufaddr, NULL, a);
       if (err)
         fail ("error printing a negative zero as %s: %s\n",
               fmts[i].name,gpg_strerror (err) );
       else
         gcry_free (buf);
     }
 
   gcry_mpi_release (a);
 }
 
 
 static void
 check_formats (void)
 {
   static struct {
     int value;
     struct {
       const char *hex;
       size_t stdlen;
       const char *std;
       size_t sshlen;
       const char *ssh;
       size_t usglen;
       const char *usg;
       size_t pgplen;
       const char *pgp;
     } a;
   } data[] = {
     {    0, { "00",
               0, "",
               4, "\x00\x00\x00\x00",
               0, "",
               2, "\x00\x00"}
     },
     {    1, { "01",
               1, "\x01",
               5, "\x00\x00\x00\x01\x01",
               1, "\x01",
               3, "\x00\x01\x01" }
     },
     {    2, { "02",
               1, "\x02",
               5, "\x00\x00\x00\x01\x02",
               1, "\x02",
               3, "\x00\x02\x02" }
     },
     {  127, { "7F",
               1, "\x7f",
               5, "\x00\x00\x00\x01\x7f",
               1, "\x7f",
               3, "\x00\x07\x7f" }
     },
     {  128, { "0080",
               2, "\x00\x80",
               6, "\x00\x00\x00\x02\x00\x80",
               1, "\x80",
               3, "\x00\x08\x80" }
     },
     {  129, { "0081",
               2, "\x00\x81",
               6, "\x00\x00\x00\x02\x00\x81",
               1, "\x81",
               3, "\x00\x08\x81" }
     },
     {  255, { "00FF",
               2, "\x00\xff",
               6, "\x00\x00\x00\x02\x00\xff",
               1, "\xff",
               3, "\x00\x08\xff" }
     },
     {  256, { "0100",
               2, "\x01\x00",
               6, "\x00\x00\x00\x02\x01\x00",
               2, "\x01\x00",
               4, "\x00\x09\x01\x00" }
     },
     {  257, { "0101",
               2, "\x01\x01",
               6, "\x00\x00\x00\x02\x01\x01",
               2, "\x01\x01",
               4, "\x00\x09\x01\x01" }
     },
     {   -1, { "-01",
               1, "\xff",
               5, "\x00\x00\x00\x01\xff",
               1,"\x01" }
     },
     {   -2, { "-02",
               1, "\xfe",
               5, "\x00\x00\x00\x01\xfe",
               1, "\x02" }
     },
     { -127, { "-7F",
               1, "\x81",
               5, "\x00\x00\x00\x01\x81",
               1, "\x7f" }
     },
     { -128, { "-0080",
               1, "\x80",
               5, "\x00\x00\x00\x01\x80",
               1, "\x80" }
     },
     { -129, { "-0081",
               2, "\xff\x7f",
               6, "\x00\x00\x00\x02\xff\x7f",
               1, "\x81" }
     },
     { -255, { "-00FF",
               2, "\xff\x01",
               6, "\x00\x00\x00\x02\xff\x01",
               1, "\xff" }
     },
     { -256, { "-0100",
               2, "\xff\x00",
               6, "\x00\x00\x00\x02\xff\x00",
               2, "\x01\x00" }
     },
     { -257, { "-0101",
               2, "\xfe\xff",
               6, "\x00\x00\x00\x02\xfe\xff",
               2, "\x01\x01" }
     },
     {  65535, { "00FFFF",
                 3, "\x00\xff\xff",
                 7, "\x00\x00\x00\x03\x00\xff\xff",
                 2, "\xff\xff",
                 4, "\x00\x10\xff\xff" }
     },
     {  65536, { "010000",
                 3, "\x01\00\x00",
                 7, "\x00\x00\x00\x03\x01\x00\x00",
                 3, "\x01\x00\x00",
                 5, "\x00\x11\x01\x00\x00 "}
     },
     {  65537, { "010001",
                 3, "\x01\00\x01",
                 7, "\x00\x00\x00\x03\x01\x00\x01",
                 3, "\x01\x00\x01",
                 5, "\x00\x11\x01\x00\x01" }
     },
     { -65537, { "-010001",
                 3, "\xfe\xff\xff",
                 7, "\x00\x00\x00\x03\xfe\xff\xff",
                 3, "\x01\x00\x01" }
     },
     { -65536, { "-010000",
                 3, "\xff\x00\x00",
                 7, "\x00\x00\x00\x03\xff\x00\x00",
                 3, "\x01\x00\x00" }
     },
     { -65535, { "-00FFFF",
                 3, "\xff\x00\x01",
                 7, "\x00\x00\x00\x03\xff\x00\x01",
                 2, "\xff\xff" }
     }
   };
   gpg_error_t err;
   gcry_mpi_t a, b;
   char *buf;
   void *bufaddr = &buf;
   int idx;
   size_t buflen;
 
   a = gcry_mpi_new (0);
   for (idx=0; idx < DIM(data); idx++)
     {
       if (debug)
         info ("print test %d\n", data[idx].value);
 
       if (data[idx].value < 0)
         {
           gcry_mpi_set_ui (a, -data[idx].value);
           gcry_mpi_neg (a, a);
         }
       else
         gcry_mpi_set_ui (a, data[idx].value);
 
       err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
       if (err)
         fail ("error printing value %d as %s: %s\n",
               data[idx].value, "HEX", gpg_strerror (err));
       else
         {
           if (strcmp (buf, data[idx].a.hex))
             {
               fail ("error printing value %d as %s: %s\n",
                     data[idx].value, "HEX", "wrong result");
               info ("expected: '%s'\n", data[idx].a.hex);
               info ("     got: '%s'\n", buf);
             }
           gcry_free (buf);
         }
 
       err = gcry_mpi_aprint (GCRYMPI_FMT_STD, bufaddr, &buflen, a);
       if (err)
         fail ("error printing value %d as %s: %s\n",
               data[idx].value, "STD", gpg_strerror (err));
       else
         {
           if (buflen != data[idx].a.stdlen
               || memcmp (buf, data[idx].a.std, data[idx].a.stdlen))
             {
               fail ("error printing value %d as %s: %s\n",
                     data[idx].value, "STD", "wrong result");
               showhex ("expected:", data[idx].a.std, data[idx].a.stdlen);
               showhex ("     got:", buf, buflen);
             }
           gcry_free (buf);
         }
 
       err = gcry_mpi_aprint (GCRYMPI_FMT_SSH, bufaddr, &buflen, a);
       if (err)
         fail ("error printing value %d as %s: %s\n",
               data[idx].value, "SSH", gpg_strerror (err));
       else
         {
           if (buflen != data[idx].a.sshlen
               || memcmp (buf, data[idx].a.ssh, data[idx].a.sshlen))
             {
               fail ("error printing value %d as %s: %s\n",
                     data[idx].value, "SSH", "wrong result");
               showhex ("expected:", data[idx].a.ssh, data[idx].a.sshlen);
               showhex ("     got:", buf, buflen);
             }
           gcry_free (buf);
         }
 
       err = gcry_mpi_aprint (GCRYMPI_FMT_USG, bufaddr, &buflen, a);
       if (err)
         fail ("error printing value %d as %s: %s\n",
               data[idx].value, "USG", gpg_strerror (err));
       else
         {
           if (buflen != data[idx].a.usglen
               || memcmp (buf, data[idx].a.usg, data[idx].a.usglen))
             {
               fail ("error printing value %d as %s: %s\n",
                     data[idx].value, "USG", "wrong result");
               showhex ("expected:", data[idx].a.usg, data[idx].a.usglen);
               showhex ("     got:", buf, buflen);
             }
           gcry_free (buf);
         }
 
       err = gcry_mpi_aprint (GCRYMPI_FMT_PGP, bufaddr, &buflen, a);
       if (gcry_mpi_is_neg (a))
         {
           if (gpg_err_code (err) != GPG_ERR_INV_ARG)
             fail ("error printing value %d as %s: %s\n",
                   data[idx].value, "PGP", "Expected error not returned");
         }
       else if (err)
         fail ("error printing value %d as %s: %s\n",
               data[idx].value, "PGP", gpg_strerror (err));
       else
         {
           if (buflen != data[idx].a.pgplen
               || memcmp (buf, data[idx].a.pgp, data[idx].a.pgplen))
             {
               fail ("error printing value %d as %s: %s\n",
                     data[idx].value, "PGP", "wrong result");
               showhex ("expected:", data[idx].a.pgp, data[idx].a.pgplen);
               showhex ("     got:", buf, buflen);
             }
           gcry_free (buf);
         }
     }
 
 
   /* Now for the other direction.  */
   for (idx=0; idx < DIM(data); idx++)
     {
       if (debug)
         info ("scan test %d\n", data[idx].value);
 
       if (data[idx].value < 0)
         {
           gcry_mpi_set_ui (a, -data[idx].value);
           gcry_mpi_neg (a, a);
         }
       else
         gcry_mpi_set_ui (a, data[idx].value);
 
       err = gcry_mpi_scan (&b, GCRYMPI_FMT_HEX, data[idx].a.hex, 0, &buflen);
       if (err)
         fail ("error scanning value %d from %s: %s\n",
               data[idx].value, "HEX", gpg_strerror (err));
       else
         {
           if (gcry_mpi_cmp (a, b))
             {
               fail ("error scanning value %d from %s: %s\n",
                     data[idx].value, "HEX", "wrong result");
               showmpi ("expected:", a);
               showmpi ("     got:", b);
             }
           gcry_mpi_release (b);
         }
 
       err = gcry_mpi_scan (&b, GCRYMPI_FMT_STD,
                            data[idx].a.std, data[idx].a.stdlen, &buflen);
       if (err)
         fail ("error scanning value %d as %s: %s\n",
               data[idx].value, "STD", gpg_strerror (err));
       else
         {
           if (gcry_mpi_cmp (a, b) || data[idx].a.stdlen != buflen)
             {
               fail ("error scanning value %d from %s: %s (%lu)\n",
                     data[idx].value, "STD", "wrong result",
                     (long unsigned int)buflen);
               showmpi ("expected:", a);
               showmpi ("     got:", b);
             }
           gcry_mpi_release (b);
         }
 
       err = gcry_mpi_scan (&b, GCRYMPI_FMT_SSH,
                            data[idx].a.ssh, data[idx].a.sshlen, &buflen);
       if (err)
         fail ("error scanning value %d as %s: %s\n",
               data[idx].value, "SSH", gpg_strerror (err));
       else
         {
           if (gcry_mpi_cmp (a, b) || data[idx].a.sshlen != buflen)
             {
               fail ("error scanning value %d from %s: %s (%lu)\n",
                     data[idx].value, "SSH", "wrong result",
                     (long unsigned int)buflen);
               showmpi ("expected:", a);
               showmpi ("     got:", b);
             }
           gcry_mpi_release (b);
         }
 
       err = gcry_mpi_scan (&b, GCRYMPI_FMT_USG,
                            data[idx].a.usg, data[idx].a.usglen, &buflen);
       if (err)
         fail ("error scanning value %d as %s: %s\n",
               data[idx].value, "USG", gpg_strerror (err));
       else
         {
           if (gcry_mpi_is_neg (a))
             gcry_mpi_neg (b, b);
           if (gcry_mpi_cmp (a, b) || data[idx].a.usglen != buflen)
             {
               fail ("error scanning value %d from %s: %s (%lu)\n",
                     data[idx].value, "USG", "wrong result",
                     (long unsigned int)buflen);
               showmpi ("expected:", a);
               showmpi ("     got:", b);
             }
           gcry_mpi_release (b);
         }
 
       /* Negative values are not supported by PGP, thus we don't have
          an samples.  */
       if (!gcry_mpi_is_neg (a))
         {
           err = gcry_mpi_scan (&b, GCRYMPI_FMT_PGP,
                                data[idx].a.pgp, data[idx].a.pgplen, &buflen);
           if (err)
             fail ("error scanning value %d as %s: %s\n",
                   data[idx].value, "PGP", gpg_strerror (err));
           else
             {
               if (gcry_mpi_cmp (a, b) || data[idx].a.pgplen != buflen)
                 {
                   fail ("error scanning value %d from %s: %s (%lu)\n",
                         data[idx].value, "PGP", "wrong result",
                         (long unsigned int)buflen);
                   showmpi ("expected:", a);
                   showmpi ("     got:", b);
                 }
               gcry_mpi_release (b);
             }
         }
     }
 
   gcry_mpi_release (a);
 }
 
 
 int
 main (int argc, char **argv)
 {
   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     verbose = 1;
   else if (argc > 1 && !strcmp (argv[1], "--debug"))
     verbose = debug = 1;
 
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   negative_zero ();
   check_formats ();
 
   info ("All tests completed. Errors: %d\n", error_count);
   return error_count ? 1 : 0;
 }
diff --git a/tests/t-cv25519.c b/tests/t-cv25519.c
index 8c4a53eb..5634312d 100644
--- a/tests/t-cv25519.c
+++ b/tests/t-cv25519.c
@@ -1,571 +1,571 @@
 /* t-cv25519.c - Check the cv25519 crypto
  * Copyright (C) 2016 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdarg.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 
 #include "stopwatch.h"
 
 #define PGM "t-cv25519"
 #include "t-common.h"
 #define N_TESTS 18
 
 
 static void
 print_mpi (const char *text, gcry_mpi_t a)
 {
   gcry_error_t err;
   char *buf;
   void *bufaddr = &buf;
 
   err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
   if (err)
     fprintf (stderr, "%s: [error printing number: %s]\n",
              text, gpg_strerror (err));
   else
     {
       fprintf (stderr, "%s: %s\n", text, buf);
       gcry_free (buf);
     }
 }
 
 
 static void
 show_note (const char *format, ...)
 {
   va_list arg_ptr;
 
   if (!verbose && getenv ("srcdir"))
     fputs ("      ", stderr);  /* To align above "PASS: ".  */
   else
     fprintf (stderr, "%s: ", PGM);
   va_start (arg_ptr, format);
   vfprintf (stderr, format, arg_ptr);
   if (*format && format[strlen(format)-1] != '\n')
     putc ('\n', stderr);
   va_end (arg_ptr);
 }
 
 
 /* Convert STRING consisting of hex characters into its binary
    representation and return it as an allocated buffer. The valid
    length of the buffer is returned at R_LENGTH.  The string is
    delimited by end of string.  The function returns NULL on
    error.  */
 static void *
 hex2buffer (const char *string, size_t *r_length)
 {
   const char *s;
   unsigned char *buffer;
   size_t length;
 
   buffer = xmalloc (strlen(string)/2+1);
   length = 0;
   for (s=string; *s; s +=2 )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         return NULL;           /* Invalid hex digits. */
       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     }
   *r_length = length;
   return buffer;
 }
 
 static void
 reverse_buffer (unsigned char *buffer, unsigned int length)
 {
   unsigned int tmp, i;
 
   for (i=0; i < length/2; i++)
     {
       tmp = buffer[i];
       buffer[i] = buffer[length-1-i];
       buffer[length-1-i] = tmp;
     }
 }
 
 
 /*
  * Test X25519 functionality through higher layer crypto routines.
  *
  * Input: K (as hex string), U (as hex string), R (as hex string)
  *
  * where R is expected result of X25519 (K, U).
  *
  * It calls gcry_pk_decrypt with Curve25519 private key and let
  * it compute X25519.
  */
 static void
 test_cv (int testno, const char *k_str, const char *u_str,
          const char *result_str)
 {
   gpg_error_t err;
   void *buffer = NULL;
   size_t buflen;
   gcry_sexp_t s_pk = NULL;
   gcry_mpi_t mpi_k = NULL;
   gcry_sexp_t s_data = NULL;
   gcry_sexp_t s_result = NULL;
   gcry_sexp_t s_tmp = NULL;
   unsigned char *res = NULL;
   size_t res_len;
 
   if (verbose > 1)
     info ("Running test %d\n", testno);
 
   if (!(buffer = hex2buffer (k_str, &buflen)) || buflen != 32)
     {
       fail ("error building s-exp for test %d, %s: %s",
             testno, "k", "invalid hex string");
       goto leave;
     }
 
   reverse_buffer (buffer, buflen);
   if ((err = gcry_mpi_scan (&mpi_k, GCRYMPI_FMT_USG, buffer, buflen, NULL)))
     {
       fail ("error converting MPI for test %d: %s", testno, gpg_strerror (err));
       goto leave;
     }
 
   if ((err = gcry_sexp_build (&s_data, NULL, "%m", mpi_k)))
     {
       fail ("error building s-exp for test %d, %s: %s",
             testno, "data", gpg_strerror (err));
       goto leave;
     }
 
   xfree (buffer);
   if (!(buffer = hex2buffer (u_str, &buflen)) || buflen != 32)
     {
       fail ("error building s-exp for test %d, %s: %s",
             testno, "u", "invalid hex string");
       goto leave;
     }
 
   /*
    * The procedure of decodeUCoordinate will be done internally
    * by _gcry_ecc_mont_decodepoint.  So, we just put the little-endian
    * binary to build S-exp.
    *
    * We could add the prefix 0x40, but libgcrypt also supports
    * format with no prefix.  So, it is OK not to put the prefix.
    */
   if ((err = gcry_sexp_build (&s_pk, NULL,
                               "(public-key"
                               " (ecc"
                               "  (curve \"Curve25519\")"
                               "  (flags djb-tweak)"
                               "  (q%b)))", (int)buflen, buffer)))
     {
       fail ("error building s-exp for test %d, %s: %s",
             testno, "pk", gpg_strerror (err));
       goto leave;
     }
 
   xfree (buffer);
   buffer = NULL;
 
   if ((err = gcry_pk_encrypt (&s_result, s_data, s_pk)))
     fail ("gcry_pk_encrypt failed for test %d: %s", testno,
           gpg_strerror (err));
 
   s_tmp = gcry_sexp_find_token (s_result, "s", 0);
   if (!s_tmp || !(res = gcry_sexp_nth_buffer (s_tmp, 1, &res_len)))
     fail ("gcry_pk_encrypt failed for test %d: %s", testno, "missing value");
   else
     {
       char *r, *r0;
       int i;
 
       /* To skip the prefix 0x40, for-loop start with i=1 */
       r0 = r = xmalloc (2*(res_len)+1);
       if (!r0)
         {
           fail ("memory allocation for test %d", testno);
           goto leave;
         }
 
       for (i=1; i < res_len; i++, r += 2)
         snprintf (r, 3, "%02x", res[i]);
       if (strcmp (result_str, r0))
         {
           fail ("gcry_pk_encrypt failed for test %d: %s",
                 testno, "wrong value returned");
           info ("  expected: '%s'", result_str);
           info ("       got: '%s'", r0);
         }
       xfree (r0);
     }
 
  leave:
   xfree (res);
   gcry_mpi_release (mpi_k);
   gcry_sexp_release (s_tmp);
   gcry_sexp_release (s_result);
   gcry_sexp_release (s_data);
   gcry_sexp_release (s_pk);
   xfree (buffer);
 }
 
 /*
  * Test iterative X25519 computation through lower layer MPI routines.
  *
  * Input: K (as hex string), ITER, R (as hex string)
  *
  * where R is expected result of iterating X25519 by ITER times.
  *
  */
 static void
 test_it (int testno, const char *k_str, int iter, const char *result_str)
 {
   gcry_ctx_t ctx;
   gpg_error_t err;
   void *buffer = NULL;
   size_t buflen;
   gcry_mpi_t mpi_k = NULL;
   gcry_mpi_t mpi_x = NULL;
   gcry_mpi_point_t P = NULL;
   gcry_mpi_point_t Q;
   int i;
   gcry_mpi_t mpi_kk = NULL;
 
   if (verbose > 1)
     info ("Running test %d: iteration=%d\n", testno, iter);
 
   gcry_mpi_ec_new (&ctx, NULL, "Curve25519");
   Q = gcry_mpi_point_new (0);
 
   if (!(buffer = hex2buffer (k_str, &buflen)) || buflen != 32)
     {
       fail ("error scanning MPI for test %d, %s: %s",
             testno, "k", "invalid hex string");
       goto leave;
     }
   reverse_buffer (buffer, buflen);
   if ((err = gcry_mpi_scan (&mpi_x, GCRYMPI_FMT_USG, buffer, buflen, NULL)))
     {
       fail ("error scanning MPI for test %d, %s: %s",
             testno, "x", gpg_strerror (err));
       goto leave;
     }
 
   xfree (buffer);
   buffer = NULL;
 
   P = gcry_mpi_point_set (NULL, mpi_x, NULL, GCRYMPI_CONST_ONE);
 
   mpi_k = gcry_mpi_copy (mpi_x);
   if (debug)
     print_mpi ("k", mpi_k);
 
   for (i = 0; i < iter; i++)
     {
       /*
        * Another variant of decodeScalar25519 thing.
        */
       mpi_kk = gcry_mpi_set (mpi_kk, mpi_k);
       gcry_mpi_set_bit (mpi_kk, 254);
       gcry_mpi_clear_bit (mpi_kk, 255);
       gcry_mpi_clear_bit (mpi_kk, 0);
       gcry_mpi_clear_bit (mpi_kk, 1);
       gcry_mpi_clear_bit (mpi_kk, 2);
 
       gcry_mpi_ec_mul (Q, mpi_kk, P, ctx);
 
       P = gcry_mpi_point_set (P, mpi_k, NULL, GCRYMPI_CONST_ONE);
       gcry_mpi_ec_get_affine (mpi_k, NULL, Q, ctx);
 
       if (debug)
         print_mpi ("k", mpi_k);
     }
 
   {
     unsigned char res[32];
     char *r, *r0;
 
     gcry_mpi_print (GCRYMPI_FMT_USG, res, 32, NULL, mpi_k);
     reverse_buffer (res, 32);
 
     r0 = r = xmalloc (65);
     if (!r0)
       {
         fail ("memory allocation for test %d", testno);
         goto leave;
       }
 
     for (i=0; i < 32; i++, r += 2)
       snprintf (r, 3, "%02x", res[i]);
 
     if (strcmp (result_str, r0))
       {
         fail ("curv25519 failed for test %d: %s",
               testno, "wrong value returned");
         info ("  expected: '%s'", result_str);
         info ("       got: '%s'", r0);
       }
     xfree (r0);
   }
 
  leave:
   gcry_mpi_release (mpi_kk);
   gcry_mpi_release (mpi_k);
   gcry_mpi_point_release (P);
   gcry_mpi_release (mpi_x);
   xfree (buffer);
   gcry_mpi_point_release (Q);
   gcry_ctx_release (ctx);
 }
 
 /*
  * X-coordinate of generator of the Curve25519.
  */
 #define G_X "0900000000000000000000000000000000000000000000000000000000000000"
 
 /*
  * Test Diffie-Hellman in RFC-7748.
  *
  * Note that it's not like the ECDH of OpenPGP, where we use
  * ephemeral public key.
  */
 static void
 test_dh (int testno, const char *a_priv_str, const char *a_pub_str,
           const char *b_priv_str, const char *b_pub_str,
           const char *result_str)
 {
   /* Test A for private key corresponds to public key. */
   test_cv (testno, a_priv_str, G_X, a_pub_str);
   /* Test B for private key corresponds to public key. */
   test_cv (testno, b_priv_str, G_X, b_pub_str);
   /* Test DH with A's private key and B's public key. */
   test_cv (testno, a_priv_str, b_pub_str, result_str);
   /* Test DH with B's private key and A's public key. */
   test_cv (testno, b_priv_str, a_pub_str, result_str);
 }
 
 
 static void
 check_cv25519 (void)
 {
   int ntests;
 
   info ("Checking Curve25519.\n");
 
   ntests = 0;
 
   /*
    * Values are cited from RFC-7748: 5.2.  Test Vectors.
    * Following two tests are for the first type test.
    */
   test_cv (1,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "e6db6867583030db3594c1a424b15f7c726624ec26b3353b10a903a6d0ab1c4c",
            "c3da55379de9c6908e94ea4df28d084f32eccf03491c71f754b4075577a28552");
   ntests++;
   test_cv (2,
            "4b66e9d4d1b4673c5ad22691957d6af5c11b6421e0ea01d42ca4169e7918ba0d",
            "e5210f12786811d3f4b7959d0538ae2c31dbe7106fc03c3efc4cd549c715a493",
            "95cbde9476e8907d7aade45cb4b873f88b595a68799fa152e6f8f7647aac7957");
   ntests++;
 
   /*
    * Additional test.  Value is from second type test.
    */
   test_cv (3,
            G_X,
            G_X,
            "422c8e7a6227d7bca1350b3e2bb7279f7897b87bb6854b783c60e80311ae3079");
   ntests++;
 
   /*
    * Following two tests are for the second type test,
    * with one iteration and 1,000 iterations.  (1,000,000 iterations
    * takes too long.)
    */
   test_it (4,
            G_X,
            1,
            "422c8e7a6227d7bca1350b3e2bb7279f7897b87bb6854b783c60e80311ae3079");
   ntests++;
 
   test_it (5,
            G_X,
            1000,
            "684cf59ba83309552800ef566f2f4d3c1c3887c49360e3875f2eb94d99532c51");
   ntests++;
 
   /*
    * Last test is from: 6.  Diffie-Hellman, 6.1.  Curve25519
    */
   test_dh (6,
            /* Alice's private key, a */
            "77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a",
            /* Alice's public key, X25519(a, 9) */
            "8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a",
            /* Bob's private key, b */
            "5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb",
            /* Bob's public key, X25519(b, 9) */
            "de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f",
            /* Their shared secret, K */
            "4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742");
   ntests++;
 
   /* Seven tests which results 0. */
   test_cv (7,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "0000000000000000000000000000000000000000000000000000000000000000",
            "0000000000000000000000000000000000000000000000000000000000000000");
   ntests++;
 
   test_cv (8,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "0100000000000000000000000000000000000000000000000000000000000000",
            "0000000000000000000000000000000000000000000000000000000000000000");
   ntests++;
 
   test_cv (9,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "e0eb7a7c3b41b8ae1656e3faf19fc46ada098deb9c32b1fd866205165f49b800",
            "0000000000000000000000000000000000000000000000000000000000000000");
   ntests++;
 
   test_cv (10,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "5f9c95bca3508c24b1d0b1559c83ef5b04445cc4581c8e86d8224eddd09f1157",
            "0000000000000000000000000000000000000000000000000000000000000000");
   ntests++;
 
   test_cv (11,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
            "0000000000000000000000000000000000000000000000000000000000000000");
   ntests++;
 
   test_cv (12,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
            "0000000000000000000000000000000000000000000000000000000000000000");
   ntests++;
 
   test_cv (13,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
            "0000000000000000000000000000000000000000000000000000000000000000");
   ntests++;
 
   /* Five tests which resulted 0 if decodeUCoordinate didn't change MSB. */
   test_cv (14,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "cdeb7a7c3b41b8ae1656e3faf19fc46ada098deb9c32b1fd866205165f49b880",
            "7ce548bc4919008436244d2da7a9906528fe3a6d278047654bd32d8acde9707b");
   ntests++;
 
   test_cv (15,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "4c9c95bca3508c24b1d0b1559c83ef5b04445cc4581c8e86d8224eddd09f11d7",
            "e17902e989a034acdf7248260e2c94cdaf2fe1e72aaac7024a128058b6189939");
   ntests++;
 
   test_cv (16,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "d9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
            "ea6e6ddf0685c31e152d5818441ac9ac8db1a01f3d6cb5041b07443a901e7145");
   ntests++;
 
   test_cv (17,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "daffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
            "845ddce7b3a9b3ee01a2f1fd4282ad293310f7a232cbc5459fb35d94bccc9d05");
   ntests++;
 
   test_cv (18,
            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
            "dbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
            "6989e2cb1cea159acf121b0af6bf77493189c9bd32c2dac71669b540f9488247");
   ntests++;
 
   if (ntests != N_TESTS)
     fail ("did %d tests but expected %d", ntests, N_TESTS);
   else if ((ntests % 256))
     show_note ("%d tests done\n", ntests);
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           fputs ("usage: " PGM " [options]\n"
                  "Options:\n"
                  "  --verbose       print timings etc.\n"
                  "  --debug         flyswatter\n",
                  stdout);
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose += 2;
           debug++;
           argc--; argv++;
         }
       else if (!strncmp (*argv, "--", 2))
         die ("unknown option '%s'", *argv);
     }
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u , 0));
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   start_timer ();
   check_cv25519 ();
   stop_timer ();
 
   info ("All tests completed in %s.  Errors: %d\n",
         elapsed_time (1), error_count);
   return !!error_count;
 }
diff --git a/tests/t-ed25519.c b/tests/t-ed25519.c
index 73628a81..a5271c25 100644
--- a/tests/t-ed25519.c
+++ b/tests/t-ed25519.c
@@ -1,497 +1,497 @@
 /* t-ed25519.c - Check the Ed25519 crypto
  * Copyright (C) 2013 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdarg.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 
 #include "stopwatch.h"
 
 #define PGM "t-ed25519"
 #include "t-common.h"
 #define N_TESTS 1026
 
 static int sign_with_pk;
 static int no_verify;
 static int custom_data_file;
 
 
 static void
 show_note (const char *format, ...)
 {
   va_list arg_ptr;
 
   if (!verbose && getenv ("srcdir"))
     fputs ("      ", stderr);  /* To align above "PASS: ".  */
   else
     fprintf (stderr, "%s: ", PGM);
   va_start (arg_ptr, format);
   vfprintf (stderr, format, arg_ptr);
   if (*format && format[strlen(format)-1] != '\n')
     putc ('\n', stderr);
   va_end (arg_ptr);
 }
 
 
 static void
 show_sexp (const char *prefix, gcry_sexp_t a)
 {
   char *buf;
   size_t size;
 
   fprintf (stderr, "%s: ", PGM);
   if (prefix)
     fputs (prefix, stderr);
   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   buf = xmalloc (size);
 
   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
   fprintf (stderr, "%.*s", (int)size, buf);
   gcry_free (buf);
 }
 
 
 /* Prepend FNAME with the srcdir environment variable's value and
  * return an allocated filename.  */
 char *
 prepend_srcdir (const char *fname)
 {
   static const char *srcdir;
   char *result;
 
   if (!srcdir && !(srcdir = getenv ("srcdir")))
     srcdir = ".";
 
   result = xmalloc (strlen (srcdir) + 1 + strlen (fname) + 1);
   strcpy (result, srcdir);
   strcat (result, "/");
   strcat (result, fname);
   return result;
 }
 
 
 /* Read next line but skip over empty and comment lines.  Caller must
    xfree the result.  */
 static char *
 read_textline (FILE *fp, int *lineno)
 {
   char line[4096];
   char *p;
 
   do
     {
       if (!fgets (line, sizeof line, fp))
         {
           if (feof (fp))
             return NULL;
           die ("error reading input line: %s\n", strerror (errno));
         }
       ++*lineno;
       p = strchr (line, '\n');
       if (!p)
         die ("input line %d not terminated or too long\n", *lineno);
       *p = 0;
       for (p--;p > line && my_isascii (*p) && isspace (*p); p--)
         *p = 0;
     }
   while (!*line || *line == '#');
   /* if (debug) */
   /*   info ("read line: '%s'\n", line); */
   return xstrdup (line);
 }
 
 
 /* Copy the data after the tag to BUFFER.  BUFFER will be allocated as
    needed.  */
 static void
 copy_data (char **buffer, const char *line, int lineno)
 {
   const char *s;
 
   xfree (*buffer);
   *buffer = NULL;
 
   s = strchr (line, ':');
   if (!s)
     {
       fail ("syntax error at input line %d", lineno);
       return;
     }
   for (s++; my_isascii (*s) && isspace (*s); s++)
     ;
   *buffer = xstrdup (s);
 }
 
 
 /* Convert STRING consisting of hex characters into its binary
    representation and return it as an allocated buffer. The valid
    length of the buffer is returned at R_LENGTH.  The string is
    delimited by end of string.  The function returns NULL on
    error.  */
 static void *
 hex2buffer (const char *string, size_t *r_length)
 {
   const char *s;
   unsigned char *buffer;
   size_t length;
 
   buffer = xmalloc (strlen(string)/2+1);
   length = 0;
   for (s=string; *s; s +=2 )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         return NULL;           /* Invalid hex digits. */
       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     }
   *r_length = length;
   return buffer;
 }
 
 
 static void
 hexdowncase (char *string)
 {
   char *p;
 
   for (p=string; *p; p++)
     if (my_isascii (*p))
       *p = tolower (*p);
 }
 
 
 static void
 one_test (int testno, const char *sk, const char *pk,
           const char *msg, const char *sig)
 {
   gpg_error_t err;
   int i;
   char *p;
   void *buffer = NULL;
   void *buffer2 = NULL;
   size_t buflen, buflen2;
   gcry_sexp_t s_tmp, s_tmp2;
   gcry_sexp_t s_sk = NULL;
   gcry_sexp_t s_pk = NULL;
   gcry_sexp_t s_msg= NULL;
   gcry_sexp_t s_sig= NULL;
   unsigned char *sig_r = NULL;
   unsigned char *sig_s = NULL;
   char *sig_rs_string = NULL;
   size_t sig_r_len, sig_s_len;
 
   if (verbose > 1)
     info ("Running test %d\n", testno);
 
   if (!(buffer = hex2buffer (sk, &buflen)))
     {
       fail ("error building s-exp for test %d, %s: %s",
             testno, "sk", "invalid hex string");
       goto leave;
     }
   if (!(buffer2 = hex2buffer (pk, &buflen2)))
     {
       fail ("error building s-exp for test %d, %s: %s",
             testno, "pk", "invalid hex string");
       goto leave;
     }
   if (sign_with_pk)
     err = gcry_sexp_build (&s_sk, NULL,
                            "(private-key"
                            " (ecc"
                            "  (curve \"Ed25519\")"
                            "  (flags eddsa)"
                            "  (q %b)"
                            "  (d %b)))",
                            (int)buflen2, buffer2,
                            (int)buflen, buffer);
   else
     err = gcry_sexp_build (&s_sk, NULL,
                            "(private-key"
                            " (ecc"
                            "  (curve \"Ed25519\")"
                            "  (flags eddsa)"
                            "  (d %b)))",
                            (int)buflen, buffer);
   if (err)
     {
       fail ("error building s-exp for test %d, %s: %s",
             testno, "sk", gpg_strerror (err));
       goto leave;
     }
 
   if ((err = gcry_sexp_build (&s_pk, NULL,
                               "(public-key"
                               " (ecc"
                               "  (curve \"Ed25519\")"
                               "  (flags eddsa)"
                               "  (q %b)))",  (int)buflen2, buffer2)))
     {
       fail ("error building s-exp for test %d, %s: %s",
             testno, "pk", gpg_strerror (err));
       goto leave;
     }
 
   xfree (buffer);
   if (!(buffer = hex2buffer (msg, &buflen)))
     {
       fail ("error building s-exp for test %d, %s: %s",
             testno, "msg", "invalid hex string");
       goto leave;
     }
   if ((err = gcry_sexp_build (&s_msg, NULL,
                               "(data"
                               " (flags eddsa)"
                               " (hash-algo sha512)"
                               " (value %b))",  (int)buflen, buffer)))
     {
       fail ("error building s-exp for test %d, %s: %s",
             testno, "msg", gpg_strerror (err));
       goto leave;
     }
 
   if ((err = gcry_pk_sign (&s_sig, s_msg, s_sk)))
     fail ("gcry_pk_sign failed for test %d: %s", testno, gpg_strerror (err));
   if (debug)
     show_sexp ("sig=", s_sig);
 
   s_tmp2 = NULL;
   s_tmp = gcry_sexp_find_token (s_sig, "sig-val", 0);
   if (s_tmp)
     {
       s_tmp2 = s_tmp;
       s_tmp = gcry_sexp_find_token (s_tmp2, "eddsa", 0);
       if (s_tmp)
         {
           gcry_sexp_release (s_tmp2);
           s_tmp2 = s_tmp;
           s_tmp = gcry_sexp_find_token (s_tmp2, "r", 0);
           if (s_tmp)
             {
               sig_r = gcry_sexp_nth_buffer (s_tmp, 1, &sig_r_len);
               gcry_sexp_release (s_tmp);
             }
           s_tmp = gcry_sexp_find_token (s_tmp2, "s", 0);
           if (s_tmp)
             {
               sig_s = gcry_sexp_nth_buffer (s_tmp, 1, &sig_s_len);
               gcry_sexp_release (s_tmp);
             }
         }
     }
   gcry_sexp_release (s_tmp2); s_tmp2 = NULL;
 
   if (!sig_r || !sig_s)
     fail ("gcry_pk_sign failed for test %d: %s", testno, "r or s missing");
   else
     {
       sig_rs_string = xmalloc (2*(sig_r_len + sig_s_len)+1);
       p = sig_rs_string;
       *p = 0;
       for (i=0; i < sig_r_len; i++, p += 2)
         snprintf (p, 3, "%02x", sig_r[i]);
       for (i=0; i < sig_s_len; i++, p += 2)
         snprintf (p, 3, "%02x", sig_s[i]);
       if (strcmp (sig_rs_string, sig))
         {
           fail ("gcry_pk_sign failed for test %d: %s",
                 testno, "wrong value returned");
           info ("  expected: '%s'", sig);
           info ("       got: '%s'", sig_rs_string);
         }
     }
 
   if (!no_verify)
     if ((err = gcry_pk_verify (s_sig, s_msg, s_pk)))
       fail ("gcry_pk_verify failed for test %d: %s",
             testno, gpg_strerror (err));
 
 
  leave:
   gcry_sexp_release (s_sig);
   gcry_sexp_release (s_sk);
   gcry_sexp_release (s_pk);
   gcry_sexp_release (s_msg);
   xfree (buffer);
   xfree (buffer2);
   xfree (sig_r);
   xfree (sig_s);
   xfree (sig_rs_string);
 }
 
 
 static void
 check_ed25519 (const char *fname)
 {
   FILE *fp;
   int lineno, ntests;
   char *line;
   int testno;
   char *sk, *pk, *msg, *sig;
 
   info ("Checking Ed25519.\n");
 
   fp = fopen (fname, "r");
   if (!fp)
     die ("error opening '%s': %s\n", fname, strerror (errno));
 
   testno = 0;
   sk = pk = msg = sig = NULL;
   lineno = ntests = 0;
   while ((line = read_textline (fp, &lineno)))
     {
       if (!strncmp (line, "TST:", 4))
         testno = atoi (line+4);
       else if (!strncmp (line, "SK:", 3))
         copy_data (&sk, line, lineno);
       else if (!strncmp (line, "PK:", 3))
         copy_data (&pk, line, lineno);
       else if (!strncmp (line, "MSG:", 4))
         copy_data (&msg, line, lineno);
       else if (!strncmp (line, "SIG:", 4))
         copy_data (&sig, line, lineno);
       else
         fail ("unknown tag at input line %d", lineno);
 
       xfree (line);
       if (testno && sk && pk && msg && sig)
         {
           hexdowncase (sig);
           one_test (testno, sk, pk, msg, sig);
           ntests++;
           if (!(ntests % 256))
             show_note ("%d of %d tests done\n", ntests, N_TESTS);
           xfree (pk);  pk = NULL;
           xfree (sk);  sk = NULL;
           xfree (msg); msg = NULL;
           xfree (sig); sig = NULL;
         }
 
     }
   xfree (pk);
   xfree (sk);
   xfree (msg);
   xfree (sig);
 
   if (ntests != N_TESTS && !custom_data_file)
     fail ("did %d tests but expected %d", ntests, N_TESTS);
   else if ((ntests % 256))
     show_note ("%d tests done\n", ntests);
 
   fclose (fp);
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   char *fname = NULL;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           fputs ("usage: " PGM " [options]\n"
                  "Options:\n"
                  "  --verbose       print timings etc.\n"
                  "  --debug         flyswatter\n"
                  "  --sign-with-pk  also use the public key for signing\n"
                  "  --no-verify     skip the verify test\n"
                  "  --data FNAME    take test data from file FNAME\n",
                  stdout);
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose += 2;
           debug++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--sign-with-pk"))
         {
           sign_with_pk = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--no-verify"))
         {
           no_verify = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--data"))
         {
           argc--; argv++;
           if (argc)
             {
               xfree (fname);
               fname = xstrdup (*argv);
               argc--; argv++;
             }
         }
       else if (!strncmp (*argv, "--", 2))
         die ("unknown option '%s'", *argv);
 
     }
 
   if (!fname)
     fname = prepend_srcdir ("t-ed25519.inp");
   else
     custom_data_file = 1;
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u , 0));
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   /* Ed25519 isn't supported in fips mode */
   if (gcry_fips_mode_active())
     return 77;
 
   start_timer ();
   check_ed25519 (fname);
   stop_timer ();
 
   xfree (fname);
 
   info ("All tests completed in %s.  Errors: %d\n",
         elapsed_time (1), error_count);
   return !!error_count;
 }
diff --git a/tests/t-kdf.c b/tests/t-kdf.c
index e011ef4f..7a48e98a 100644
--- a/tests/t-kdf.c
+++ b/tests/t-kdf.c
@@ -1,1292 +1,1292 @@
 /* t-kdf.c -  KDF regression tests
  * Copyright (C) 2011 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <assert.h>
 
 #include "stopwatch.h"
 #define PGM "t-kdf"
 #include "t-common.h"
 
 
 static void
 dummy_consumer (volatile char *buffer, size_t buflen)
 {
   (void)buffer;
   (void)buflen;
 }
 
 
 static void
 bench_s2k (unsigned long s2kcount)
 {
   gpg_error_t err;
   const char passphrase[] = "123456789abcdef0";
   char keybuf[128/8];
   unsigned int repetitions = 10;
   unsigned int count;
   const char *elapsed;
   int pass = 0;
 
  again:
   start_timer ();
   for (count = 0; count < repetitions; count++)
     {
       err = gcry_kdf_derive (passphrase, strlen (passphrase),
                              GCRY_KDF_ITERSALTED_S2K,
                              GCRY_MD_SHA1, "saltsalt", 8, s2kcount,
                              sizeof keybuf, keybuf);
       if (err)
         die ("gcry_kdf_derive failed: %s\n", gpg_strerror (err));
       dummy_consumer (keybuf, sizeof keybuf);
     }
   stop_timer ();
 
   elapsed = elapsed_time (repetitions);
   if (!pass++)
     {
       if (!atoi (elapsed))
         {
           repetitions = 10000;
           goto again;
         }
       else if (atoi (elapsed) < 10)
         {
           repetitions = 100;
           goto again;
         }
     }
 
   printf ("%s\n", elapsed);
 }
 
 
 static void
 check_openpgp (void)
 {
   /* Test vectors manually created with gpg 1.4 derived code: In
      passphrase.c:hash_passpharse, add this code to the end of the
      function:
 
        ===8<===
        printf ("{\n"
                "  \"");
        for (i=0; i < pwlen; i++)
          {
            if (i && !(i%16))
              printf ("\"\n  \"");
            printf ("\\x%02x", ((const unsigned char *)pw)[i]);
          }
        printf ("\", %d,\n", pwlen);
 
        printf ("  %s, %s,\n",
                s2k->mode == 0? "GCRY_KDF_SIMPLE_S2K":
                s2k->mode == 1? "GCRY_KDF_SALTED_S2K":
                s2k->mode == 3? "GCRY_KDF_ITERSALTED_S2K":"?",
                s2k->hash_algo == DIGEST_ALGO_MD5   ? "GCRY_MD_MD5" :
                s2k->hash_algo == DIGEST_ALGO_SHA1  ? "GCRY_MD_SHA1" :
                s2k->hash_algo == DIGEST_ALGO_RMD160? "GCRY_MD_RMD160" :
                s2k->hash_algo == DIGEST_ALGO_SHA256? "GCRY_MD_SHA256" :
                s2k->hash_algo == DIGEST_ALGO_SHA384? "GCRY_MD_SHA384" :
                s2k->hash_algo == DIGEST_ALGO_SHA512? "GCRY_MD_SHA512" :
                s2k->hash_algo == DIGEST_ALGO_SHA224? "GCRY_MD_SHA224" : "?");
 
        if (s2k->mode == 0)
          printf ("  NULL, 0,\n");
        else
          {
            printf ("  \"");
            for (i=0; i < 8; i++)
              printf ("\\x%02x", (unsigned int)s2k->salt[i]);
            printf ("\", %d,\n", 8);
          }
 
        if (s2k->mode == 3)
          printf ("  %lu,\n", (unsigned long)S2K_DECODE_COUNT(s2k->count));
        else
          printf ("  0,\n");
 
        printf ("  %d,\n", (int)dek->keylen);
 
        printf ("  \"");
        for (i=0; i < dek->keylen; i++)
          {
            if (i && !(i%16))
              printf ("\"\n  \"");
            printf ("\\x%02x", ((unsigned char *)dek->key)[i]);
          }
        printf ("\"\n},\n");
        ===>8===
 
      Then prepare a file x.inp with utf8 encoding:
 
        ===8<===
        0 aes    md5 1024 a
        0 aes    md5 1024 ab
        0 aes    md5 1024 abc
        0 aes    md5 1024 abcd
        0 aes    md5 1024 abcde
        0 aes    md5 1024 abcdef
        0 aes    md5 1024 abcdefg
        0 aes    md5 1024 abcdefgh
        0 aes    md5 1024 abcdefghi
        0 aes    md5 1024 abcdefghijklmno
        0 aes    md5 1024 abcdefghijklmnop
        0 aes    md5 1024 abcdefghijklmnopq
        0 aes    md5 1024 Long_sentence_used_as_passphrase
        0 aes    md5 1024 With_utf8_umlauts:äüÖß
        0 aes    sha1 1024 a
        0 aes    sha1 1024 ab
        0 aes    sha1 1024 abc
        0 aes    sha1 1024 abcd
        0 aes    sha1 1024 abcde
        0 aes    sha1 1024 abcdef
        0 aes    sha1 1024 abcdefg
        0 aes    sha1 1024 abcdefgh
        0 aes    sha1 1024 abcdefghi
        0 aes    sha1 1024 abcdefghijklmno
        0 aes    sha1 1024 abcdefghijklmnop
        0 aes    sha1 1024 abcdefghijklmnopq
        0 aes    sha1 1024 abcdefghijklmnopqr
        0 aes    sha1 1024 abcdefghijklmnopqrs
        0 aes    sha1 1024 abcdefghijklmnopqrst
        0 aes    sha1 1024 abcdefghijklmnopqrstu
        0 aes    sha1 1024 Long_sentence_used_as_passphrase
        0 aes256 sha1 1024 Long_sentence_used_as_passphrase
        0 aes    sha1 1024 With_utf8_umlauts:äüÖß
        3 aes    sha1 1024 a
        3 aes    sha1 1024 ab
        3 aes    sha1 1024 abc
        3 aes    sha1 1024 abcd
        3 aes    sha1 1024 abcde
        3 aes    sha1 1024 abcdef
        3 aes    sha1 1024 abcdefg
        3 aes    sha1 1024 abcdefgh
        3 aes    sha1 1024 abcdefghi
        3 aes    sha1 1024 abcdefghijklmno
        3 aes    sha1 1024 abcdefghijklmnop
        3 aes    sha1 1024 abcdefghijklmnopq
        3 aes    sha1 1024 abcdefghijklmnopqr
        3 aes    sha1 1024 abcdefghijklmnopqrs
        3 aes    sha1 1024 abcdefghijklmnopqrst
        3 aes    sha1 1024 abcdefghijklmnopqrstu
        3 aes    sha1 1024 With_utf8_umlauts:äüÖß
        3 aes    sha1 1024 Long_sentence_used_as_passphrase
        3 aes    sha1 10240 Long_sentence_used_as_passphrase
        3 aes    sha1 102400 Long_sentence_used_as_passphrase
        3 aes192 sha1 1024 a
        3 aes192 sha1 1024 abcdefg
        3 aes192 sha1 1024 abcdefghi
        3 aes192 sha1 1024 abcdefghi
        3 aes192 sha1 1024 Long_sentence_used_as_passphrase
        3 aes256 sha1 1024 a
        3 aes256 sha1 1024 abcdefg
        3 aes256 sha1 1024 abcdefghi
        3 aes256 sha1 1024 abcdefghi
        3 aes256 sha1 1024 Long_sentence_used_as_passphrase
        0 aes    sha256 1024 Long_sentence_used_as_passphrase
        1 aes    sha256 1024 Long_sentence_used_as_passphrase
        3 aes    sha256 1024 Long_sentence_used_as_passphrase
        3 aes    sha256 10240 Long_sentence_used_as_passphrase
        3 aes    sha384 1024 Long_sentence_used_as_passphrase
        3 aes    sha512 1024 Long_sentence_used_as_passphrase
        3 aes256 sha512 1024 Long_sentence_used_as_passphrase
        3 3des   sha512 1024 Long_sentence_used_as_passphrase
        ===>8===
 
     and finally using a proper utf-8 enabled shell, run:
 
        cat x.inp | while read mode cipher digest count pass dummy; do \
          ./gpg </dev/null -o /dev/null -c  --passphrase "$pass" \
            --s2k-mode $mode --s2k-digest $digest --s2k-count $count \
            --cipher-algo $cipher ; done >x.out
   */
   static struct {
     const char *p;   /* Passphrase.  */
     size_t plen;     /* Length of P. */
     int algo;
     int hashalgo;
     const char *salt;
     size_t saltlen;
     unsigned long c; /* Iterations.  */
     int dklen;       /* Requested key length.  */
     const char *dk;  /* Derived key.  */
     int disabled;
   } tv[] = {
     {
       "\x61", 1,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\x0c\xc1\x75\xb9\xc0\xf1\xb6\xa8\x31\xc3\x99\xe2\x69\x77\x26\x61"
     },
     {
       "\x61\x62", 2,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\x18\x7e\xf4\x43\x61\x22\xd1\xcc\x2f\x40\xdc\x2b\x92\xf0\xeb\xa0"
     },
     {
       "\x61\x62\x63", 3,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\x90\x01\x50\x98\x3c\xd2\x4f\xb0\xd6\x96\x3f\x7d\x28\xe1\x7f\x72"
     },
     {
       "\x61\x62\x63\x64", 4,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\xe2\xfc\x71\x4c\x47\x27\xee\x93\x95\xf3\x24\xcd\x2e\x7f\x33\x1f"
     },
     {
       "\x61\x62\x63\x64\x65", 5,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\xab\x56\xb4\xd9\x2b\x40\x71\x3a\xcc\x5a\xf8\x99\x85\xd4\xb7\x86"
     },
     {
       "\x61\x62\x63\x64\x65\x66", 6,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\xe8\x0b\x50\x17\x09\x89\x50\xfc\x58\xaa\xd8\x3c\x8c\x14\x97\x8e"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67", 7,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\x7a\xc6\x6c\x0f\x14\x8d\xe9\x51\x9b\x8b\xd2\x64\x31\x2c\x4d\x64"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68", 8,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\xe8\xdc\x40\x81\xb1\x34\x34\xb4\x51\x89\xa7\x20\xb7\x7b\x68\x18"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69", 9,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\x8a\xa9\x9b\x1f\x43\x9f\xf7\x12\x93\xe9\x53\x57\xba\xc6\xfd\x94"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f", 15,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\x8a\x73\x19\xdb\xf6\x54\x4a\x74\x22\xc9\xe2\x54\x52\x58\x0e\xa5"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70", 16,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\x1d\x64\xdc\xe2\x39\xc4\x43\x7b\x77\x36\x04\x1d\xb0\x89\xe1\xb9"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
       "\x71", 17,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\x9a\x8d\x98\x45\xa6\xb4\xd8\x2d\xfc\xb2\xc2\xe3\x51\x62\xc8\x30"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\x35\x2a\xf0\xfc\xdf\xe9\xbb\x62\x16\xfc\x99\x9d\x8d\x58\x05\xcb"
     },
     {
       "\x57\x69\x74\x68\x5f\x75\x74\x66\x38\x5f\x75\x6d\x6c\x61\x75\x74"
       "\x73\x3a\xc3\xa4\xc3\xbc\xc3\x96\xc3\x9f", 26,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_MD5,
       NULL, 0,
       0,
       16,
       "\x21\xa4\xeb\xd8\xfd\xf0\x59\x25\xd1\x32\x31\xdb\xe7\xf2\x13\x5d"
     },
     {
       "\x61", 1,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\x86\xf7\xe4\x37\xfa\xa5\xa7\xfc\xe1\x5d\x1d\xdc\xb9\xea\xea\xea"
     },
     {
       "\x61\x62", 2,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\xda\x23\x61\x4e\x02\x46\x9a\x0d\x7c\x7b\xd1\xbd\xab\x5c\x9c\x47"
     },
     {
       "\x61\x62\x63", 3,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\xa9\x99\x3e\x36\x47\x06\x81\x6a\xba\x3e\x25\x71\x78\x50\xc2\x6c"
     },
     {
       "\x61\x62\x63\x64", 4,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\x81\xfe\x8b\xfe\x87\x57\x6c\x3e\xcb\x22\x42\x6f\x8e\x57\x84\x73"
     },
     {
       "\x61\x62\x63\x64\x65", 5,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\x03\xde\x6c\x57\x0b\xfe\x24\xbf\xc3\x28\xcc\xd7\xca\x46\xb7\x6e"
     },
     {
       "\x61\x62\x63\x64\x65\x66", 6,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\x1f\x8a\xc1\x0f\x23\xc5\xb5\xbc\x11\x67\xbd\xa8\x4b\x83\x3e\x5c"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67", 7,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\x2f\xb5\xe1\x34\x19\xfc\x89\x24\x68\x65\xe7\xa3\x24\xf4\x76\xec"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68", 8,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\x42\x5a\xf1\x2a\x07\x43\x50\x2b\x32\x2e\x93\xa0\x15\xbc\xf8\x68"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69", 9,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\xc6\x3b\x19\xf1\xe4\xc8\xb5\xf7\x6b\x25\xc4\x9b\x8b\x87\xf5\x7d"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f", 15,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\x29\x38\xdc\xc2\xe3\xaa\x77\x98\x7c\x7e\x5d\x4a\x0f\x26\x96\x67"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70", 16,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\x14\xf3\x99\x52\x88\xac\xd1\x89\xe6\xe5\x0a\x7a\xf4\x7e\xe7\x09"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
       "\x71", 17,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\xd8\x3d\x62\x1f\xcd\x2d\x4d\x29\x85\x54\x70\x43\xa7\xa5\xfd\x4d"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
       "\x71\x72", 18,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\xe3\x81\xfe\x42\xc5\x7e\x48\xa0\x82\x17\x86\x41\xef\xfd\x1c\xb9"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
       "\x71\x72\x73", 19,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\x89\x3e\x69\xff\x01\x09\xf3\x45\x9c\x42\x43\x01\x3b\x3d\xe8\xb1"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
       "\x71\x72\x73\x74", 20,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\x14\xa2\x3a\xd7\x0f\x2a\x5d\xd7\x25\x57\x5d\xe6\xc4\x3e\x1c\xdd"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
       "\x71\x72\x73\x74\x75", 21,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\xec\xa9\x86\xb9\x5d\x58\x7f\x34\xd7\x1c\xa7\x75\x2a\x4e\x00\x10"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\x3e\x1b\x9a\x50\x7d\x6e\x9a\xd8\x93\x64\x96\x7a\x3f\xcb\x27\x3f"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       32,
       "\x3e\x1b\x9a\x50\x7d\x6e\x9a\xd8\x93\x64\x96\x7a\x3f\xcb\x27\x3f"
       "\xc3\x7b\x3a\xb2\xef\x4d\x68\xaa\x9c\xd7\xe4\x88\xee\xd1\x5e\x70"
     },
     {
       "\x57\x69\x74\x68\x5f\x75\x74\x66\x38\x5f\x75\x6d\x6c\x61\x75\x74"
       "\x73\x3a\xc3\xa4\xc3\xbc\xc3\x96\xc3\x9f", 26,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA1,
       NULL, 0,
       0,
       16,
       "\xe0\x4e\x1e\xe3\xad\x0b\x49\x7c\x7a\x5f\x37\x3b\x4d\x90\x3c\x2e"
     },
     {
       "\x61", 1,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x6d\x47\xe3\x68\x5d\x2c\x36\x16", 8,
       1024,
       16,
       "\x41\x9f\x48\x6e\xbf\xe6\xdd\x05\x9a\x72\x23\x17\x44\xd8\xd3\xf3"
     },
     {
       "\x61\x62", 2,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x7c\x34\x78\xfb\x28\x2d\x25\xc7", 8,
       1024,
       16,
       "\x0a\x9d\x09\x06\x43\x3d\x4f\xf9\x87\xd6\xf7\x48\x90\xde\xd1\x1c"
     },
     {
       "\x61\x62\x63", 3,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xc3\x16\x37\x2e\x27\xf6\x9f\x6f", 8,
       1024,
       16,
       "\xf8\x27\xa0\x07\xc6\xcb\xdd\xf1\xfe\x5c\x88\x3a\xfc\xcd\x84\x4d"
     },
     {
       "\x61\x62\x63\x64", 4,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xf0\x0c\x73\x38\xb7\xc3\xd5\x14", 8,
       1024,
       16,
       "\x9b\x5f\x26\xba\x52\x3b\xcd\xd9\xa5\x2a\xef\x3c\x03\x4d\xd1\x52"
     },
     {
       "\x61\x62\x63\x64\x65", 5,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xe1\x7d\xa2\x36\x09\x59\xee\xc5", 8,
       1024,
       16,
       "\x94\x9d\x5b\x1a\x5a\x66\x8c\xfa\x8f\x6f\x22\xaf\x8b\x60\x9f\xaf"
     },
     {
       "\x61\x62\x63\x64\x65\x66", 6,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xaf\xa7\x0c\x68\xdf\x7e\xaa\x27", 8,
       1024,
       16,
       "\xe5\x38\xf4\x39\x62\x27\xcd\xcc\x91\x37\x7f\x1b\xdc\x58\x64\x27"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67", 7,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x40\x57\xb2\x9d\x5f\xbb\x11\x4f", 8,
       1024,
       16,
       "\xad\xa2\x33\xd9\xdd\xe0\xfb\x94\x8e\xcc\xec\xcc\xb3\xa8\x3a\x9e"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68", 8,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x38\xf5\x65\xc5\x0f\x8c\x19\x61", 8,
       1024,
       16,
       "\xa0\xb0\x3e\x29\x76\xe6\x8f\xa0\xd8\x34\x8f\xa4\x2d\xfd\x65\xee"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69", 9,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xc3\xb7\x99\xcc\xda\x2d\x05\x7b", 8,
       1024,
       16,
       "\x27\x21\xc8\x99\x5f\xcf\x20\xeb\xf2\xd9\xff\x6a\x69\xff\xad\xe8"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f", 15,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x7d\xd8\x68\x8a\x1c\xc5\x47\x22", 8,
       1024,
       16,
       "\x0f\x96\x7a\x12\x23\x54\xf6\x92\x61\x67\x07\xb4\x68\x17\xb8\xaa"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70", 16,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x8a\x95\xd4\x88\x0b\xb8\xe9\x9d", 8,
       1024,
       16,
       "\xcc\xe4\xc8\x82\x53\x32\xf1\x93\x5a\x00\xd4\x7f\xd4\x46\xfa\x07"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
       "\x71", 17,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xb5\x22\x48\xa6\xc4\xad\x74\x67", 8,
       1024,
       16,
       "\x0c\xe3\xe0\xee\x3d\x8f\x35\xd2\x35\x14\x14\x29\x0c\xf1\xe3\x34"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
       "\x71\x72", 18,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xac\x9f\x04\x63\x83\x0e\x3c\x95", 8,
       1024,
       16,
       "\x49\x0a\x04\x68\xa8\x2a\x43\x6f\xb9\x73\x94\xb4\x85\x9a\xaa\x0e"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
       "\x71\x72\x73", 19,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x03\x6f\x60\x30\x3a\x19\x61\x0d", 8,
       1024,
       16,
       "\x15\xe5\x9b\xbf\x1c\xf0\xbe\x74\x95\x1a\xb2\xc4\xda\x09\xcd\x99"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
       "\x71\x72\x73\x74", 20,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x51\x40\xa5\x57\xf5\x28\xfd\x03", 8,
       1024,
       16,
       "\xa6\xf2\x7e\x6b\x30\x4d\x8d\x67\xd4\xa2\x7f\xa2\x57\x27\xab\x96"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
       "\x71\x72\x73\x74\x75", 21,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x4c\xf1\x10\x11\x04\x70\xd3\x6e", 8,
       1024,
       16,
       "\x2c\x50\x79\x8d\x83\x23\xac\xd6\x22\x29\x37\xaf\x15\x0d\xdd\x8f"
     },
     {
       "\x57\x69\x74\x68\x5f\x75\x74\x66\x38\x5f\x75\x6d\x6c\x61\x75\x74"
       "\x73\x3a\xc3\xa4\xc3\xbc\xc3\x96\xc3\x9f", 26,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xfe\x3a\x25\xcb\x78\xef\xe1\x21", 8,
       1024,
       16,
       "\x2a\xb0\x53\x08\xf3\x2f\xd4\x6e\xeb\x01\x49\x5d\x87\xf6\x27\xf6"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x04\x97\xd0\x02\x6a\x44\x2d\xde", 8,
       1024,
       16,
       "\x57\xf5\x70\x41\xa0\x9b\x8c\x09\xca\x74\xa9\x22\xa5\x82\x2d\x17"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xdd\xf3\x31\x7c\xce\xf4\x81\x26", 8,
       10240,
       16,
       "\xc3\xdd\x01\x6d\xaf\xf6\x58\xc8\xd7\x79\xb4\x40\x00\xb5\xe8\x0b"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x95\xd6\x72\x4e\xfb\xe1\xc3\x1a", 8,
       102400,
       16,
       "\xf2\x3f\x36\x7f\xb4\x6a\xd0\x3a\x31\x9e\x65\x11\x8e\x2b\x99\x9b"
     },
     {
       "\x61", 1,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x6d\x69\x15\x18\xe4\x13\x42\x82", 8,
       1024,
       24,
       "\x28\x0c\x7e\xf2\x31\xf6\x1c\x6b\x5c\xef\x6a\xd5\x22\x64\x97\x91"
       "\xe3\x5e\x37\xfd\x50\xe2\xfc\x6c"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67", 7,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x9b\x76\x5e\x81\xde\x13\xdf\x15", 8,
       1024,
       24,
       "\x91\x1b\xa1\xc1\x7b\x4f\xc3\xb1\x80\x61\x26\x08\xbe\x53\xe6\x50"
       "\x40\x6f\x28\xed\xc6\xe6\x67\x55"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69", 9,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x7a\xac\xcc\x6e\x15\x56\xbd\xa1", 8,
       1024,
       24,
       "\xfa\x7e\x20\x07\xb6\x47\xb0\x09\x46\xb8\x38\xfb\xa1\xaf\xf7\x75"
       "\x2a\xfa\x77\x14\x06\x54\xcb\x34"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69", 9,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x1c\x68\xf8\xfb\x98\xf7\x8c\x39", 8,
       1024,
       24,
       "\xcb\x1e\x86\xf5\xe0\xe4\xfb\xbf\x71\x34\x99\x24\xf4\x39\x8c\xc2"
       "\x8e\x25\x1c\x4c\x96\x47\x22\xe8"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x10\xa9\x4e\xc1\xa5\xec\x17\x52", 8,
       1024,
       24,
       "\x0f\x83\xa2\x77\x92\xbb\xe4\x58\x68\xc5\xf2\x14\x6e\x6e\x2e\x6b"
       "\x98\x17\x70\x92\x07\x44\xe0\x51"
     },
     {
       "\x61", 1,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xef\x8f\x37\x61\x8f\xab\xae\x4f", 8,
       1024,
       32,
       "\x6d\x65\xae\x86\x23\x91\x39\x98\xec\x1c\x23\x44\xb6\x0d\xad\x32"
       "\x54\x46\xc7\x23\x26\xbb\xdf\x4b\x54\x6e\xd4\xc2\xfa\xc6\x17\x17"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67", 7,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xaa\xfb\xd9\x06\x7d\x7c\x40\xaf", 8,
       1024,
       32,
       "\x7d\x10\x54\x13\x3c\x43\x7a\xb3\x54\x1f\x38\xd4\x8f\x70\x0a\x09"
       "\xe2\xfa\xab\x97\x9a\x70\x16\xef\x66\x68\xca\x34\x2e\xce\xfa\x1f"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69", 9,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x58\x03\x4f\x56\x8b\x97\xd4\x98", 8,
       1024,
       32,
       "\xf7\x40\xb1\x25\x86\x0d\x35\x8f\x9f\x91\x2d\xce\x04\xee\x5a\x04"
       "\x9d\xbd\x44\x23\x4c\xa6\xbb\xab\xb0\xd0\x56\x82\xa9\xda\x47\x16"
     },
     {
       "\x61\x62\x63\x64\x65\x66\x67\x68\x69", 9,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\x5d\x41\x3d\xa3\xa7\xfc\x5d\x0c", 8,
       1024,
       32,
       "\x4c\x7a\x86\xed\x81\x8a\x94\x99\x7d\x4a\xc4\xf7\x1c\xf8\x08\xdb"
       "\x09\x35\xd9\xa3\x2d\x22\xde\x32\x2d\x74\x38\xe5\xc8\xf2\x50\x6e"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA1,
       "\xca\xa7\xdc\x59\xce\x31\xe7\x49", 8,
       1024,
       32,
       "\x67\xe9\xd6\x29\x49\x1c\xb6\xa0\x85\xe8\xf9\x8b\x85\x47\x3a\x7e"
       "\xa7\xee\x89\x52\x6f\x19\x00\x53\x93\x07\x0a\x8b\xb9\xa8\x86\x94"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_SIMPLE_S2K, GCRY_MD_SHA256,
       NULL, 0,
       0,
       16,
       "\x88\x36\x78\x6b\xd9\x5a\x62\xff\x47\xd3\xfb\x79\xc9\x08\x70\x56"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_SALTED_S2K, GCRY_MD_SHA256,
       "\x05\x8b\xfe\x31\xaa\xf3\x29\x11", 8,
       0,
       16,
       "\xb2\x42\xfe\x5e\x09\x02\xd9\x62\xb9\x35\xf3\xa8\x43\x80\x9f\xb1"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
       "\xd3\x4a\xea\xc9\x97\x1b\xcc\x83", 8,
       1024,
       16,
       "\x35\x37\x99\x62\x07\x26\x68\x23\x05\x47\xb2\xa0\x0b\x2b\x2b\x8d"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
       "\x5e\x71\xbd\x00\x5f\x96\xc4\x23", 8,
       10240,
       16,
       "\xa1\x6a\xee\xba\xde\x73\x25\x25\xd1\xab\xa0\xc5\x7e\xc6\x39\xa7"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA384,
       "\xc3\x08\xeb\x17\x62\x08\x89\xef", 8,
       1024,
       16,
       "\x9b\x7f\x0c\x81\x6f\x71\x59\x9b\xd5\xf6\xbf\x3a\x86\x20\x16\x33"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA512,
       "\xe6\x7d\x13\x6b\x39\xe3\x44\x05", 8,
       1024,
       16,
       "\xc8\xcd\x4b\xa4\xf3\xf1\xd5\xb0\x59\x06\xf0\xbb\x89\x34\x6a\xad"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA512,
       "\xed\x7d\x30\x47\xe4\xc3\xf8\xb6", 8,
       1024,
       32,
       "\x89\x7a\xef\x70\x97\xe7\x10\xdb\x75\xcc\x20\x22\xab\x7b\xf3\x05"
       "\x4b\xb6\x2e\x17\x11\x9f\xd6\xeb\xbf\xdf\x4d\x70\x59\xf0\xf9\xe5"
     },
     {
       "\x4c\x6f\x6e\x67\x5f\x73\x65\x6e\x74\x65\x6e\x63\x65\x5f\x75\x73"
       "\x65\x64\x5f\x61\x73\x5f\x70\x61\x73\x73\x70\x68\x72\x61\x73\x65", 32,
       GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA512,
       "\xbb\x1a\x45\x30\x68\x62\x6d\x63", 8,
       1024,
       24,
       "\xde\x5c\xb8\xd5\x75\xf6\xad\x69\x5b\xc9\xf6\x2f\xba\xeb\xfb\x36"
       "\x34\xf2\xb8\xee\x3b\x37\x21\xb7"
     }
   };
   int tvidx;
   gpg_error_t err;
   unsigned char outbuf[32];
   int i;
 
   for (tvidx=0; tvidx < DIM(tv); tvidx++)
     {
       if (tv[tvidx].disabled)
         continue;
       /* MD5 isn't supported in fips mode */
       if (gcry_fips_mode_active()
           && tv[tvidx].hashalgo == GCRY_MD_MD5)
         continue;
       if (verbose)
         fprintf (stderr, "checking S2K test vector %d\n", tvidx);
       assert (tv[tvidx].dklen <= sizeof outbuf);
       err = gcry_kdf_derive (tv[tvidx].p, tv[tvidx].plen,
                              tv[tvidx].algo, tv[tvidx].hashalgo,
                              tv[tvidx].salt, tv[tvidx].saltlen,
                              tv[tvidx].c, tv[tvidx].dklen, outbuf);
       if (err)
         fail ("s2k test %d failed: %s\n", tvidx, gpg_strerror (err));
       else if (memcmp (outbuf, tv[tvidx].dk, tv[tvidx].dklen))
         {
           fail ("s2k test %d failed: mismatch\n", tvidx);
           fputs ("got:", stderr);
           for (i=0; i < tv[tvidx].dklen; i++)
             fprintf (stderr, " %02x", outbuf[i]);
           putc ('\n', stderr);
         }
     }
 }
 
 
 static void
 check_pbkdf2 (void)
 {
   /* Test vectors are from RFC-6070.  */
   static struct {
     const char *p;   /* Passphrase.  */
     size_t plen;     /* Length of P. */
     const char *salt;
     size_t saltlen;
     int hashalgo;
     unsigned long c; /* Iterations.  */
     int dklen;       /* Requested key length.  */
     const char *dk;  /* Derived key.  */
     int disabled;
   } tv[] = {
     {
       "password", 8,
       "salt", 4,
       GCRY_MD_SHA1,
       1,
       20,
       "\x0c\x60\xc8\x0f\x96\x1f\x0e\x71\xf3\xa9"
       "\xb5\x24\xaf\x60\x12\x06\x2f\xe0\x37\xa6"
     },
     {
       "password", 8,
       "salt", 4,
       GCRY_MD_SHA1,
       2,
       20,
       "\xea\x6c\x01\x4d\xc7\x2d\x6f\x8c\xcd\x1e"
       "\xd9\x2a\xce\x1d\x41\xf0\xd8\xde\x89\x57"
     },
     {
       "password", 8,
       "salt", 4,
       GCRY_MD_SHA1,
       4096,
       20,
       "\x4b\x00\x79\x01\xb7\x65\x48\x9a\xbe\xad"
       "\x49\xd9\x26\xf7\x21\xd0\x65\xa4\x29\xc1"
     },
     {
       "password", 8,
       "salt", 4,
       GCRY_MD_SHA1,
       16777216,
       20,
       "\xee\xfe\x3d\x61\xcd\x4d\xa4\xe4\xe9\x94"
       "\x5b\x3d\x6b\xa2\x15\x8c\x26\x34\xe9\x84",
       1 /* This test takes too long.  */
     },
     {
       "passwordPASSWORDpassword", 24,
       "saltSALTsaltSALTsaltSALTsaltSALTsalt", 36,
       GCRY_MD_SHA1,
       4096,
       25,
       "\x3d\x2e\xec\x4f\xe4\x1c\x84\x9b\x80\xc8"
       "\xd8\x36\x62\xc0\xe4\x4a\x8b\x29\x1a\x96"
       "\x4c\xf2\xf0\x70\x38"
     },
     {
       "pass\0word", 9,
       "sa\0lt", 5,
       GCRY_MD_SHA1,
       4096,
       16,
       "\x56\xfa\x6a\xa7\x55\x48\x09\x9d\xcc\x37"
       "\xd7\xf0\x34\x25\xe0\xc3"
     },
     { /* empty password test, not in RFC-6070 */
       "", 0,
       "salt", 4,
       GCRY_MD_SHA1,
       2,
       20,
       "\x13\x3a\x4c\xe8\x37\xb4\xd2\x52\x1e\xe2"
       "\xbf\x03\xe1\x1c\x71\xca\x79\x4e\x07\x97"
     },
     {
       "password", 8,
       "salt", 4,
       GCRY_MD_GOSTR3411_CP,
       1,
       32,
       "\x73\x14\xe7\xc0\x4f\xb2\xe6\x62\xc5\x43\x67\x42\x53\xf6\x8b\xd0"
       "\xb7\x34\x45\xd0\x7f\x24\x1b\xed\x87\x28\x82\xda\x21\x66\x2d\x58"
     },
     {
       "password", 8,
       "salt", 4,
       GCRY_MD_GOSTR3411_CP,
       2,
       32,
       "\x99\x0d\xfa\x2b\xd9\x65\x63\x9b\xa4\x8b\x07\xb7\x92\x77\x5d\xf7"
       "\x9f\x2d\xb3\x4f\xef\x25\xf2\x74\x37\x88\x72\xfe\xd7\xed\x1b\xb3"
     },
     {
       "password", 8,
       "salt", 4,
       GCRY_MD_GOSTR3411_CP,
       4096,
       32,
       "\x1f\x18\x29\xa9\x4b\xdf\xf5\xbe\x10\xd0\xae\xb3\x6a\xf4\x98\xe7"
       "\xa9\x74\x67\xf3\xb3\x11\x16\xa5\xa7\xc1\xaf\xff\x9d\xea\xda\xfe"
     },
     /* { -- takes too long (4-5 min) to calculate
       "password", 8,
       "salt", 4,
       GCRY_MD_GOSTR3411_CP,
       16777216,
       32,
       "\xa5\x7a\xe5\xa6\x08\x83\x96\xd1\x20\x85\x0c\x5c\x09\xde\x0a\x52"
       "\x51\x00\x93\x8a\x59\xb1\xb5\xc3\xf7\x81\x09\x10\xd0\x5f\xcd\x97"
     }, */
     {
       "passwordPASSWORDpassword", 24,
       "saltSALTsaltSALTsaltSALTsaltSALTsalt", 36,
       GCRY_MD_GOSTR3411_CP,
       4096,
       40,
       "\x78\x83\x58\xc6\x9c\xb2\xdb\xe2\x51\xa7\xbb\x17\xd5\xf4\x24\x1f"
       "\x26\x5a\x79\x2a\x35\xbe\xcd\xe8\xd5\x6f\x32\x6b\x49\xc8\x50\x47"
       "\xb7\x63\x8a\xcb\x47\x64\xb1\xfd"
     },
     {
       "pass\0word", 9,
       "sa\0lt", 5,
       GCRY_MD_GOSTR3411_CP,
       4096,
       20,
       "\x43\xe0\x6c\x55\x90\xb0\x8c\x02\x25\x24"
       "\x23\x73\x12\x7e\xdf\x9c\x8e\x9c\x32\x91"
     },
     {
       "password", 8,
       "salt", 4,
       GCRY_MD_STRIBOG512,
       1,
       64,
       "\x64\x77\x0a\xf7\xf7\x48\xc3\xb1\xc9\xac\x83\x1d\xbc\xfd\x85\xc2"
       "\x61\x11\xb3\x0a\x8a\x65\x7d\xdc\x30\x56\xb8\x0c\xa7\x3e\x04\x0d"
       "\x28\x54\xfd\x36\x81\x1f\x6d\x82\x5c\xc4\xab\x66\xec\x0a\x68\xa4"
       "\x90\xa9\xe5\xcf\x51\x56\xb3\xa2\xb7\xee\xcd\xdb\xf9\xa1\x6b\x47"
     },
     {
       "password", 8,
       "salt", 4,
       GCRY_MD_STRIBOG512,
       2,
       64,
       "\x5a\x58\x5b\xaf\xdf\xbb\x6e\x88\x30\xd6\xd6\x8a\xa3\xb4\x3a\xc0"
       "\x0d\x2e\x4a\xeb\xce\x01\xc9\xb3\x1c\x2c\xae\xd5\x6f\x02\x36\xd4"
       "\xd3\x4b\x2b\x8f\xbd\x2c\x4e\x89\xd5\x4d\x46\xf5\x0e\x47\xd4\x5b"
       "\xba\xc3\x01\x57\x17\x43\x11\x9e\x8d\x3c\x42\xba\x66\xd3\x48\xde"
     },
     {
       "password", 8,
       "salt", 4,
       GCRY_MD_STRIBOG512,
       4096,
       64,
       "\xe5\x2d\xeb\x9a\x2d\x2a\xaf\xf4\xe2\xac\x9d\x47\xa4\x1f\x34\xc2"
       "\x03\x76\x59\x1c\x67\x80\x7f\x04\x77\xe3\x25\x49\xdc\x34\x1b\xc7"
       "\x86\x7c\x09\x84\x1b\x6d\x58\xe2\x9d\x03\x47\xc9\x96\x30\x1d\x55"
       "\xdf\x0d\x34\xe4\x7c\xf6\x8f\x4e\x3c\x2c\xda\xf1\xd9\xab\x86\xc3"
     },
     /* { -- takes toooo long
       "password", 8,
       "salt", 4,
       GCRY_MD_STRIBOG512,
       16777216,
       64,
       "\x49\xe4\x84\x3b\xba\x76\xe3\x00\xaf\xe2\x4c\x4d\x23\xdc\x73\x92"
       "\xde\xf1\x2f\x2c\x0e\x24\x41\x72\x36\x7c\xd7\x0a\x89\x82\xac\x36"
       "\x1a\xdb\x60\x1c\x7e\x2a\x31\x4e\x8c\xb7\xb1\xe9\xdf\x84\x0e\x36"
       "\xab\x56\x15\xbe\x5d\x74\x2b\x6c\xf2\x03\xfb\x55\xfd\xc4\x80\x71"
     }, */
     {
       "passwordPASSWORDpassword", 24,
       "saltSALTsaltSALTsaltSALTsaltSALTsalt", 36,
       GCRY_MD_STRIBOG512,
       4096,
       100,
       "\xb2\xd8\xf1\x24\x5f\xc4\xd2\x92\x74\x80\x20\x57\xe4\xb5\x4e\x0a"
       "\x07\x53\xaa\x22\xfc\x53\x76\x0b\x30\x1c\xf0\x08\x67\x9e\x58\xfe"
       "\x4b\xee\x9a\xdd\xca\xe9\x9b\xa2\xb0\xb2\x0f\x43\x1a\x9c\x5e\x50"
       "\xf3\x95\xc8\x93\x87\xd0\x94\x5a\xed\xec\xa6\xeb\x40\x15\xdf\xc2"
       "\xbd\x24\x21\xee\x9b\xb7\x11\x83\xba\x88\x2c\xee\xbf\xef\x25\x9f"
       "\x33\xf9\xe2\x7d\xc6\x17\x8c\xb8\x9d\xc3\x74\x28\xcf\x9c\xc5\x2a"
       "\x2b\xaa\x2d\x3a"
     },
     {
       "pass\0word", 9,
       "sa\0lt", 5,
       GCRY_MD_STRIBOG512,
       4096,
       64,
       "\x50\xdf\x06\x28\x85\xb6\x98\x01\xa3\xc1\x02\x48\xeb\x0a\x27\xab"
       "\x6e\x52\x2f\xfe\xb2\x0c\x99\x1c\x66\x0f\x00\x14\x75\xd7\x3a\x4e"
       "\x16\x7f\x78\x2c\x18\xe9\x7e\x92\x97\x6d\x9c\x1d\x97\x08\x31\xea"
       "\x78\xcc\xb8\x79\xf6\x70\x68\xcd\xac\x19\x10\x74\x08\x44\xe8\x30"
     }
   };
   int tvidx;
   gpg_error_t err;
   unsigned char outbuf[100];
   int i;
 
   for (tvidx=0; tvidx < DIM(tv); tvidx++)
     {
       if (tv[tvidx].disabled)
         continue;
       if (verbose)
         fprintf (stderr, "checking PBKDF2 test vector %d algo %d\n", tvidx,
                  tv[tvidx].hashalgo);
       assert (tv[tvidx].dklen <= sizeof outbuf);
       err = gcry_kdf_derive (tv[tvidx].p, tv[tvidx].plen,
                              GCRY_KDF_PBKDF2, tv[tvidx].hashalgo,
                              tv[tvidx].salt, tv[tvidx].saltlen,
                              tv[tvidx].c, tv[tvidx].dklen, outbuf);
       if (err)
         fail ("pbkdf2 test %d failed: %s\n", tvidx, gpg_strerror (err));
       else if (memcmp (outbuf, tv[tvidx].dk, tv[tvidx].dklen))
         {
           fail ("pbkdf2 test %d failed: mismatch\n", tvidx);
           fputs ("got:", stderr);
           for (i=0; i < tv[tvidx].dklen; i++)
             fprintf (stderr, " %02x", outbuf[i]);
           putc ('\n', stderr);
         }
     }
 }
 
 
 static void
 check_scrypt (void)
 {
   /* Test vectors are from draft-josefsson-scrypt-kdf-01.  */
   static struct {
     const char *p;        /* Passphrase.  */
     size_t plen;          /* Length of P. */
     const char *salt;
     size_t saltlen;
     int parm_n;           /* CPU/memory cost.  */
     int parm_r;           /* blocksize */
     unsigned long parm_p; /* parallelization. */
     int dklen;            /* Requested key length.  */
     const char *dk;       /* Derived key.  */
     int disabled;
   } tv[] = {
     {
       "", 0,
       "", 0,
       16,
       1,
       1,
       64,
       "\x77\xd6\x57\x62\x38\x65\x7b\x20\x3b\x19\xca\x42\xc1\x8a\x04\x97"
       "\xf1\x6b\x48\x44\xe3\x07\x4a\xe8\xdf\xdf\xfa\x3f\xed\xe2\x14\x42"
       "\xfc\xd0\x06\x9d\xed\x09\x48\xf8\x32\x6a\x75\x3a\x0f\xc8\x1f\x17"
       "\xe8\xd3\xe0\xfb\x2e\x0d\x36\x28\xcf\x35\xe2\x0c\x38\xd1\x89\x06"
     },
     {
       "password", 8,
       "NaCl", 4,
       1024,
       8,
       16,
       64,
       "\xfd\xba\xbe\x1c\x9d\x34\x72\x00\x78\x56\xe7\x19\x0d\x01\xe9\xfe"
       "\x7c\x6a\xd7\xcb\xc8\x23\x78\x30\xe7\x73\x76\x63\x4b\x37\x31\x62"
       "\x2e\xaf\x30\xd9\x2e\x22\xa3\x88\x6f\xf1\x09\x27\x9d\x98\x30\xda"
       "\xc7\x27\xaf\xb9\x4a\x83\xee\x6d\x83\x60\xcb\xdf\xa2\xcc\x06\x40"
     },
     {
       "pleaseletmein", 13,
       "SodiumChloride", 14,
       16384,
       8,
       1,
       64,
       "\x70\x23\xbd\xcb\x3a\xfd\x73\x48\x46\x1c\x06\xcd\x81\xfd\x38\xeb"
       "\xfd\xa8\xfb\xba\x90\x4f\x8e\x3e\xa9\xb5\x43\xf6\x54\x5d\xa1\xf2"
       "\xd5\x43\x29\x55\x61\x3f\x0f\xcf\x62\xd4\x97\x05\x24\x2a\x9a\xf9"
       "\xe6\x1e\x85\xdc\x0d\x65\x1e\x40\xdf\xcf\x01\x7b\x45\x57\x58\x87"
     },
     {
       "pleaseletmein", 13,
       "SodiumChloride", 14,
       1048576,
       8,
       1,
       64,
       "\x21\x01\xcb\x9b\x6a\x51\x1a\xae\xad\xdb\xbe\x09\xcf\x70\xf8\x81"
       "\xec\x56\x8d\x57\x4a\x2f\xfd\x4d\xab\xe5\xee\x98\x20\xad\xaa\x47"
       "\x8e\x56\xfd\x8f\x4b\xa5\xd0\x9f\xfa\x1c\x6d\x92\x7c\x40\xf4\xc3"
       "\x37\x30\x40\x49\xe8\xa9\x52\xfb\xcb\xf4\x5c\x6f\xa7\x7a\x41\xa4",
       2 /* Only in debug mode.  */
     }
   };
   int tvidx;
   gpg_error_t err;
   unsigned char outbuf[64];
   int i;
 
   for (tvidx=0; tvidx < DIM(tv); tvidx++)
     {
       if (tv[tvidx].disabled && !(tv[tvidx].disabled == 2 && debug))
         continue;
       if (verbose)
         fprintf (stderr, "checking SCRYPT test vector %d\n", tvidx);
       assert (tv[tvidx].dklen <= sizeof outbuf);
       err = gcry_kdf_derive (tv[tvidx].p, tv[tvidx].plen,
                              tv[tvidx].parm_r == 1 ? 41 : GCRY_KDF_SCRYPT,
                              tv[tvidx].parm_n,
                              tv[tvidx].salt, tv[tvidx].saltlen,
                              tv[tvidx].parm_p, tv[tvidx].dklen, outbuf);
       if (err)
         fail ("scrypt test %d failed: %s\n", tvidx, gpg_strerror (err));
       else if (memcmp (outbuf, tv[tvidx].dk, tv[tvidx].dklen))
         {
           fail ("scrypt test %d failed: mismatch\n", tvidx);
           fputs ("got:", stderr);
           for (i=0; i < tv[tvidx].dklen; i++)
             fprintf (stderr, " %02x", outbuf[i]);
           putc ('\n', stderr);
         }
     }
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   unsigned long s2kcount = 0;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           fputs ("usage: t-kdf [options]"
                  "Options:\n"
                  " --verbose    print timinigs etc.\n"
                  " --debug      flyswatter\n"
                  " --s2k        print the time needed for S2K\n",
                  stdout);
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose += 2;
           debug++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--s2k"))
         {
           s2kcount = 1;
           argc--; argv++;
         }
       else if (!strncmp (*argv, "--", 2))
         die ("unknown option '%s'\n", *argv);
     }
 
   if (s2kcount)
     {
       if (argc != 1)
         die ("usage: t-kdf --s2k S2KCOUNT\n");
       s2kcount = strtoul (*argv, NULL, 10);
       if (!s2kcount)
         die ("t-kdf: S2KCOUNT must be positive\n");
     }
 
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
 
   if (s2kcount)
     bench_s2k (s2kcount);
   else
     {
       check_openpgp ();
       check_pbkdf2 ();
       check_scrypt ();
     }
 
   return error_count ? 1 : 0;
 }
diff --git a/tests/t-lock.c b/tests/t-lock.c
index 7e5732e0..9f30ec56 100644
--- a/tests/t-lock.c
+++ b/tests/t-lock.c
@@ -1,458 +1,458 @@
 /* t-lock.c - Check the lock functions
  * Copyright (C) 2014 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
  * as published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #if HAVE_CONFIG_H
 # include <config.h>
 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
 #include <unistd.h>
 #if HAVE_PTHREAD
 # include <pthread.h>
 #endif
 
 #define PGM "t-lock"
 
 #include "t-common.h"
 #include "../src/gcrypt-testapi.h"
 
 /* Mingw requires us to include windows.h after winsock2.h which is
    included by gcrypt.h.  */
 #ifdef _WIN32
 # include <windows.h>
 #endif
 
 #ifdef _WIN32
 # define THREAD_RET_TYPE  DWORD WINAPI
 # define THREAD_RET_VALUE 0
 #else
 # define THREAD_RET_TYPE  void *
 # define THREAD_RET_VALUE NULL
 #endif
 
 
 /* Number of threads to run.  */
 #define N_NONCE_THREADS 8
 /* Number of interations.  */
 #define N_NONCE_ITERATIONS 1000
 /* Requested nonce size.  */
 #define NONCE_SIZE  11
 
 
 /* This tests works by having a a couple of accountant threads which do
    random transactions between accounts and a revision threads which
    checks that the balance of all accounts is invariant.  The idea for
    this check is due to Bruno Haible.  */
 #define N_ACCOUNT 8
 #define ACCOUNT_VALUE 42
 static int account[N_ACCOUNT];
 
 /* Number of transactions done by each accountant.  */
 #define N_TRANSACTIONS 1000
 
 /* Number of accountants to run.  */
 #define N_ACCOUNTANTS 5
 
 /* Maximum transaction value.  A quite low value is used so that we
    would get an integer overflow.  */
 #define MAX_TRANSACTION_VALUE 50
 
 /* Flag to tell the revision thread to finish.  */
 static volatile int stop_revision_thread;
 
 
 struct thread_arg_s
 {
   int no;
 };
 
 
 
 
 /* Wrapper functions to access Libgcrypt's internal test lock.  */
 static void
 external_lock_test_init (int line)
 {
   gpg_error_t err;
 
   err = gcry_control (PRIV_CTL_EXTERNAL_LOCK_TEST, EXTERNAL_LOCK_TEST_INIT);
   if (err)
     fail ("init lock failed at %d: %s", line, gpg_strerror (err));
 }
 
 static void
 external_lock_test_lock (int line)
 {
   gpg_error_t err;
 
   err = gcry_control (PRIV_CTL_EXTERNAL_LOCK_TEST, EXTERNAL_LOCK_TEST_LOCK);
   if (err)
     fail ("taking lock failed at %d: %s", line, gpg_strerror (err));
 }
 
 static void
 external_lock_test_unlock (int line)
 {
   gpg_error_t err;
 
   err = gcry_control (PRIV_CTL_EXTERNAL_LOCK_TEST, EXTERNAL_LOCK_TEST_UNLOCK);
   if (err)
     fail ("releasing lock failed at %d: %s", line, gpg_strerror (err));
 
 }
 
 static void
 external_lock_test_destroy (int line)
 {
   gpg_error_t err;
 
   err = gcry_control (PRIV_CTL_EXTERNAL_LOCK_TEST, EXTERNAL_LOCK_TEST_DESTROY);
   if (err)
     fail ("destroying lock failed at %d: %s", line, gpg_strerror (err));
 }
 
 
 
 
 /* The nonce thread.  We simply request a couple of nonces and
    return.  */
 static THREAD_RET_TYPE
 nonce_thread (void *argarg)
 {
   struct thread_arg_s *arg = argarg;
   int i;
   char nonce[NONCE_SIZE];
 
   for (i = 0; i < N_NONCE_ITERATIONS; i++)
     {
       gcry_create_nonce (nonce, sizeof nonce);
       if (i && !(i%100))
         info ("thread %d created %d nonces so far", arg->no, i);
     }
 
   gcry_free (arg);
   return THREAD_RET_VALUE;
 }
 
 
 /* To check our locking function we run several threads all accessing
    the nonce functions.  If this function returns we know that there
    are no obvious deadlocks or failed lock initialization.  */
 static void
 check_nonce_lock (void)
 {
   struct thread_arg_s *arg;
 #ifdef _WIN32
   HANDLE threads[N_NONCE_THREADS];
   int i;
   int rc;
 
   for (i=0; i < N_NONCE_THREADS; i++)
     {
       arg = gcry_xmalloc (sizeof *arg);
       arg->no = i;
       threads[i] = CreateThread (NULL, 0, nonce_thread, arg, 0, NULL);
       if (!threads[i])
         die ("error creating nonce thread %d: rc=%d",
              i, (int)GetLastError ());
     }
 
   for (i=0; i < N_NONCE_THREADS; i++)
     {
       rc = WaitForSingleObject (threads[i], INFINITE);
       if (rc == WAIT_OBJECT_0)
         info ("nonce thread %d has terminated", i);
       else
         fail ("waiting for nonce thread %d failed: %d",
               i, (int)GetLastError ());
       CloseHandle (threads[i]);
     }
 
 #elif HAVE_PTHREAD
   pthread_t threads[N_NONCE_THREADS];
   int rc, i;
 
   for (i=0; i < N_NONCE_THREADS; i++)
     {
       arg = gcry_xmalloc (sizeof *arg);
       arg->no = i;
       pthread_create (&threads[i], NULL, nonce_thread, arg);
     }
 
   for (i=0; i < N_NONCE_THREADS; i++)
     {
       rc = pthread_join (threads[i], NULL);
       if (rc)
         fail ("pthread_join failed for nonce thread %d: %s",
               i, strerror (errno));
       else
         info ("nonce thread %d has terminated", i);
     }
 
 #endif /*!_WIN32*/
 }
 
 
 /* Initialize all accounts.  */
 static void
 init_accounts (void)
 {
   int i;
 
   for (i=0; i < N_ACCOUNT; i++)
     account[i] = ACCOUNT_VALUE;
 }
 
 
 /* Check that the sum of all accounts matches the initial sum.  */
 static void
 check_accounts (void)
 {
   int i, sum;
 
   sum = 0;
   for (i = 0; i < N_ACCOUNT; i++)
     sum += account[i];
   if (sum != N_ACCOUNT * ACCOUNT_VALUE)
     die ("accounts out of balance");
 }
 
 
 static void
 print_accounts (void)
 {
   int i;
 
   for (i=0; i < N_ACCOUNT; i++)
     printf ("account %d: %6d\n", i, account[i]);
 }
 
 
 /* Get a a random integer value in the range 0 to HIGH.  */
 static unsigned int
 get_rand (int high)
 {
   return (unsigned int)(1+(int)((double)(high+1)*rand ()/(RAND_MAX+1.0))) - 1;
 }
 
 
 /* Pick a random account.  Note that this function is not
    thread-safe. */
 static int
 pick_account (void)
 {
   return get_rand (N_ACCOUNT - 1);
 }
 
 
 /* Pick a random value for a transaction.  This is not thread-safe.  */
 static int
 pick_value (void)
 {
   return get_rand (MAX_TRANSACTION_VALUE);
 }
 
 
 /* This is the revision department.  */
 static THREAD_RET_TYPE
 revision_thread (void *arg)
 {
   (void)arg;
 
   while (!stop_revision_thread)
     {
       external_lock_test_lock (__LINE__);
       check_accounts ();
       external_lock_test_unlock (__LINE__);
     }
   return THREAD_RET_VALUE;
 }
 
 
 /* This is one of our accountants.  */
 static THREAD_RET_TYPE
 accountant_thread (void *arg)
 {
   int i;
   int acc1, acc2;
   int value;
 
   (void)arg;
 
   for (i = 0; i < N_TRANSACTIONS; i++)
     {
       external_lock_test_lock (__LINE__);
       acc1 = pick_account ();
       acc2 = pick_account ();
       value = pick_value ();
       account[acc1] += value;
       account[acc2] -= value;
       external_lock_test_unlock (__LINE__);
     }
   return THREAD_RET_VALUE;
 }
 
 
 static void
 run_test (void)
 {
 #ifdef _WIN32
   HANDLE rthread;
   HANDLE athreads[N_ACCOUNTANTS];
   int i;
   int rc;
 
   external_lock_test_init (__LINE__);
   stop_revision_thread = 0;
   rthread = CreateThread (NULL, 0, revision_thread, NULL, 0, NULL);
   if (!rthread)
     die ("error creating revision thread: rc=%d", (int)GetLastError ());
 
   for (i=0; i < N_ACCOUNTANTS; i++)
     {
       athreads[i] = CreateThread (NULL, 0, accountant_thread, NULL, 0, NULL);
       if (!athreads[i])
         die ("error creating accountant thread %d: rc=%d",
              i, (int)GetLastError ());
     }
 
   for (i=0; i < N_ACCOUNTANTS; i++)
     {
       rc = WaitForSingleObject (athreads[i], INFINITE);
       if (rc == WAIT_OBJECT_0)
         info ("accountant thread %d has terminated", i);
       else
         fail ("waiting for accountant thread %d failed: %d",
               i, (int)GetLastError ());
       CloseHandle (athreads[i]);
     }
   stop_revision_thread = 1;
 
   rc = WaitForSingleObject (rthread, INFINITE);
   if (rc == WAIT_OBJECT_0)
     info ("revision thread has terminated");
   else
     fail ("waiting for revision thread failed: %d", (int)GetLastError ());
   CloseHandle (rthread);
 
 #else /*!_WIN32*/
   pthread_t rthread;
   pthread_t athreads[N_ACCOUNTANTS];
   int rc, i;
 
   external_lock_test_init (__LINE__);
   stop_revision_thread = 0;
   pthread_create (&rthread, NULL, revision_thread, NULL);
 
   for (i=0; i < N_ACCOUNTANTS; i++)
     pthread_create (&athreads[i], NULL, accountant_thread, NULL);
 
   for (i=0; i < N_ACCOUNTANTS; i++)
     {
       rc = pthread_join (athreads[i], NULL);
       if (rc)
         fail ("pthread_join failed for accountant thread %d: %s",
               i, strerror (errno));
       else
         info ("accountant thread %d has terminated", i);
     }
 
   stop_revision_thread = 1;
   rc = pthread_join (rthread, NULL);
   if (rc)
     fail ("pthread_join failed for the revision thread: %s", strerror (errno));
   else
     info ("revision thread has terminated");
 
 #endif /*!_WIN32*/
 
   external_lock_test_destroy (__LINE__);
 }
 
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
 
   if (argc)
     {
       argc--; argv++;
     }
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--help"))
         {
           puts (
 "usage: ./t-lock [options]\n"
 "\n"
 "Options:\n"
 "  --verbose      Show what is going on\n"
 "  --debug        Flyswatter\n"
 );
           exit (0);
         }
       if (!strcmp (*argv, "--verbose"))
         {
           verbose = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose = debug = 1;
           argc--; argv++;
         }
     }
 
   srand (time(NULL)*getpid());
 
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch");
   /* We are using non-public interfaces - check the exact version.  */
   if (strcmp (gcry_check_version (NULL), GCRYPT_VERSION))
     die ("exact version match failed");
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   check_nonce_lock ();
 
   init_accounts ();
   check_accounts ();
 
   run_test ();
   check_accounts ();
 
   /* Run a second time to check deinit code.  */
   run_test ();
   check_accounts ();
 
   if (verbose)
     print_accounts ();
 
   return error_count ? 1 : 0;
 }
diff --git a/tests/t-mpi-bit.c b/tests/t-mpi-bit.c
index 91116ca9..b66809f0 100644
--- a/tests/t-mpi-bit.c
+++ b/tests/t-mpi-bit.c
@@ -1,362 +1,362 @@
 /* t-mpi-bit.c  - Tests for bit level functions
  * Copyright (C) 2006 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  * MA 02110-1301, USA.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <stdarg.h>
 
 #define PGM "t-mpi-bit"
 #include "t-common.h"
 
 
 /* Allocate a bit string consisting of '0' and '1' from the MPI
    A. Return the LENGTH least significant bits. Caller needs to xfree
    the result. */
 static char *
 mpi2bitstr (gcry_mpi_t a, size_t length)
 {
   char *p, *buf;
 
   buf = p = xmalloc (length+1);
   while (length--)
     *p++ = gcry_mpi_test_bit (a, length) ? '1':'0';
   *p = 0;
 
   return buf;
 }
 
 /* Allocate a bit string consisting of '0' and '1' from the MPI A.  Do
    not return any leading zero bits. Caller needs to xfree the
    result. */
 static char *
 mpi2bitstr_nlz (gcry_mpi_t a)
 {
   char *p, *buf;
   size_t length = gcry_mpi_get_nbits (a);
 
   if (!length)
     {
       buf = p = xmalloc (2);
       *p++ = '0';
     }
   else
     {
       buf = p = xmalloc (length + 1);
       while (length-- > 1)
         *p++ = gcry_mpi_test_bit (a, length) ? '1':'0';
       *p++ = gcry_mpi_test_bit (a, 0) ? '1':'0';
     }
   *p = 0;
   return buf;
 }
 
 /* Shift a bit string to the right. */
 static void
 rshiftbitstring (char *string, size_t n)
 {
   size_t len = strlen (string);
 
   if (n > len)
     n = len;
 
   memmove (string+n, string, len-n);
   memset (string, '0', n);
 }
 
 /* Shift a bit string to the left. Caller needs to free the result. */
 static char *
 lshiftbitstring (const char *string, size_t n)
 {
   size_t len = strlen (string);
   char *result;
 
   if (len+n+1 < len)
     die ("internal overflow\n");
   /* Allocate enough space. */
   result = xmalloc (len+n+1);
   for (; *string == '0' && string[1]; string++, len--)
     ;
   memcpy (result, string, len);
   if (*string == '0' && !string[1])
     n = 0; /* Avoid extra nulls for an only 0 string.  */
   else
     memset (result+len, '0', n);
   result[len+n] = 0;
   return result;
 }
 
 
 /* This is to check a bug reported by bpgcrypt at itaparica.org on
    2006-07-31 against libgcrypt 1.2.2.  */
 static void
 one_bit_only (int highbit)
 {
   gcry_mpi_t a;
   char *result;
   int i;
 
   wherestr = "one_bit_only";
   info ("checking that set_%sbit does only set one bit\n", highbit?"high":"");
 
   a = gcry_mpi_new (0);
   gcry_mpi_randomize (a, 70, GCRY_WEAK_RANDOM);
   gcry_mpi_set_ui (a, 0);
 
   if (highbit)
     gcry_mpi_set_highbit (a, 42);
   else
     gcry_mpi_set_bit (a, 42);
   if (!gcry_mpi_test_bit (a, 42))
     fail ("failed to set a bit\n");
   gcry_mpi_clear_bit (a, 42);
   if (gcry_mpi_test_bit (a, 42))
     fail ("failed to clear a bit\n");
   result = mpi2bitstr (a, 70);
   assert (strlen (result) == 70);
   for (i=0; result[i]; i++)
     if ( result[i] != '0' )
       break;
   if (result[i])
     fail ("spurious bits detected\n");
   xfree (result);
   gcry_mpi_release (a);
 }
 
 /* Check that right shifting actually works for an amount larger than
    the number of bits per limb. */
 static void
 test_rshift (int pass)
 {
   gcry_mpi_t a, b;
   char *result, *result2;
   int i;
 
   wherestr = "test_rshift";
   info ("checking that rshift works as expected (pass %d)\n", pass);
 
   a = gcry_mpi_new (0);
   b = gcry_mpi_new (0);
   gcry_mpi_randomize (a, 70, GCRY_WEAK_RANDOM);
 
   for (i=0; i < 75; i++)
     {
       gcry_mpi_rshift (b, a, i);
 
       result = mpi2bitstr (b, 72);
       result2 = mpi2bitstr (a, 72);
       rshiftbitstring (result2, i);
       if (strcmp (result, result2))
         {
           info ("got =%s\n", result);
           info ("want=%s\n", result2);
           fail ("rshift by %d failed\n", i);
         }
       xfree (result);
       xfree (result2);
     }
 
   /* Again. This time using in-place operation. */
   gcry_mpi_randomize (a, 70, GCRY_WEAK_RANDOM);
 
   for (i=0; i < 75; i++)
     {
       gcry_mpi_release (b);
       b = gcry_mpi_copy (a);
       gcry_mpi_rshift (b, b, i);
 
       result = mpi2bitstr (b, 72);
       result2 = mpi2bitstr (a, 72);
       rshiftbitstring (result2, i);
       if (strcmp (result, result2))
         {
           info ("got =%s\n", result);
           info ("want=%s\n", result2);
           fail ("in-place rshift by %d failed\n", i);
         }
       xfree (result2);
       xfree (result);
     }
 
   gcry_mpi_release (b);
   gcry_mpi_release (a);
 }
 
 /* Check that left shifting works correctly.  */
 static void
 test_lshift (int pass)
 {
   static int size_list[] = {1, 31, 32, 63, 64, 65, 70, 0};
   int size_idx;
   gcry_mpi_t a, b;
   char *tmpstr, *result, *result2;
   int i;
 
   wherestr = "test_lshift";
   info ("checking that lshift works as expected (pass %d)\n", pass);
 
   for (size_idx=0; size_list[size_idx]; size_idx++)
     {
       a = gcry_mpi_new (0);
       b = gcry_mpi_new (0);
 
       /* gcry_mpi_randomize rounds up to full bytes, thus we need to
          use gcry_mpi_clear_highbit to fix that.  */
       gcry_mpi_randomize (a, size_list[size_idx], GCRY_WEAK_RANDOM);
       gcry_mpi_clear_highbit (a, size_list[size_idx]);
 
       for (i=0; i < 75; i++)
         {
           gcry_mpi_lshift (b, a, i);
 
           result = mpi2bitstr_nlz (b);
           tmpstr = mpi2bitstr_nlz (a);
           result2 = lshiftbitstring (tmpstr, i);
           xfree (tmpstr);
           if (strcmp (result, result2))
             {
               info ("got =%s\n", result);
               info ("want=%s\n", result2);
               fail ("lshift by %d failed\n", i);
             }
           xfree (result);
           xfree (result2);
         }
 
       /* Again. This time using in-place operation. */
       gcry_mpi_randomize (a, size_list[size_idx], GCRY_WEAK_RANDOM);
       gcry_mpi_clear_highbit (a, size_list[size_idx]);
 
       for (i=0; i < 75; i++)
         {
           gcry_mpi_release (b);
           b = gcry_mpi_copy (a);
           gcry_mpi_lshift (b, b, i);
 
           result = mpi2bitstr_nlz (b);
           tmpstr = mpi2bitstr_nlz (a);
           result2 = lshiftbitstring (tmpstr, i);
           xfree (tmpstr);
           if (strcmp (result, result2))
             {
               info ("got =%s\n", result);
               info ("want=%s\n", result2);
               fail ("in-place lshift by %d failed\n", i);
             }
           xfree (result2);
           xfree (result);
         }
 
       gcry_mpi_release (b);
       gcry_mpi_release (a);
     }
 }
 
 
 /* Bug fixed on 2014-05-09:
       a = gcry_mpi_new (1523);
       gcry_mpi_set_bit (a, 1536);
       didn't initialized all limbs in A.  */
 static void
 set_bit_with_resize (void)
 {
   gcry_mpi_t a;
   int i;
 
   wherestr = "set_bit_with_resize";
   info ("checking that set_bit initializes all limbs\n");
 
   a = gcry_mpi_new (1536);
   gcry_mpi_set_bit (a, 1536);
 
   if (!gcry_mpi_test_bit (a, 1536))
     fail ("failed to set a bit\n");
   for (i=0; i < 1536; i++)
     {
       if (gcry_mpi_test_bit (a, i))
         {
           fail ("spurious bit detected\n");
           break;
         }
     }
   if (gcry_mpi_test_bit (a, 1537))
     fail ("more bits set than expected\n");
   gcry_mpi_release (a);
 
   wherestr = "set_highbit_with_resize";
   info ("checking that set_highbit initializes all limbs\n");
 
   a = gcry_mpi_new (1536);
   gcry_mpi_set_highbit (a, 1536);
 
   if (!gcry_mpi_test_bit (a, 1536))
     fail ("failed to set a bit\n");
   for (i=0; i < 1536; i++)
     {
       if (gcry_mpi_test_bit (a, i))
         {
           fail ("spurious bit detected\n");
           break;
         }
     }
   if (gcry_mpi_test_bit (a, 1537))
     fail ("more bits set than expected\n");
   gcry_mpi_release (a);
 }
 
 
 int
 main (int argc, char **argv)
 {
   int i;
 
   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     verbose = 1;
   else if (argc > 1 && !strcmp (argv[1], "--debug"))
     verbose = debug = 1;
 
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
 
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   one_bit_only (0);
   one_bit_only (1);
   for (i=0; i < 5; i++)
     test_rshift (i); /* Run several times due to random initializations. */
 
   for (i=0; i < 5; i++)
     test_lshift (i); /* Run several times due to random initializations. */
 
   set_bit_with_resize ();
 
   info ("All tests completed. Errors: %d\n", error_count);
   return error_count ? 1 : 0;
 }
diff --git a/tests/t-mpi-point.c b/tests/t-mpi-point.c
index f2378bff..1ee1caf2 100644
--- a/tests/t-mpi-point.c
+++ b/tests/t-mpi-point.c
@@ -1,1347 +1,1347 @@
 /* t-mpi-point.c  - Tests for mpi point functions
  * Copyright (C) 2013 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <stdarg.h>
 
 #define PGM "t-mpi-point"
 #include "t-common.h"
 
 static struct
 {
   const char *desc;           /* Description of the curve.  */
   const char *p;              /* Order of the prime field.  */
   const char *a, *b;          /* The coefficients. */
   const char *n;              /* The order of the base point.  */
   const char *g_x, *g_y;      /* Base point.  */
   const char *h;              /* Cofactor.  */
 } test_curve[] =
   {
     {
       "NIST P-192",
       "0xfffffffffffffffffffffffffffffffeffffffffffffffff",
       "0xfffffffffffffffffffffffffffffffefffffffffffffffc",
       "0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1",
       "0xffffffffffffffffffffffff99def836146bc9b1b4d22831",
 
       "0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012",
       "0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811",
       "0x01"
     },
     {
       "NIST P-224",
       "0xffffffffffffffffffffffffffffffff000000000000000000000001",
       "0xfffffffffffffffffffffffffffffffefffffffffffffffffffffffe",
       "0xb4050a850c04b3abf54132565044b0b7d7bfd8ba270b39432355ffb4",
       "0xffffffffffffffffffffffffffff16a2e0b8f03e13dd29455c5c2a3d" ,
 
       "0xb70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21",
       "0xbd376388b5f723fb4c22dfe6cd4375a05a07476444d5819985007e34",
       "0x01"
     },
     {
       "NIST P-256",
       "0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff",
       "0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc",
       "0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
       "0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
 
       "0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
       "0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
       "0x01"
     },
     {
       "NIST P-384",
       "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
       "ffffffff0000000000000000ffffffff",
       "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
       "ffffffff0000000000000000fffffffc",
       "0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875a"
       "c656398d8a2ed19d2a85c8edd3ec2aef",
       "0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf"
       "581a0db248b0a77aecec196accc52973",
 
       "0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a38"
       "5502f25dbf55296c3a545e3872760ab7",
       "0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c0"
       "0a60b1ce1d7e819d7a431d7c90ea0e5f",
       "0x01"
     },
     {
       "NIST P-521",
       "0x01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
       "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
       "0x01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
       "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc",
       "0x051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef10"
       "9e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00",
       "0x1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
       "ffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409",
 
       "0xc6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3d"
       "baa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66",
       "0x11839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e6"
       "62c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650",
       "0x01"
     },
     {
       "Ed25519",
       "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED",
       "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEC",
       "0x52036CEE2B6FFE738CC740797779E89800700A4D4141D8AB75EB4DCA135978A3",
       "0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED",
       "0x216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A",
       "0x6666666666666666666666666666666666666666666666666666666666666658",
       "0x08"
     },
     { NULL, NULL, NULL, NULL, NULL, NULL }
   };
 
 /* A sample public key for NIST P-256.  */
 static const char sample_p256_q[] =
   "04"
   "42B927242237639A36CE9221B340DB1A9AB76DF2FE3E171277F6A4023DED146E"
   "E86525E38CCECFF3FB8D152CC6334F70D23A525175C1BCBDDE6E023B2228770E";
 static const char sample_p256_q_x[] =
   "42B927242237639A36CE9221B340DB1A9AB76DF2FE3E171277F6A4023DED146E";
 static const char sample_p256_q_y[] =
   "00E86525E38CCECFF3FB8D152CC6334F70D23A525175C1BCBDDE6E023B2228770E";
 
 
 /* A sample public key for Ed25519.  */
 static const char sample_ed25519_q[] =
   "04"
   "55d0e09a2b9d34292297e08d60d0f620c513d47253187c24b12786bd777645ce"
   "1a5107f7681a02af2523a6daf372e10e3a0764c9d3fe4bd5b70ab18201985ad7";
 static const char sample_ed25519_q_x[] =
   "55d0e09a2b9d34292297e08d60d0f620c513d47253187c24b12786bd777645ce";
 static const char sample_ed25519_q_y[] =
   "1a5107f7681a02af2523a6daf372e10e3a0764c9d3fe4bd5b70ab18201985ad7";
 static const char sample_ed25519_q_eddsa[] =
   "d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a";
 static const char sample_ed25519_d[] =
   "9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60";
 
 
 static void
 print_mpi_2 (const char *text, const char *text2, gcry_mpi_t a)
 {
   gcry_error_t err;
   char *buf;
   void *bufaddr = &buf;
 
   err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
   if (err)
     fprintf (stderr, "%s%s: [error printing number: %s]\n",
              text, text2? text2:"", gpg_strerror (err));
   else
     {
       fprintf (stderr, "%s%s: %s\n", text, text2? text2:"", buf);
       gcry_free (buf);
     }
 }
 
 
 static void
 print_mpi (const char *text, gcry_mpi_t a)
 {
   print_mpi_2 (text, NULL, a);
 }
 
 
 static void
 print_point (const char *text, gcry_mpi_point_t a)
 {
   gcry_mpi_t x, y, z;
 
   x = gcry_mpi_new (0);
   y = gcry_mpi_new (0);
   z = gcry_mpi_new (0);
   gcry_mpi_point_get (x, y, z, a);
   print_mpi_2 (text, ".x", x);
   print_mpi_2 (text, ".y", y);
   print_mpi_2 (text, ".z", z);
   gcry_mpi_release (x);
   gcry_mpi_release (y);
   gcry_mpi_release (z);
 }
 
 
 static void
 print_sexp (const char *prefix, gcry_sexp_t a)
 {
   char *buf;
   size_t size;
 
   if (prefix)
     fputs (prefix, stderr);
   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   buf = gcry_xmalloc (size);
 
   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
   fprintf (stderr, "%.*s", (int)size, buf);
   gcry_free (buf);
 }
 
 
 static gcry_mpi_t
 hex2mpi (const char *string)
 {
   gpg_error_t err;
   gcry_mpi_t val;
 
   err = gcry_mpi_scan (&val, GCRYMPI_FMT_HEX, string, 0, NULL);
   if (err)
     die ("hex2mpi '%s' failed: %s\n", string, gpg_strerror (err));
   return val;
 }
 
 
 /* Convert STRING consisting of hex characters into its binary
    representation and return it as an allocated buffer. The valid
    length of the buffer is returned at R_LENGTH.  The string is
    delimited by end of string.  The function returns NULL on
    error.  */
 static void *
 hex2buffer (const char *string, size_t *r_length)
 {
   const char *s;
   unsigned char *buffer;
   size_t length;
 
   buffer = xmalloc (strlen(string)/2+1);
   length = 0;
   for (s=string; *s; s +=2 )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         return NULL;           /* Invalid hex digits. */
       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     }
   *r_length = length;
   return buffer;
 }
 
 
 static gcry_mpi_t
 hex2mpiopa (const char *string)
 {
   char *buffer;
   size_t buflen;
   gcry_mpi_t val;
 
   buffer = hex2buffer (string, &buflen);
   if (!buffer)
     die ("hex2mpiopa '%s' failed: parser error\n", string);
   val = gcry_mpi_set_opaque (NULL, buffer, buflen*8);
   if (!buffer)
     die ("hex2mpiopa '%s' failed: set_opaque error\n", string);
   return val;
 }
 
 
 /* Compare A to B, where B is given as a hex string.  */
 static int
 cmp_mpihex (gcry_mpi_t a, const char *b)
 {
   gcry_mpi_t bval;
   int res;
 
   if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
     bval = hex2mpiopa (b);
   else
     bval = hex2mpi (b);
   res = gcry_mpi_cmp (a, bval);
   gcry_mpi_release (bval);
   return res;
 }
 
 
 /* Wrapper to emulate the libgcrypt internal EC context allocation
    function.  */
 static gpg_error_t
 ec_p_new (gcry_ctx_t *r_ctx, gcry_mpi_t p, gcry_mpi_t a)
 {
   gpg_error_t err;
   gcry_sexp_t sexp;
 
   if (p && a)
     err = gcry_sexp_build (&sexp, NULL, "(ecdsa (p %m)(a %m))", p, a);
   else if (p)
     err = gcry_sexp_build (&sexp, NULL, "(ecdsa (p %m))", p);
   else if (a)
     err = gcry_sexp_build (&sexp, NULL, "(ecdsa (a %m))", a);
   else
     err = gcry_sexp_build (&sexp, NULL, "(ecdsa)");
   if (err)
     return err;
   err = gcry_mpi_ec_new (r_ctx, sexp, NULL);
   gcry_sexp_release (sexp);
   return err;
 }
 
 
 
 static void
 set_get_point (void)
 {
   gcry_mpi_point_t point, point2;
   gcry_mpi_t x, y, z;
 
   wherestr = "set_get_point";
   info ("checking point setting functions\n");
 
   point = gcry_mpi_point_new (0);
   x = gcry_mpi_set_ui (NULL, 17);
   y = gcry_mpi_set_ui (NULL, 42);
   z = gcry_mpi_set_ui (NULL, 11371);
   gcry_mpi_point_get (x, y, z, point);
   if (gcry_mpi_cmp_ui (x, 0)
       || gcry_mpi_cmp_ui (y, 0) || gcry_mpi_cmp_ui (z, 0))
     fail ("new point not initialized to (0,0,0)\n");
   gcry_mpi_point_snatch_get (x, y, z, point);
   point = NULL;
   if (gcry_mpi_cmp_ui (x, 0)
       || gcry_mpi_cmp_ui (y, 0) || gcry_mpi_cmp_ui (z, 0))
     fail ("snatch_get failed\n");
   gcry_mpi_release (x);
   gcry_mpi_release (y);
   gcry_mpi_release (z);
 
   point = gcry_mpi_point_new (0);
   x = gcry_mpi_set_ui (NULL, 17);
   y = gcry_mpi_set_ui (NULL, 42);
   z = gcry_mpi_set_ui (NULL, 11371);
   gcry_mpi_point_set (point, x, y, z);
   gcry_mpi_set_ui (x, 23);
   gcry_mpi_set_ui (y, 24);
   gcry_mpi_set_ui (z, 25);
   gcry_mpi_point_get (x, y, z, point);
   if (gcry_mpi_cmp_ui (x, 17)
       || gcry_mpi_cmp_ui (y, 42) || gcry_mpi_cmp_ui (z, 11371))
     fail ("point_set/point_get failed\n");
   gcry_mpi_point_snatch_set (point, x, y, z);
   x = gcry_mpi_new (0);
   y = gcry_mpi_new (0);
   z = gcry_mpi_new (0);
   gcry_mpi_point_get (x, y, z, point);
   if (gcry_mpi_cmp_ui (x, 17)
       || gcry_mpi_cmp_ui (y, 42) || gcry_mpi_cmp_ui (z, 11371))
     fail ("point_snatch_set/point_get failed\n");
 
   point2 = gcry_mpi_point_copy (point);
 
   gcry_mpi_point_get (x, y, z, point2);
   if (gcry_mpi_cmp_ui (x, 17)
       || gcry_mpi_cmp_ui (y, 42) || gcry_mpi_cmp_ui (z, 11371))
     fail ("point_copy failed (1)\n");
 
   gcry_mpi_point_release (point);
 
   gcry_mpi_point_get (x, y, z, point2);
   if (gcry_mpi_cmp_ui (x, 17)
       || gcry_mpi_cmp_ui (y, 42) || gcry_mpi_cmp_ui (z, 11371))
     fail ("point_copy failed (2)\n");
 
   gcry_mpi_point_release (point2);
 
   gcry_mpi_release (x);
   gcry_mpi_release (y);
   gcry_mpi_release (z);
 }
 
 
 static void
 context_alloc (void)
 {
   gpg_error_t err;
   gcry_ctx_t ctx;
   gcry_mpi_t p, a;
 
   wherestr = "context_alloc";
   info ("checking context functions\n");
 
   p = gcry_mpi_set_ui (NULL, 1);
   a = gcry_mpi_set_ui (NULL, 1);
   err = ec_p_new (&ctx, p, a);
   if (err)
     die ("ec_p_new returned an error: %s\n", gpg_strerror (err));
   gcry_mpi_release (p);
   gcry_mpi_release (a);
   gcry_ctx_release (ctx);
 
   p = NULL;
   a = gcry_mpi_set_ui (NULL, 0);
 
   err = ec_p_new (&ctx, p, a);
   if (!err || gpg_err_code (err) != GPG_ERR_EINVAL)
     fail ("ec_p_new: bad parameter detection failed (1)\n");
 
   gcry_mpi_release (a);
   a = NULL;
   err = ec_p_new (&ctx, p, a);
   if (!err || gpg_err_code (err) != GPG_ERR_EINVAL)
     fail ("ec_p_new: bad parameter detection failed (2)\n");
 
 }
 
 
 static int
 get_and_cmp_mpi (const char *name, const char *mpistring, const char *desc,
                  gcry_ctx_t ctx)
 {
   gcry_mpi_t mpi;
 
   mpi = gcry_mpi_ec_get_mpi (name, ctx, 1);
   if (!mpi)
     {
       fail ("error getting parameter '%s' of curve '%s'\n", name, desc);
       return 1;
     }
   if (debug)
     print_mpi (name, mpi);
   if (cmp_mpihex (mpi, mpistring))
     {
       fail ("parameter '%s' of curve '%s' does not match\n", name, desc);
       gcry_mpi_release (mpi);
       return 1;
     }
   gcry_mpi_release (mpi);
   return 0;
 }
 
 
 static int
 get_and_cmp_point (const char *name,
                    const char *mpi_x_string, const char *mpi_y_string,
                    const char *desc, gcry_ctx_t ctx)
 {
   gcry_mpi_point_t point;
   gcry_mpi_t x, y, z;
   int result = 0;
 
   point = gcry_mpi_ec_get_point (name, ctx, 1);
   if (!point)
     {
       fail ("error getting point parameter '%s' of curve '%s'\n", name, desc);
       return 1;
     }
   if (debug)
     print_point (name, point);
 
   x = gcry_mpi_new (0);
   y = gcry_mpi_new (0);
   z = gcry_mpi_new (0);
   gcry_mpi_point_snatch_get (x, y, z, point);
   if (cmp_mpihex (x, mpi_x_string))
     {
       fail ("x coordinate of '%s' of curve '%s' does not match\n", name, desc);
       result = 1;
     }
   if (cmp_mpihex (y, mpi_y_string))
     {
       fail ("y coordinate of '%s' of curve '%s' does not match\n", name, desc);
       result = 1;
     }
   if (cmp_mpihex (z, "01"))
     {
       fail ("z coordinate of '%s' of curve '%s' is not 1\n", name, desc);
       result = 1;
     }
   gcry_mpi_release (x);
   gcry_mpi_release (y);
   gcry_mpi_release (z);
   return result;
 }
 
 
 static void
 context_param (void)
 {
   gpg_error_t err;
   int idx;
   gcry_ctx_t ctx = NULL;
   gcry_mpi_t q, d;
   gcry_sexp_t keyparam;
 
   wherestr = "context_param";
 
   info ("checking standard curves\n");
   for (idx=0; test_curve[idx].desc; idx++)
     {
       /* P-192 and Ed25519 are not supported in fips mode */
       if (gcry_fips_mode_active())
         {
           if (!strcmp(test_curve[idx].desc, "NIST P-192")
               || !strcmp(test_curve[idx].desc, "Ed25519"))
             {
 	      info ("skipping %s in fips mode\n", test_curve[idx].desc );
               continue;
             }
         }
 
       gcry_ctx_release (ctx);
       err = gcry_mpi_ec_new (&ctx, NULL, test_curve[idx].desc);
       if (err)
         {
           fail ("can't create context for curve '%s': %s\n",
                 test_curve[idx].desc, gpg_strerror (err));
           continue;
         }
       if (get_and_cmp_mpi ("p", test_curve[idx].p, test_curve[idx].desc, ctx))
         continue;
       if (get_and_cmp_mpi ("a", test_curve[idx].a, test_curve[idx].desc, ctx))
         continue;
       if (get_and_cmp_mpi ("b", test_curve[idx].b, test_curve[idx].desc, ctx))
         continue;
       if (get_and_cmp_mpi ("g.x",test_curve[idx].g_x, test_curve[idx].desc,ctx))
         continue;
       if (get_and_cmp_mpi ("g.y",test_curve[idx].g_y, test_curve[idx].desc,ctx))
         continue;
       if (get_and_cmp_mpi ("n", test_curve[idx].n, test_curve[idx].desc, ctx))
         continue;
       if (get_and_cmp_point ("g", test_curve[idx].g_x, test_curve[idx].g_y,
                              test_curve[idx].desc, ctx))
         continue;
       if (get_and_cmp_mpi ("h", test_curve[idx].h, test_curve[idx].desc, ctx))
         continue;
 
     }
 
   info ("checking sample public key (nistp256)\n");
   q = hex2mpi (sample_p256_q);
   err = gcry_sexp_build (&keyparam, NULL,
                         "(public-key(ecc(curve %s)(q %m)))",
                         "NIST P-256", q);
   if (err)
     die ("gcry_sexp_build failed: %s\n", gpg_strerror (err));
   gcry_mpi_release (q);
 
   /* We can't call gcry_pk_testkey because it is only implemented for
      private keys.  */
   /* err = gcry_pk_testkey (keyparam); */
   /* if (err) */
   /*   fail ("gcry_pk_testkey failed for sample public key: %s\n", */
   /*         gpg_strerror (err)); */
 
   gcry_ctx_release (ctx);
   err = gcry_mpi_ec_new (&ctx, keyparam, NULL);
   if (err)
     fail ("gcry_mpi_ec_new failed for sample public key (nistp256): %s\n",
           gpg_strerror (err));
   else
     {
       gcry_sexp_t sexp;
 
       get_and_cmp_mpi ("q", sample_p256_q, "nistp256", ctx);
       get_and_cmp_point ("q", sample_p256_q_x, sample_p256_q_y, "nistp256",
                          ctx);
 
       /* Delete Q.  */
       err = gcry_mpi_ec_set_mpi ("q", NULL, ctx);
       if (err)
         fail ("clearing Q for nistp256 failed: %s\n", gpg_strerror (err));
       if (gcry_mpi_ec_get_mpi ("q", ctx, 0))
         fail ("clearing Q for nistp256 did not work\n");
 
       /* Set Q again.  */
       q = hex2mpi (sample_p256_q);
       err = gcry_mpi_ec_set_mpi ("q", q, ctx);
       if (err)
         fail ("setting Q for nistp256 failed: %s\n", gpg_strerror (err));
       get_and_cmp_mpi ("q", sample_p256_q, "nistp256(2)", ctx);
       gcry_mpi_release (q);
 
       /* Get as s-expression.  */
       err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
       if (err)
         fail ("gcry_pubkey_get_sexp(0) failed: %s\n", gpg_strerror (err));
       else if (debug)
         print_sexp ("Result of gcry_pubkey_get_sexp (0):\n", sexp);
       gcry_sexp_release (sexp);
 
       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_PUBKEY, ctx);
       if (err)
         fail ("gcry_pubkey_get_sexp(GET_PUBKEY) failed: %s\n",
               gpg_strerror (err));
       else if (debug)
         print_sexp ("Result of gcry_pubkey_get_sexp (GET_PUBKEY):\n", sexp);
       gcry_sexp_release (sexp);
 
       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_SECKEY, ctx);
       if (gpg_err_code (err) != GPG_ERR_NO_SECKEY)
         fail ("gcry_pubkey_get_sexp(GET_SECKEY) returned wrong error: %s\n",
               gpg_strerror (err));
       gcry_sexp_release (sexp);
     }
 
   /* Skipping Ed25519 if in FIPS mode (it isn't supported) */
   if (gcry_fips_mode_active())
     goto cleanup;
 
   info ("checking sample public key (Ed25519)\n");
   q = hex2mpi (sample_ed25519_q);
   gcry_sexp_release (keyparam);
   err = gcry_sexp_build (&keyparam, NULL,
                         "(public-key(ecc(curve %s)(flags eddsa)(q %m)))",
                         "Ed25519", q);
   if (err)
     die ("gcry_sexp_build failed: %s\n", gpg_strerror (err));
   gcry_mpi_release (q);
 
   /* We can't call gcry_pk_testkey because it is only implemented for
      private keys.  */
   /* err = gcry_pk_testkey (keyparam); */
   /* if (err) */
   /*   fail ("gcry_pk_testkey failed for sample public key: %s\n", */
   /*         gpg_strerror (err)); */
 
   gcry_ctx_release (ctx);
   err = gcry_mpi_ec_new (&ctx, keyparam, NULL);
   if (err)
     fail ("gcry_mpi_ec_new failed for sample public key: %s\n",
           gpg_strerror (err));
   else
     {
       gcry_sexp_t sexp;
 
       get_and_cmp_mpi ("q", sample_ed25519_q, "Ed25519", ctx);
       get_and_cmp_point ("q", sample_ed25519_q_x, sample_ed25519_q_y,
                          "Ed25519", ctx);
       get_and_cmp_mpi ("q@eddsa", sample_ed25519_q_eddsa, "Ed25519", ctx);
 
       /* Set d to see whether Q is correctly re-computed.  */
       d = hex2mpi (sample_ed25519_d);
       err = gcry_mpi_ec_set_mpi ("d", d, ctx);
       if (err)
         fail ("setting d for Ed25519 failed: %s\n", gpg_strerror (err));
       gcry_mpi_release (d);
       get_and_cmp_mpi ("q", sample_ed25519_q, "Ed25519(recompute Q)", ctx);
 
       /* Delete Q by setting d and then clearing d.  The clearing is
          required so that we can check whether Q has been cleared and
          because further tests only expect a public key.  */
       d = hex2mpi (sample_ed25519_d);
       err = gcry_mpi_ec_set_mpi ("d", d, ctx);
       if (err)
         fail ("setting d for Ed25519 failed: %s\n", gpg_strerror (err));
       gcry_mpi_release (d);
       err = gcry_mpi_ec_set_mpi ("d", NULL, ctx);
       if (err)
         fail ("setting d for Ed25519 failed(2): %s\n", gpg_strerror (err));
       if (gcry_mpi_ec_get_mpi ("q", ctx, 0))
         fail ("setting d for Ed25519 did not reset Q\n");
 
       /* Set Q again.  We need to use an opaque MPI here because
          sample_ed25519_q is in uncompressed format which can only be
          auto-detected if passed opaque.  */
       q = hex2mpiopa (sample_ed25519_q);
       err = gcry_mpi_ec_set_mpi ("q", q, ctx);
       if (err)
         fail ("setting Q for Ed25519 failed: %s\n", gpg_strerror (err));
       gcry_mpi_release (q);
       get_and_cmp_mpi ("q", sample_ed25519_q, "Ed25519(2)", ctx);
 
       /* Get as s-expression.  */
       err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
       if (err)
         fail ("gcry_pubkey_get_sexp(0) failed: %s\n", gpg_strerror (err));
       else if (debug)
         print_sexp ("Result of gcry_pubkey_get_sexp (0):\n", sexp);
       gcry_sexp_release (sexp);
 
       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_PUBKEY, ctx);
       if (err)
         fail ("gcry_pubkey_get_sexp(GET_PUBKEY) failed: %s\n",
               gpg_strerror (err));
       else if (debug)
         print_sexp ("Result of gcry_pubkey_get_sexp (GET_PUBKEY):\n", sexp);
       gcry_sexp_release (sexp);
 
       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_SECKEY, ctx);
       if (gpg_err_code (err) != GPG_ERR_NO_SECKEY)
         fail ("gcry_pubkey_get_sexp(GET_SECKEY) returned wrong error: %s\n",
               gpg_strerror (err));
       gcry_sexp_release (sexp);
 
     }
 
  cleanup:
   gcry_ctx_release (ctx);
   gcry_sexp_release (keyparam);
 }
 
 
 
 
 /* Create a new point from (X,Y,Z) given as hex strings.  */
 gcry_mpi_point_t
 make_point (const char *x, const char *y, const char *z)
 {
   gcry_mpi_point_t point;
 
   point = gcry_mpi_point_new (0);
   gcry_mpi_point_snatch_set (point, hex2mpi (x), hex2mpi (y), hex2mpi (z));
 
   return point;
 }
 
 
 /* This tests checks that the low-level EC API yields the same result
    as using the high level API.  The values have been taken from a
    test run using the high level API.  */
 static void
 basic_ec_math (void)
 {
   gpg_error_t err;
   gcry_ctx_t ctx;
   gcry_mpi_t P, A;
   gcry_mpi_point_t G, Q;
   gcry_mpi_t d;
   gcry_mpi_t x, y, z;
 
   wherestr = "basic_ec_math";
   info ("checking basic math functions for EC\n");
 
   P = hex2mpi ("0xfffffffffffffffffffffffffffffffeffffffffffffffff");
   A = hex2mpi ("0xfffffffffffffffffffffffffffffffefffffffffffffffc");
   G = make_point ("188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012",
                   "7192B95FFC8DA78631011ED6B24CDD573F977A11E794811",
                   "1");
   d = hex2mpi ("D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D");
   Q = gcry_mpi_point_new (0);
 
   err = ec_p_new (&ctx, P, A);
   if (err)
     die ("ec_p_new failed: %s\n", gpg_strerror (err));
 
   x = gcry_mpi_new (0);
   y = gcry_mpi_new (0);
   z = gcry_mpi_new (0);
 
   {
     /* A quick check that multiply by zero works.  */
     gcry_mpi_t tmp;
 
     tmp = gcry_mpi_new (0);
     gcry_mpi_ec_mul (Q, tmp, G, ctx);
     gcry_mpi_release (tmp);
     gcry_mpi_point_get (x, y, z, Q);
     if (gcry_mpi_cmp_ui (x, 0) || gcry_mpi_cmp_ui (y, 0)
         || gcry_mpi_cmp_ui (z, 0))
       fail ("multiply a point by zero failed\n");
   }
 
   gcry_mpi_ec_mul (Q, d, G, ctx);
   gcry_mpi_point_get (x, y, z, Q);
   if (cmp_mpihex (x, "222D9EC717C89D047E0898C9185B033CD11C0A981EE6DC66")
       || cmp_mpihex (y, "605DE0A82D70D3E0F84A127D0739ED33D657DF0D054BFDE8")
       || cmp_mpihex (z, "00B06B519071BC536999AC8F2D3934B3C1FC9EACCD0A31F88F"))
     fail ("computed public key does not match\n");
   if (debug)
     {
       print_mpi ("Q.x", x);
       print_mpi ("Q.y", y);
       print_mpi ("Q.z", z);
     }
 
   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
     fail ("failed to get affine coordinates\n");
   if (cmp_mpihex (x, "008532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE")
       || cmp_mpihex (y, "00C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966"))
     fail ("computed affine coordinates of public key do not match\n");
   if (debug)
     {
       print_mpi ("q.x", x);
       print_mpi ("q.y", y);
     }
 
   gcry_mpi_release (z);
   gcry_mpi_release (y);
   gcry_mpi_release (x);
   gcry_mpi_point_release (Q);
   gcry_mpi_release (d);
   gcry_mpi_point_release (G);
   gcry_mpi_release (A);
   gcry_mpi_release (P);
   gcry_ctx_release (ctx);
 }
 
 
 /* This is the same as basic_ec_math but uses more advanced
    features.  */
 static void
 basic_ec_math_simplified (void)
 {
   gpg_error_t err;
   gcry_ctx_t ctx;
   gcry_mpi_point_t G, Q;
   gcry_mpi_t d;
   gcry_mpi_t x, y, z;
   gcry_sexp_t sexp;
 
   wherestr = "basic_ec_math_simplified";
   info ("checking basic math functions for EC (variant)\n");
 
   d = hex2mpi ("D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D");
   Q = gcry_mpi_point_new (0);
 
   err = gcry_mpi_ec_new (&ctx, NULL, "NIST P-192");
   if (err)
     die ("gcry_mpi_ec_new failed: %s\n", gpg_strerror (err));
   G = gcry_mpi_ec_get_point ("g", ctx, 1);
   if (!G)
     die ("gcry_mpi_ec_get_point(G) failed\n");
   gcry_mpi_ec_mul (Q, d, G, ctx);
 
   x = gcry_mpi_new (0);
   y = gcry_mpi_new (0);
   z = gcry_mpi_new (0);
   gcry_mpi_point_get (x, y, z, Q);
   if (cmp_mpihex (x, "222D9EC717C89D047E0898C9185B033CD11C0A981EE6DC66")
       || cmp_mpihex (y, "605DE0A82D70D3E0F84A127D0739ED33D657DF0D054BFDE8")
       || cmp_mpihex (z, "00B06B519071BC536999AC8F2D3934B3C1FC9EACCD0A31F88F"))
     fail ("computed public key does not match\n");
   if (debug)
     {
       print_mpi ("Q.x", x);
       print_mpi ("Q.y", y);
       print_mpi ("Q.z", z);
     }
 
   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
     fail ("failed to get affine coordinates\n");
   if (cmp_mpihex (x, "008532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE")
       || cmp_mpihex (y, "00C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966"))
     fail ("computed affine coordinates of public key do not match\n");
   if (debug)
     {
       print_mpi ("q.x", x);
       print_mpi ("q.y", y);
     }
 
   gcry_mpi_release (z);
   gcry_mpi_release (y);
   gcry_mpi_release (x);
 
   /* Let us also check whether we can update the context.  */
   err = gcry_mpi_ec_set_point ("g", G, ctx);
   if (err)
     die ("gcry_mpi_ec_set_point(G) failed\n");
   err = gcry_mpi_ec_set_mpi ("d", d, ctx);
   if (err)
     die ("gcry_mpi_ec_set_mpi(d) failed\n");
 
   /* FIXME: Below we need to check that the returned S-expression is
      as requested.  For now we use manual inspection using --debug.  */
 
   /* Does get_sexp return the private key?  */
   err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
   if (err)
     fail ("gcry_pubkey_get_sexp(0) failed: %s\n", gpg_strerror (err));
   else if (debug)
     print_sexp ("Result of gcry_pubkey_get_sexp (0):\n", sexp);
   gcry_sexp_release (sexp);
 
   /* Does get_sexp return the public key if requested?  */
   err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_PUBKEY, ctx);
   if (err)
     fail ("gcry_pubkey_get_sexp(GET_PUBKEY) failed: %s\n", gpg_strerror (err));
   else if (debug)
     print_sexp ("Result of gcry_pubkey_get_sexp (GET_PUBKEY):\n", sexp);
   gcry_sexp_release (sexp);
 
   /* Does get_sexp return the public key after d has been deleted?  */
   err = gcry_mpi_ec_set_mpi ("d", NULL, ctx);
   if (err)
     die ("gcry_mpi_ec_set_mpi(d=NULL) failed\n");
   err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
   if (err)
     fail ("gcry_pubkey_get_sexp(0 w/o d) failed: %s\n", gpg_strerror (err));
   else if (debug)
     print_sexp ("Result of gcry_pubkey_get_sexp (0 w/o d):\n", sexp);
   gcry_sexp_release (sexp);
 
   /* Does get_sexp return an error after d has been deleted?  */
   err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_SECKEY, ctx);
   if (gpg_err_code (err) != GPG_ERR_NO_SECKEY)
     fail ("gcry_pubkey_get_sexp(GET_SECKEY) returned wrong error: %s\n",
           gpg_strerror (err));
   gcry_sexp_release (sexp);
 
   /* Does get_sexp return an error after d and Q have been deleted?  */
   err = gcry_mpi_ec_set_point ("q", NULL, ctx);
   if (err)
     die ("gcry_mpi_ec_set_point(q=NULL) failed\n");
   err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
   if (gpg_err_code (err) != GPG_ERR_BAD_CRYPT_CTX)
     fail ("gcry_pubkey_get_sexp(0 w/o Q,d) returned wrong error: %s\n",
           gpg_strerror (err));
   gcry_sexp_release (sexp);
 
 
   gcry_mpi_point_release (Q);
   gcry_mpi_release (d);
   gcry_mpi_point_release (G);
   gcry_ctx_release (ctx);
 }
 
 
 /* Check the math used with Twisted Edwards curves.  */
 static void
 twistededwards_math (void)
 {
   gpg_error_t err;
   gcry_ctx_t ctx;
   gcry_mpi_point_t G, Q;
   gcry_mpi_t k;
   gcry_mpi_t w, a, x, y, z, p, n, b, I;
 
   wherestr = "twistededwards_math";
   info ("checking basic Twisted Edwards math\n");
 
   err = gcry_mpi_ec_new (&ctx, NULL, "Ed25519");
   if (err)
     die ("gcry_mpi_ec_new failed: %s\n", gpg_strerror (err));
 
   k = hex2mpi
     ("2D3501E723239632802454EE5DDC406EFB0BDF18486A5BDE9C0390A9C2984004"
      "F47252B628C953625B8DEB5DBCB8DA97AA43A1892D11FA83596F42E0D89CB1B6");
   G = gcry_mpi_ec_get_point ("g", ctx, 1);
   if (!G)
     die ("gcry_mpi_ec_get_point(G) failed\n");
   Q = gcry_mpi_point_new (0);
 
 
   w = gcry_mpi_new (0);
   a = gcry_mpi_new (0);
   x = gcry_mpi_new (0);
   y = gcry_mpi_new (0);
   z = gcry_mpi_new (0);
   I = gcry_mpi_new (0);
   p = gcry_mpi_ec_get_mpi ("p", ctx, 1);
   n = gcry_mpi_ec_get_mpi ("n", ctx, 1);
   b = gcry_mpi_ec_get_mpi ("b", ctx, 1);
 
   /* Check: 2^{p-1} mod p == 1 */
   gcry_mpi_sub_ui (a, p, 1);
   gcry_mpi_powm (w, GCRYMPI_CONST_TWO, a, p);
   if (gcry_mpi_cmp_ui (w, 1))
     fail ("failed assertion: 2^{p-1} mod p == 1\n");
 
   /* Check: p % 4 == 1 */
   gcry_mpi_mod (w, p, GCRYMPI_CONST_FOUR);
   if (gcry_mpi_cmp_ui (w, 1))
     fail ("failed assertion: p %% 4 == 1\n");
 
   /* Check: 2^{n-1} mod n == 1 */
   gcry_mpi_sub_ui (a, n, 1);
   gcry_mpi_powm (w, GCRYMPI_CONST_TWO, a, n);
   if (gcry_mpi_cmp_ui (w, 1))
     fail ("failed assertion: 2^{n-1} mod n == 1\n");
 
   /* Check: b^{(p-1)/2} mod p == p-1 */
   gcry_mpi_sub_ui (a, p, 1);
   gcry_mpi_div (x, NULL, a, GCRYMPI_CONST_TWO, -1);
   gcry_mpi_powm (w, b, x, p);
   gcry_mpi_abs (w);
   if (gcry_mpi_cmp (w, a))
     fail ("failed assertion: b^{(p-1)/2} mod p == p-1\n");
 
   /* I := 2^{(p-1)/4} mod p */
   gcry_mpi_sub_ui (a, p, 1);
   gcry_mpi_div (x, NULL, a, GCRYMPI_CONST_FOUR, -1);
   gcry_mpi_powm (I, GCRYMPI_CONST_TWO, x, p);
 
   /* Check: I^2 mod p == p-1 */
   gcry_mpi_powm (w, I, GCRYMPI_CONST_TWO, p);
   if (gcry_mpi_cmp (w, a))
     fail ("failed assertion: I^2 mod p == p-1\n");
 
   /* Check: G is on the curve */
   if (!gcry_mpi_ec_curve_point (G, ctx))
     fail ("failed assertion: G is on the curve\n");
 
   /* Check: nG == (0,1) */
   gcry_mpi_ec_mul (Q, n, G, ctx);
   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
     fail ("failed to get affine coordinates\n");
   if (gcry_mpi_cmp_ui (x, 0) || gcry_mpi_cmp_ui (y, 1))
     fail ("failed assertion: nG == (0,1)\n");
 
   /* Now two arbitrary point operations taken from the ed25519.py
      sample data.  */
   gcry_mpi_release (a);
   a = hex2mpi
     ("4f71d012df3c371af3ea4dc38385ca5bb7272f90cb1b008b3ed601c76de1d496"
      "e30cbf625f0a756a678d8f256d5325595cccc83466f36db18f0178eb9925edd3");
   gcry_mpi_ec_mul (Q, a, G, ctx);
   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
     fail ("failed to get affine coordinates\n");
   if (cmp_mpihex (x, ("157f7361c577aad36f67ed33e38dc7be"
                       "00014fecc2165ca5cee9eee19fe4d2c1"))
       || cmp_mpihex (y, ("5a69dbeb232276b38f3f5016547bb2a2"
                          "4025645f0b820e72b8cad4f0a909a092")))
     {
       fail ("sample point multiply failed:\n");
       print_mpi ("r", a);
       print_mpi ("Rx", x);
       print_mpi ("Ry", y);
     }
 
   gcry_mpi_release (a);
   a = hex2mpi
     ("2d3501e723239632802454ee5ddc406efb0bdf18486a5bde9c0390a9c2984004"
      "f47252b628c953625b8deb5dbcb8da97aa43a1892d11fa83596f42e0d89cb1b6");
   gcry_mpi_ec_mul (Q, a, G, ctx);
   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
     fail ("failed to get affine coordinates\n");
   if (cmp_mpihex (x, ("6218e309d40065fcc338b3127f468371"
                       "82324bd01ce6f3cf81ab44e62959c82a"))
       || cmp_mpihex (y, ("5501492265e073d874d9e5b81e7f8784"
                          "8a826e80cce2869072ac60c3004356e5")))
     {
       fail ("sample point multiply failed:\n");
       print_mpi ("r", a);
       print_mpi ("Rx", x);
       print_mpi ("Ry", y);
     }
 
 
   gcry_mpi_release (I);
   gcry_mpi_release (b);
   gcry_mpi_release (n);
   gcry_mpi_release (p);
   gcry_mpi_release (w);
   gcry_mpi_release (a);
   gcry_mpi_release (x);
   gcry_mpi_release (y);
   gcry_mpi_release (z);
   gcry_mpi_point_release (Q);
   gcry_mpi_point_release (G);
   gcry_mpi_release (k);
   gcry_ctx_release (ctx);
 }
 
 
 /* Check the point on curve function.  */
 static void
 point_on_curve (void)
 {
   static struct {
     const char *curve;
     int oncurve;      /* Point below is on the curve.  */
     const char *qx;
     const char *qy;
   } t[] = {
     {
       "NIST P-256", 0,
       "015B4F6775D68D4D2E2192C6B8027FC5A3D49957E453CB251155AA3FF5D3EC9974",
       "4BC4C87B57A25E1056831208AB5B8F091142F891E9FF19F1E090B030DF1087B3"
     }, {
       "NIST P-256", 0,
       "D22C316E7EBE7B293BD66808E000806F0754398A5D72A4F9BBC21C26EAC0A651",
       "3C8DB80CC3CDE5E530D040536E6A58AAB41C33FA70B30896943513FF3690132D"
     }, {
       "NIST P-256", 0,
       "0130F7E7BC52854CA493A0DE87DC4AB3B4343758F2B634F15B10D70DBC0A5A5291",
       "86F9CA73C25CE86D54CB21C181AECBB52A5971334FF5040F76CAE9845ED46023"
     }, {
       "NIST P-256", 1,
       "14957B602C7849F28858C7407696F014BC091D6D68C449560B7A38147D6E6A9B",
       "A8E09EFEECFE00C797A0848F38B61992D30C61FAB13021E88C8BD3545B3A6C63"
     }, {
       "NIST P-256", 0,
       "923DE4957241DD97780841C76294DB0D4F5DC04C3045081174764D2D32AD2D53",
       "01B4B1A2027C02F0F520A3B01E4CE3C668BF481346A74499C5D1044A53E210B600"
     }, {
       "NIST P-256", 1,
       "9021DFAB8B4DAEAADA634AAA26D6E5FFDF8C0476FF5CA31606C870A1B933FB36",
       "9AFC65EEB24E46C7B75712EF29A981CB09FAC56E2B81D3ED024748CCAB1CB77E"
     }, {
       "NIST P-256", 0,
       "011529F0B26DE5E0EB2DA4BFB6C149C802CB52EE479DD666553286928A4005E990",
       "0EBC63DB2104884456DC0AA81A3F4E99D93B7AE2CD4B1489655EA9BE6289CF9E"
     }, {
       "NIST P-256", 1,
       "216EC5DE8CA989199D31F0DFCD381DCC9270A0785365EC3E34CA347C070A87BE",
       "87A88897BA763509ECC1DBE28D9D37F6F4E70E3B99B1CD3C0B934D4190968A6D"
     }, {
       "NIST P-256", 1,
       "7ABAA44ACBC6016FDB52A6F45F6178E65CBFC35F9920D99149CA9999612CE945",
       "88F7684BDCDA31EAFB6CAD859F8AB29B5D921D7DB2B34DF7E40CE36235F45B63"
     }, {
       "NIST P-256", 0,
       "E765B4272D211DD0064189B55421FB76BB3A7756364A6CB1627FAED848157A84",
       "C13171CFFB243E06B203F0996BBDD16F52292AD11F2DA81106E9C2FD87F4FA0F"
     }, {
       "NIST P-256", 0,
       "EE4999DFC3A1871EE7A592BE26A09BEC9D9B561613EE9EFB6ED42F17985C9CDC",
       "8399E967338A7A618336AF70DA67D9CAC1C19267809652F5C5183C8B129E0902"
     }, {
       "NIST P-256", 0,
       "F755D0CF2642A2C7FBACCC8E9E442B8B047A99C6E052B2FA5AB0544B36B4D51C",
       "AA080F17657B6565D9A4D94BD260B54D92FEE8DC4A78C4FC9C19209933AF39B0"
     } , {
       "NIST P-384", 0,
       "CBFC7DBEBF15BEAD682549757F9BBA0E3F67669DF13FCE0EBE8024B725B38B00"
       "83EC46A8F2FF3203C5C7F8C7E722A5EF",
       "0548FE281BEAB18FD1AB86F59B0CA524479A4A81373C83B78AFFD801FAC75922"
       "96470753DCF46173C9AA4A8A4C2FBE51"
     }, {
       "NIST P-384", 0,
       "1DC8E054A883DB81EAEDE6C487B26816C927B8196780525A6CA8F675D2557752"
       "02CE06CCBE705EA8A38AA2894D4BEEE6",
       "010191050E867AFAA96A199FE9C591CF8B853D81486786DA889124881FB39D2F"
       "8E0875F4C4BB1E3D0F8535C7A52306FB82"
     }, {
       "NIST P-384", 1,
       "2539FC368CE1D5E464B6C0FBB12D557B712327DB086975255AD7D17F7E7E4F23"
       "D719ED4116E2CC907AEB92CF22331A60",
       "8843FDBA742CB64323E49CEBE8DD74908CFC9C3AA0015662DFBB7219E92CF32E"
       "9FC63F61EF19DE9B3CEA98D163ABF254"
     }, {
       "NIST P-384", 0,
       "0B786DACF400D43575394349EDD9F9CD145FC7EF737A3C5F69B253BE7639DB24"
       "EC2F0CA62FF1F90B6515DE356EC2A404",
       "225D6B2939CC7F7133F43353946A682C68DAC6BB75EE9CF6BD9A1609FA915692"
       "72F4D3A87E88529754E109BB9B61B03B"
     }, {
       "NIST P-384", 0,
       "76C660C9F58CF2051F9F8B06049694AB6FE418009DE6F0A0833BC690CEC06CC2"
       "9A440AD51C94CF5BC28817C8C6E2D302",
       "012974E5D9E55304ED294AB6C7A3C65B663E67ABC5E6F6C0F6498B519F2F6CA1"
       "8306976291F3ADC0B5ABA42DED376EA9A5"
     }, {
       "NIST P-384", 0,
       "23D758B1EDB8E12E9E707C53C131A19D9464B20EE05C99766F5ABDF9F906AD03"
       "B958BF28B022E54E320672C4BAD4EEC0",
       "01E9E72870C88F4C82A5AB3CC8A3398E8F006BF3EC05FFBB1EFF8AEE88020FEA"
       "9E558E9F58ED1D324C9DCBCB4E8F2A5970"
     }, {
       "NIST P-384", 0,
       "D062B96D5A10F715ACF361F99262ABF0F7693A8BB60ECB1DF459CF95750E4293"
       "18BCB9FC60499D009F949298F3F9F47B",
       "9089C6328E4B39A73D7EE6FAE1A77E48CE354B83BBCE432082C32C8FD6784B86"
       "CFE9C552E2E720F5DA5806503D3784CD"
     }, {
       "NIST P-384", 0,
       "2A951D4D6EB35C43D94866280D37365B82441BC84D62CBFF3365CAB1FD0A3E20"
       "823CA8F84D2BBF4EA687885437DE7839",
       "01CC7D762AFE613F7B5568BC516568A421159C40599E8D52DE10E8F9488931E1"
       "69F3656C322DE45C4A70DC6DB9A661E599"
     }, {
       "NIST P-384", 1,
       "A4BAEE6CDAF3AEB69032B3FBA811707C54F5753670DA5173D891547E8CBAEEF3"
       "89B92C9A55573A596123415FBFA26991",
       "3241EA716583C11C71BB30AF6C5E3A6637956F17ADBBE641BAB52E8539F9FC7B"
       "F3B04F46DBFFE08151E0F0950CC70081"
     }, {
       "NIST P-384", 0,
       "5C0E18B0DE3261BCBCFC7B702C2D75CF481336BFBADF420BADC616235C1966AB"
       "4C0F876575DDEC1BDB3F3F04061C9AE4",
       "E90C78550D1C922F1D8161D8C9C0576E29BD09CA665376FA887D13FA8DF48352"
       "D7BBEEFB803F6CC8FC7895E47F348D33"
     }, {
       "NIST P-384", 1,
       "2015864CD50F0A1A50E6401F44191665C19E4AD4B4903EA9EB464E95D1070E36"
       "F1D8325E45734D5A0FDD103F4DF6F83E",
       "5FB3E9A5C59DD5C5262A8176CB7032A00AE33AED08485884A3E5D68D9EEB990B"
       "F26E8D87EC175577E782AD51A6A12C02"
     }, {
       "NIST P-384", 1,
       "56EBF5310EEF5A5D8D001F570A18625383ECD4882B3FC738A69874E7C9D8F89C"
       "187BECA23369DFD6C15CC0DA0629958F",
       "C1230B349FB662CB762563DB8F9FCB32D5CCA16120681C474D67D279CCA6F6DB"
       "73DE6AA96140B5C457B7486E06D318CE"
     }, {
       "NIST P-521", 0,
       "01E4D82EE5CD6DA37080252295EFA273BBBA6952012D0120EAF131E73F1E5024"
       "36E3324624471040030E1C345D65490ECEE9B64E03B15B6C7EB69A39C618BAFEED70",
       "03EE3A3C88A6933B7B16016BE4CC4E3BF5EA0625CB3DB2604CDCBBD02CABBC90"
       "8904D9DB42998F6C5101D4D4318ACFC9643C9CD641F636D1810ED86F1840EA74F3C0"
     }, {
       "NIST P-521", 0,
       "01F3DFCB5433387B6B2E3F74177F4F3D7300F05E1AD49DE112630E27B1C8A437"
       "1E742CB020E0039B5477FC897D17332034F9660B3066764EFF5FB440EB8856E782E3",
       "02D337616C9D202DC5E290C486F5855CBD6A8470AE62CA96245834CF49257D8D"
       "96D4041B15007650DEE668C00DDBF749054256C571F60980AC74D0DBCA7FB96C2F48"
     }, {
       "NIST P-521", 1,
       "822A846606DC9E96452CAC373567A8B57D9ACA15B177F75DD7EF10C635F52CE4"
       "EF6ABEEDB90D3F48F50A0C9015A95C955A25C45DE8413DE3BF899B6B1E62CF7CB8",
       "0102771B5F3EC8C36838CEC04DCBC28AD1E38C37DAB0EA89B5EE92D21F7A35CE"
       "ABC8B155EDC70154D6DFA2E77EC1D8C4A3406A6BD0ECF8F1EE2AC33A02464CB70C97"
     }, {
       "NIST P-521", 0,
       "F733D48467912D1FFE46CF442F27FDD218D190E7B8A829D822DA3B6BAF9B987E"
       "5B4BCCE34499248F59EEAF74F63ED15FF73F243C6FC3FD5E5842F6A3BA34C2022D",
       "0281AAAD1B7EEBABEB6EC67932CB7E95717AFA3B4CF7A2DB151CD537C419C3A5"
       "156ED9160758190B47696CDC15E81BBAD12975283907A571604DB23F702AEA4B38FF"
     }, {
       "NIST P-521", 0,
       "03B1B274175AAEB5907152E5114CCAEADA28A7ADD4A2B1831C3D8302E8596489"
       "E2C98B9B8D0CAE98C03BB11E28CE66D4736449758AF58BAFE40EF5A5FA22C9A43117",
       "94C5951F81D544E959EDFC5DC1D5F42FE427871D4FB91A43A0B4A6BEA6B35B9E"
       "BC5FB444C70BE4FD47B4ED16704F8C86EF019FC47C7FF2271F8B0DDEA9E2D3BCDD"
     }, {
       "NIST P-521", 1,
       "F2248C318055DE37CD706D4FCAF7E7D96737A4A7B6B8067A66DCD58B6B8DFC55"
       "90ECE67F6AA67F9C51B57E7B023075F2F42909BF47361CB6881C10F55FB7215B56",
       "0162F735CE6A2ADA54CAF96A12D6888C02DE0A74638CF34CE39DABBACA4D651B"
       "7E6ED1A65B551B36BAE7BE474BB6E6905ED0E33C7BA2021885027C7C6E40C5613004"
     }, {
       "NIST P-521", 0,
       "9F08E97FEADCF0A391CA1EA4D97B5FE62D3B164593E12027EB967BD6E1FA841A"
       "9831158DF164BCAD0BF3ADA96127745E25F349BDDD52EEA1654892B35960C9C023",
       "AE2A25F5440F258AFACA6925C4C9F7AEAD3CB67153C4FACB31AC33F58B43A78C"
       "B14F682FF726CEE2A6B6F6B481AEEB29A9B3150F02D1CFB764672BA8294C477291"
     }, {
       "NIST P-521", 0,
       "01047B52014748C904980716953206A93F0D01B34CA94A997407FA93FE304F86"
       "17BB6E402B2BB8B434C2671ECE953ABE7BADB75713CD9DF950943A33A9A19ACCDABE",
       "7433533F098037DEA616337986887D01C5CC8DEC3DC1FDB9CDF7287EF27CC125"
       "54FCF3A5E212DF9DAD9F8A3A7173B23FC6E15930704F3AEE1B074BDDB0ED6823E4"
     }, {
       "NIST P-521", 0,
       "01C2A9EBF51592FE6589F618EAADA1697D9B2EC7CE5D48C9E80FC597642B23F1"
       "F0EBE953449762BD3F094F57791D9850AFE98BBDA9872BE399B7BDD617860076BB03",
       "0B822E27692F63DB8E12C59BB3CCA172B9BBF613CAE5F9D1474186E45E8B26FF"
       "962084E1C6BE74821EDBB60941A3B75516F603719563433383812BFEA89EC14B89"
     }, {
       "NIST P-521", 0,
       "99390F342C3F0D46E80C5B65C61E8AA8ACA0B6D4E1352404586364A05D8398E9"
       "2BC71A644E8663F0A9B87D0B3ACAEE32F2AB9B321317AD23059D045EBAB91C5D93",
       "82FCF93AE4467EB57766F2B150E736636727E7282500CD482DA70D153D195F2B"
       "DF9B96D689A0DC1BB9137B41557A33F202F1B71840544CBEFF03072E77E4BB6F0B"
     }, {
       "NIST P-521", 1,
       "018E48E80594FF5496D8CC7DF8A19D6AA18805A4EF4490038AED6A1E9AA18056"
       "D0244A97DCF6D132C6804E3F4F369922119544B4C057D783C848FB798B48730A382C",
       "01AF510B4F5E1C40BC9C110216D35E7C6D7A2BEE52914FC98258676288449901"
       "F27A07EE91DF2D5D79259712906C3E18A990CBF35BCAC41A952820CE2BA8D0220080"
     }, {
       "NIST P-521", 1,
       "ADCEF3539B4BC831DC0AFD173137A4426152058AFBAE06A17FCB89F4DB6E48B5"
       "335CB88F8E4DB475A1E390E5656072F06605BFB84CBF9795B7992ECA04A8E10CA1",
       "01BCB985AFD6404B9EDA49B6190AAA346BF7D5909CA440C0F7E505C62FAC8635"
       "31D3EB7B2AC4DD4F4404E4B12E9D6D3C596179587F3724B1EFFF684CFDB4B21826B9"
     }
   };
   gpg_error_t err;
   int tidx;
   const char *lastcurve = NULL;
   gcry_ctx_t ctx = NULL;
   gcry_mpi_t qx = NULL;
   gcry_mpi_t qy = NULL;
   gcry_mpi_point_t Q;
   int oncurve;
 
   wherestr = "point_on_curve";
   for (tidx=0; tidx < DIM (t); tidx++)
     {
       if (!t[tidx].curve)
         {
           if (!lastcurve || !ctx)
             die ("invalid test vectors at idx %d\n", tidx);
         }
       else if (!ctx || !lastcurve || strcmp (t[tidx].curve, lastcurve))
         {
           lastcurve = t[tidx].curve;
           gcry_ctx_release (ctx);
           err = gcry_mpi_ec_new (&ctx, NULL, lastcurve);
           if (err)
             die ("error creating context for curve %s at idx %d: %s\n",
                  lastcurve, tidx, gpg_strerror (err));
 
           info ("checking points on curve %s\n", lastcurve);
         }
 
       gcry_mpi_release (qx);
       gcry_mpi_release (qy);
       qx = hex2mpi (t[tidx].qx);
       qy = hex2mpi (t[tidx].qy);
 
       Q = gcry_mpi_point_set (NULL, qx, qy, GCRYMPI_CONST_ONE);
       if (!Q)
         die ("gcry_mpi_point_set(Q) failed at idx %d\n", tidx);
 
       oncurve = gcry_mpi_ec_curve_point (Q, ctx);
 
       if (t[tidx].oncurve && !oncurve)
         {
           fail ("point expected on curve but not identified as such (i=%d):\n",
                 tidx);
           print_point ("  Q", Q);
         }
       else if (!t[tidx].oncurve && oncurve)
         {
           fail ("point not expected on curve but identified as such (i=%d):\n",
                 tidx);
           print_point ("  Q", Q);
         }
       gcry_mpi_point_release (Q);
     }
 
   gcry_mpi_release (qx);
   gcry_mpi_release (qy);
   gcry_ctx_release (ctx);
 }
 
 
 int
 main (int argc, char **argv)
 {
 
   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     verbose = 1;
   else if (argc > 1 && !strcmp (argv[1], "--debug"))
     verbose = debug = 1;
 
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   set_get_point ();
   context_alloc ();
   context_param ();
   basic_ec_math ();
   point_on_curve ();
 
   /* The tests are for P-192 and ed25519 which are not supported in
      FIPS mode.  */
   if (!gcry_fips_mode_active())
     {
       basic_ec_math_simplified ();
       twistededwards_math ();
     }
 
   info ("All tests completed. Errors: %d\n", error_count);
   return error_count ? 1 : 0;
 }
diff --git a/tests/t-secmem.c b/tests/t-secmem.c
index baf013d3..c4d8c66d 100644
--- a/tests/t-secmem.c
+++ b/tests/t-secmem.c
@@ -1,201 +1,201 @@
 /* t-secmem.c - Test the secmem memory allocator
  * Copyright (C) 2016 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
 
 #define PGM "t-secmem"
 
 #include "t-common.h"
 #include "../src/gcrypt-testapi.h"
 
 
 #define DEFAULT_PAGE_SIZE 4096
 #define MINIMUM_POOL_SIZE 16384
 static size_t pool_size;
 static size_t chunk_size;
 
 static void
 test_secmem (void)
 {
   void *a[28];
   void *b;
   int i;
 
   memset (a, 0, sizeof a);
 
   /* Allocating 28*512=14k should work in the default 16k pool even
    * with extra alignment requirements.  */
   for (i=0; i < DIM(a); i++)
     a[i] = gcry_xmalloc_secure (chunk_size);
 
   /* Allocating another 2k should fail for the default 16k pool.  */
   b = gcry_malloc_secure (chunk_size*4);
   if (b)
     fail ("allocation did not fail as expected\n");
 
   for (i=0; i < DIM(a); i++)
     xfree (a[i]);
   xfree (b);
 }
 
 
 static void
 test_secmem_overflow (void)
 {
   void *a[150];
   int i;
 
   memset (a, 0, sizeof a);
 
   /* Allocating 150*512=75k should require more than one overflow buffer.  */
   for (i=0; i < DIM(a); i++)
     {
       a[i] = gcry_xmalloc_secure (chunk_size);
       if (verbose && !(i %40))
-        xgcry_control (GCRYCTL_DUMP_SECMEM_STATS, 0 , 0);
+        xgcry_control ((GCRYCTL_DUMP_SECMEM_STATS, 0 , 0));
     }
 
   if (debug)
-    xgcry_control (PRIV_CTL_DUMP_SECMEM_STATS, 0 , 0);
+    xgcry_control ((PRIV_CTL_DUMP_SECMEM_STATS, 0 , 0));
   if (verbose)
-    xgcry_control (GCRYCTL_DUMP_SECMEM_STATS, 0 , 0);
+    xgcry_control ((GCRYCTL_DUMP_SECMEM_STATS, 0 , 0));
   for (i=0; i < DIM(a); i++)
     xfree (a[i]);
 }
 
 
 /* This function is called when we ran out of core and there is no way
  * to return that error to the caller (xmalloc or mpi allocation).  */
 static int
 outofcore_handler (void *opaque, size_t req_n, unsigned int flags)
 {
   static int been_here;  /* Used to protect against recursive calls. */
 
   (void)opaque;
 
   /* Protect against a second call.  */
   if (been_here)
     return 0; /* Let libgcrypt call its own fatal error handler.  */
   been_here = 1;
 
   info ("outofcore handler invoked");
-  xgcry_control (PRIV_CTL_DUMP_SECMEM_STATS, 0 , 0);
+  xgcry_control ((PRIV_CTL_DUMP_SECMEM_STATS, 0 , 0));
   fail ("out of core%s while allocating %lu bytes",
        (flags & 1)?" in secure memory":"", (unsigned long)req_n);
 
   die ("stopped");
   /*NOTREACHED*/
   return 0;
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
   long int pgsize_val = -1;
   size_t pgsize;
 
 #if HAVE_MMAP
 # if defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
   pgsize_val = sysconf (_SC_PAGESIZE);
 # elif defined(HAVE_GETPAGESIZE)
   pgsize_val = getpagesize ();
 # endif
 #endif
   pgsize = (pgsize_val > 0)? pgsize_val : DEFAULT_PAGE_SIZE;
 
   pool_size = (MINIMUM_POOL_SIZE + pgsize - 1) & ~(pgsize - 1);
   chunk_size = pool_size / 32;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           fputs ("usage: " PGM " [options]\n"
                  "Options:\n"
                  "  --verbose       print timings etc.\n"
                  "  --debug         flyswatter\n"
                  , stdout);
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose += 2;
           debug++;
           argc--; argv++;
         }
       else if (!strncmp (*argv, "--", 2))
         die ("unknown option '%s'", *argv);
     }
 
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch; pgm=%s, library=%s\n",
          GCRYPT_VERSION, gcry_check_version (NULL));
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
-  xgcry_control (GCRYCTL_INIT_SECMEM, pool_size, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u , 0));
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
+  xgcry_control ((GCRYCTL_INIT_SECMEM, pool_size, 0));
   gcry_set_outofcore_handler (outofcore_handler, NULL);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   /* Libgcrypt prints a warning when the first overflow is allocated;
    * we do not want to see that.  */
   if (!verbose)
-    xgcry_control (GCRYCTL_DISABLE_SECMEM_WARN, 0);
+    xgcry_control ((GCRYCTL_DISABLE_SECMEM_WARN, 0));
 
 
   test_secmem ();
   test_secmem_overflow ();
   /* FIXME: We need to improve the tests, for example by registering
    * our own log handler and comparing the output of
    * PRIV_CTL_DUMP_SECMEM_STATS to expected pattern.  */
 
   if (verbose)
     {
-      xgcry_control (PRIV_CTL_DUMP_SECMEM_STATS, 0 , 0);
-      xgcry_control (GCRYCTL_DUMP_SECMEM_STATS, 0 , 0);
+      xgcry_control ((PRIV_CTL_DUMP_SECMEM_STATS, 0 , 0));
+      xgcry_control ((GCRYCTL_DUMP_SECMEM_STATS, 0 , 0));
     }
 
   info ("All tests completed.  Errors: %d\n", error_count);
-  xgcry_control (GCRYCTL_TERM_SECMEM, 0 , 0);
+  xgcry_control ((GCRYCTL_TERM_SECMEM, 0 , 0));
   return !!error_count;
 }
diff --git a/tests/t-sexp.c b/tests/t-sexp.c
index 2b33520f..d45f44ae 100644
--- a/tests/t-sexp.c
+++ b/tests/t-sexp.c
@@ -1,1192 +1,1192 @@
 /* t-sexp.c  -  S-expression regression tests
  * Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
  * Copyright (C) 2014 g10 Code GmbH
  *
  * This file is part of Libgcrypt.
  *
  * Libgcrypt is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * Libgcrypt is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <assert.h>
 #include "../src/gcrypt-int.h"
 
 #define PGM "t-sexp"
 #include "t-common.h"
 
 
 /* Convert STRING consisting of hex characters into its binary
    representation and return it as an allocated buffer. The valid
    length of the buffer is returned at R_LENGTH.  The string is
    delimited by end of string.  The function returns NULL on
    error.  */
 static void *
 hex2buffer (const char *string, size_t *r_length)
 {
   const char *s;
   unsigned char *buffer;
   size_t length;
 
   buffer = xmalloc (strlen(string)/2+1);
   length = 0;
   for (s=string; *s; s +=2 )
     {
       if (!hexdigitp (s) || !hexdigitp (s+1))
         return NULL;           /* Invalid hex digits. */
       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     }
   *r_length = length;
   return buffer;
 }
 
 
 static gcry_mpi_t
 hex2mpi (const char *string)
 {
   gpg_error_t err;
   gcry_mpi_t val;
 
   err = gcry_mpi_scan (&val, GCRYMPI_FMT_HEX, string, 0, NULL);
   if (err)
     die ("hex2mpi '%s' failed: %s\n", string, gpg_strerror (err));
   return val;
 }
 
 static gcry_mpi_t
 hex2mpiopa (const char *string)
 {
   char *buffer;
   size_t buflen;
   gcry_mpi_t val;
 
   buffer = hex2buffer (string, &buflen);
   if (!buffer)
     die ("hex2mpiopa '%s' failed: parser error\n", string);
   val = gcry_mpi_set_opaque (NULL, buffer, buflen*8);
   if (!buffer)
     die ("hex2mpiopa '%s' failed: set_opaque error\n", string);
   return val;
 }
 
 
 /* Compare A to B, where B is given as a hex string.  */
 static int
 cmp_mpihex (gcry_mpi_t a, const char *b)
 {
   gcry_mpi_t bval;
   int res;
 
   if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
     bval = hex2mpiopa (b);
   else
     bval = hex2mpi (b);
   res = gcry_mpi_cmp (a, bval);
   gcry_mpi_release (bval);
   return res;
 }
 
 /* Compare A to B, where A is a buffer and B a hex string.  */
 static int
 cmp_bufhex (const void *a, size_t alen, const char *b)
 {
   void *bbuf;
   size_t blen;
   int res;
 
   if (!a && !b)
     return 0;
   if (a && !b)
     return 1;
   if (!a && b)
     return -1;
 
   bbuf = hex2buffer (b, &blen);
   if (!bbuf)
     die ("cmp_bufhex: error converting hex string\n");
   if (alen != blen)
     return alen < blen? -1 : 1;
   res = memcmp (a, bbuf, alen);
   xfree (bbuf);
   return res;
 }
 
 
 
 /* fixme: we need better tests */
 static void
 basic (void)
 {
   int pass;
   gcry_sexp_t sexp;
   int idx;
   char *secure_buffer;
   size_t secure_buffer_len;
   const char *string;
   static struct {
     const char *token;
     const char *parm;
   } values[] = {
     { "public-key", NULL },
     { "dsa", NULL },
     { "dsa", "p" },
     { "dsa", "y" },
     { "dsa", "q" },
     { "dsa", "g" },
     { NULL }
   };
 
   info ("doing some pretty pointless tests\n");
 
   secure_buffer_len = 99;
   secure_buffer = gcry_xmalloc_secure (secure_buffer_len);
   memset (secure_buffer, 'G', secure_buffer_len);
 
   for (pass=0;;pass++)
     {
       gcry_mpi_t m;
 
       switch (pass)
         {
         case 0:
           string = ("(public-key (dsa (p #41424344#) (y this_is_y) "
                     "(q #61626364656667#) (g %m)))");
 
           m = gcry_mpi_set_ui (NULL, 42);
           if ( gcry_sexp_build (&sexp, NULL, string, m ) )
             {
               gcry_mpi_release (m);
               fail (" scanning `%s' failed\n", string);
               return;
             }
           gcry_mpi_release (m);
           break;
 
         case 1:
           string = ("(public-key (dsa (p #41424344#) (y this_is_y) "
                     "(q %b) (g %m)))");
 
           m = gcry_mpi_set_ui (NULL, 42);
           if ( gcry_sexp_build (&sexp, NULL, string,
                                 15, "foo\0\x01\0x02789012345", m) )
             {
               gcry_mpi_release (m);
               fail (" scanning `%s' failed\n", string);
               return;
             }
           gcry_mpi_release (m);
           break;
 
         case 2:
           string = ("(public-key (dsa (p #41424344#) (y silly_y_value) "
                     "(q %b) (g %m)))");
 
           m = gcry_mpi_set_ui (NULL, 17);
           if ( gcry_sexp_build (&sexp, NULL, string,
                                 secure_buffer_len, secure_buffer, m) )
             {
               gcry_mpi_release (m);
               fail (" scanning `%s' failed\n", string);
               return;
             }
           gcry_mpi_release (m);
           if (!gcry_is_secure (sexp))
             fail ("gcry_sexp_build did not switch to secure memory\n");
           break;
 
         case 3:
           {
             gcry_sexp_t help_sexp;
 
             if (gcry_sexp_new (&help_sexp,
                                "(foobar-parms (xp #1234#)(xq #03#))", 0, 1))
               {
                 fail (" scanning fixed string failed\n");
                 return;
               }
 
             string = ("(public-key (dsa (p #41424344#) (parm %S) "
                       "(y dummy)(q %b) (g %m)))");
             m = gcry_mpi_set_ui (NULL, 17);
             if ( gcry_sexp_build (&sexp, NULL, string, help_sexp,
                                   secure_buffer_len, secure_buffer, m) )
               {
                 gcry_mpi_release (m);
                 fail (" scanning `%s' failed\n", string);
                 return;
               }
             gcry_mpi_release (m);
             gcry_sexp_release (help_sexp);
           }
           break;
 
 
         default:
           return; /* Ready. */
         }
 
 
       /* now find something */
       for (idx=0; values[idx].token; idx++)
         {
           const char *token = values[idx].token;
           const char *parm = values[idx].parm;
           gcry_sexp_t s1, s2;
           gcry_mpi_t a;
           const char *p;
           size_t n;
 
           s1 = gcry_sexp_find_token (sexp, token, strlen(token) );
           if (!s1)
             {
               fail ("didn't found `%s'\n", token);
               continue;
             }
 
           p = gcry_sexp_nth_data (s1, 0, &n);
           if (!p)
             {
               gcry_sexp_release (s1);
               fail ("no car for `%s'\n", token);
               continue;
             }
           /* info ("car=`%.*s'\n", (int)n, p); */
 
           s2 = gcry_sexp_cdr (s1);
           if (!s2)
             {
               gcry_sexp_release (s1);
               fail ("no cdr for `%s'\n", token);
               continue;
             }
 
           p = gcry_sexp_nth_data (s2, 0, &n);
           gcry_sexp_release (s2);
           if (p)
             {
               gcry_sexp_release (s1);
               fail ("data at car of `%s'\n", token);
               continue;
             }
 
           if (parm)
             {
               s2 = gcry_sexp_find_token (s1, parm, strlen (parm));
               gcry_sexp_release (s1);
               if (!s2)
                 {
                   fail ("didn't found `%s'\n", parm);
                   continue;
                 }
               p = gcry_sexp_nth_data (s2, 0, &n);
               if (!p)
                 {
                   gcry_sexp_release (s2);
                   fail("no car for `%s'\n", parm );
                   continue;
                 }
               /* info ("car=`%.*s'\n", (int)n, p); */
               p = gcry_sexp_nth_data (s2, 1, &n);
               if (!p)
                 {
                   gcry_sexp_release (s2);
                   fail("no cdr for `%s'\n", parm );
                   continue;
                 }
               /* info ("cdr=`%.*s'\n", (int)n, p); */
 
               a = gcry_sexp_nth_mpi (s2, 0, GCRYMPI_FMT_USG);
               gcry_sexp_release (s2);
               if (!a)
                 {
                   fail("failed to cdr the mpi for `%s'\n", parm);
                   continue;
                 }
               gcry_mpi_release (a);
             }
           else
             gcry_sexp_release (s1);
         }
 
       gcry_sexp_release (sexp);
       sexp = NULL;
     }
   gcry_free (secure_buffer);
 }
 
 
 static void
 canon_len (void)
 {
   static struct {
     size_t textlen; /* length of the buffer */
     size_t expected;/* expected length or 0 on error and then ... */
     size_t erroff;  /* ... and at this offset */
     gcry_error_t errcode;    /* ... with this error code */
     const char *text;
   } values[] = {
     { 14, 13, 0, GPG_ERR_NO_ERROR, "(9:abcdefghi) " },
     { 16, 15, 0, GPG_ERR_NO_ERROR, "(10:abcdefghix)" },
     { 14,  0,14, GPG_ERR_SEXP_STRING_TOO_LONG, "(10:abcdefghi)" },
     { 15,  0, 1, GPG_ERR_SEXP_ZERO_PREFIX, "(010:abcdefghi)" },
     {  2,  0, 0, GPG_ERR_SEXP_NOT_CANONICAL, "1:"},
     {  4,  0, 4, GPG_ERR_SEXP_STRING_TOO_LONG, "(1:)"},
     {  5,  5, 0, GPG_ERR_NO_ERROR, "(1:x)"},
     {  2,  2, 0, GPG_ERR_NO_ERROR, "()"},
     {  4,  2, 0, GPG_ERR_NO_ERROR, "()()"},
     {  4,  4, 0, GPG_ERR_NO_ERROR, "(())"},
     {  3,  0, 3, GPG_ERR_SEXP_STRING_TOO_LONG, "(()"},
     {  3,  0, 1, GPG_ERR_SEXP_BAD_CHARACTER, "( )"},
     {  9,  9, 0, GPG_ERR_NO_ERROR, "(3:abc())"},
     { 10,  0, 6, GPG_ERR_SEXP_BAD_CHARACTER, "(3:abc ())"},
     /* fixme: we need much more cases */
     { 0 },
   };
   int idx;
   gcry_error_t errcode;
   size_t n, erroff;
 
   info ("checking canoncial length test function\n");
   for (idx=0; values[idx].text; idx++)
     {
       n = gcry_sexp_canon_len ((const unsigned char*)values[idx].text,
                                values[idx].textlen,
                                &erroff, &errcode);
 
       if (n && n == values[idx].expected)
         ; /* success */
       else if (!n && !values[idx].expected)
         { /* we expected an error - check that this is the right one */
           if (values[idx].erroff != erroff)
             fail ("canonical length test %d - wrong error offset %u\n",
                   idx, (unsigned int)erroff);
           if (gcry_err_code (errcode) != values[idx].errcode)
             fail ("canonical length test %d - wrong error code %d\n",
                   idx, errcode);
         }
       else
         fail ("canonical length test %d failed - n=%u, off=%u, err=%d\n",
               idx, (unsigned int)n, (unsigned int)erroff, errcode);
     }
 }
 
 
 /* Compare SE to the canonical formatted expression in
  * (CANON,CANONLEN).  This is done by a converting SE to canonical
  * format and doing a byte compare.  Returns 0 if they match.  */
 static int
 compare_to_canon (gcry_sexp_t se, const unsigned char *canon, size_t canonlen)
 {
   size_t n, n1;
   char *p1;
 
   n1 = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, NULL, 0);
   if (!n1)
     {
       fail ("get required length in compare_to_canon failed\n");
       return -1;
     }
   p1 = gcry_xmalloc (n1);
   n = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, p1, n1);
   if (n1 != n+1)
     {
       fail ("length mismatch in compare_to_canon detected\n");
       xfree (p1);
       return -1;
     }
   if (n1 != canonlen || memcmp (p1, canon, canonlen))
     {
       xfree (p1);
       return -1;
     }
   xfree (p1);
   return 0;
 }
 
 
 static void
 back_and_forth_one (int testno, const char *buffer, size_t length)
 {
   gcry_error_t rc;
   gcry_sexp_t se, se1;
   unsigned char *canon;
   size_t canonlen;  /* Including the hidden nul suffix.  */
   size_t n, n1;
   char *p1;
 
   rc = gcry_sexp_new (&se, buffer, length, 1);
   if (rc)
     {
       fail ("baf %d: gcry_sexp_new failed: %s\n", testno, gpg_strerror (rc));
       return;
     }
   n1 = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, NULL, 0);
   if (!n1)
     {
       fail ("baf %d: get required length for canon failed\n", testno);
       return;
     }
   p1 = gcry_xmalloc (n1);
   n = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, p1, n1);
   if (n1 != n+1) /* sprints adds an extra 0 but does not return it. */
     {
       fail ("baf %d: length mismatch for canon\n", testno);
       return;
     }
   canonlen = n1;
   canon = gcry_malloc (canonlen);
   memcpy (canon, p1, canonlen);
   rc = gcry_sexp_create (&se1, p1, n, 0, gcry_free);
   if (rc)
     {
       fail ("baf %d: gcry_sexp_create failed: %s\n",
             testno, gpg_strerror (rc));
       return;
     }
   gcry_sexp_release (se1);
 
   /* Again but with memory checking. */
   p1 = gcry_xmalloc (n1+2);
   *p1 = '\x55';
   p1[n1+1] = '\xaa';
   n = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, p1+1, n1);
   if (n1 != n+1) /* sprints adds an extra 0 but does not return it */
     {
       fail ("baf %d: length mismatch for canon\n", testno);
       return;
     }
   if (*p1 != '\x55' || p1[n1+1] != '\xaa')
     fail ("baf %d: memory corrupted (1)\n", testno);
   rc = gcry_sexp_create (&se1, p1+1, n, 0, NULL);
   if (rc)
     {
       fail ("baf %d: gcry_sexp_create failed: %s\n",
             testno, gpg_strerror (rc));
       return;
     }
   if (*p1 != '\x55' || p1[n1+1] != '\xaa')
     fail ("baf %d: memory corrupted (2)\n", testno);
   gcry_sexp_release (se1);
   if (*p1 != '\x55' || p1[n1+1] != '\xaa')
     fail ("baf %d: memory corrupted (3)\n", testno);
   gcry_free (p1);
 
   /* Check converting to advanced format.  */
   n1 = gcry_sexp_sprint (se, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   if (!n1)
     {
       fail ("baf %d: get required length for advanced failed\n", testno);
       return;
     }
   p1 = gcry_xmalloc (n1);
   n = gcry_sexp_sprint (se, GCRYSEXP_FMT_ADVANCED, p1, n1);
   if (n1 != n+1) /* sprints adds an extra 0 but does not return it */
     {
       fail ("baf %d: length mismatch for advanced\n", testno);
       return;
     }
   rc = gcry_sexp_create (&se1, p1, n, 0, gcry_free);
   if (rc)
     {
       fail ("baf %d: gcry_sexp_create failed: %s\n",
             testno, gpg_strerror (rc));
       return;
     }
   if (compare_to_canon (se1, canon, canonlen))
     {
       fail ("baf %d: converting to advanced failed: %s\n",
             testno, gpg_strerror (rc));
       return;
     }
   gcry_sexp_release (se1);
 
 
   /* FIXME: we need a lot more tests */
 
   gcry_sexp_release (se);
   xfree (canon);
 }
 
 
 
 static void
 back_and_forth (void)
 {
   static struct { const char *buf; int len; } tests[] = {
     { "(7:g34:fgh1::2:())", 0 },
     { "(7:g34:fgh1::2:())", 18 },
     {
 "(protected-private-key \n"
 " (rsa \n"
 "  (n #00BE8A536204687149A48FF9F1715FF3530AD9A836D62102BF4065E5CF5953236DB94F1DF2FF4D525CD4CE7966DDC3C839968E8BAC2948934DF047CC65287CD79F6C23C93E55D7F9231E3942BD496DE383469977635A51ADF4AF747DB958CA02E9940DFC1DC0FC7FC755E7EB6618FEE6DA54B8A06E0CBF9D9257443F9992261435#)\n"
 "  (e #010001#)\n"
 "  (protected openpgp-s2k3-sha1-aes-cbc \n"
 "   (\n"
 "    (sha1 #C2A5673BD3882405# \"96\")\n"
 "    #8D08AAF6A9209ED69D71EB7E64D78715#)\n"
 "   #F7B0B535F8F8E22F4F3DA031224070303F82F9207D42952F1ACF21A4AB1C50304EBB25527992C7B265A9E9FF702826FB88759BDD55E4759E9FCA6C879538C9D043A9C60A326CB6681090BAA731289BD880A7D5774D9999F026E5E7963BFC8C0BDC9F061393CB734B4F259725C0A0A0B15BA39C39146EF6A1B3DC4DF30A22EBE09FD05AE6CB0C8C6532951A925F354F4E26A51964F5BBA50081690C421C8385C4074E9BAB9297D081B857756607EAE652415275A741C89E815558A50AC638EDC5F5030210B4395E3E1A40FF38DCCCB333A19EA88EFE7E4D51B54128C6DF27395646836679AC21B1B25C1DA6F0A7CE9F9BE078EFC7934FA9AE202CBB0AA06C20DFAF9A66FAB7E9073FBE96B9A7F25C3BA45EC3EECA65796AEE313BA148DE5314F30345B452B50B17C4D841A7F27397126E8C10BD0CE3B50A82C0425AAEE7798031671407B681F52916256F78CAF92A477AC27BCBE26DAFD1BCE386A853E2A036F8314BB2E8E5BB1F196434232EFB0288331C2AB16DBC5457CC295EB966CAC5CE73D5DA5D566E469F0EFA82F9A12B8693E0#)\n"
 "  )\n"
 " )\n", 0 },
     { "((sha1 #8B98CBF4A9823CA7# \"2097\") #3B6FC9#)", 0 },
     { "((4:sha18:\x8B\x98\xCB\xF4\xA9\x82\x3C\xA7""4:2097)3:\x3B\x6F\xC9)", 0},
     { "((4:sha18:\x8B\x98\xCB\x22\xA9\x82\x3C\xA7""4:2097)3:\x3B\x6F\xC9)", 0},
     { "((sha1 #64652267686970C9# \"2097\") #3B6FC9#)", 0 },
     { "((4:sha18:\x64\x65\x22\x67\x68\xc3\xa4\x71""4:2097)3:\x3B\x6F\xC9)", 0},
     { "((sha1 \"defghäq\" \"2097\") #3B6FC9#)", 0 },
     { "((sha1 \"de\\\"ghäq\" \"2097\") #3B6FC9#)", 0 },
     { NULL, 0 }
   };
   int idx;
 
   for (idx=0; tests[idx].buf; idx++)
     back_and_forth_one (idx, tests[idx].buf, tests[idx].len);
 }
 
 
 static void
 check_sscan (void)
 {
   static struct {
     const char *text;
     gcry_error_t expected_err;
   } values[] = {
     /* Bug reported by Olivier L'Heureux 2003-10-07 */
     { "(7:sig-val(3:dsa"
       "(1:r20:\x7e\xff\xd5\xba\xc9\xc9\xa4\x9b\xd4\x26\x8b\x64"
       "\x06\x7a\xcf\x42\x7b\x6c\x51\xfb)"
       "(1:s21:\x01\x8c\x6c\x6f\x37\x1a\x8d\xfd\x5a\xb3\x2a\x3d"
       "\xc5\xae\x23\xed\x32\x62\x30\x62\x3e)))",
       GPG_ERR_NO_ERROR },
     { "(7:sig-val(3:dsa"
       "(1:r20:\x7e\xff\xd5\xba\xc9\xc9\xa4\x9b\xd4\x26\x8b\x64"
       "\x06\x7a\xcf\x42\x7b\x6c\x51\xfb)"
       "(1:s21:\x01\x8c\x6c\x6f\x37\x1a\x8d\xfd\x5a\xb3\x2a\x3d"
       "\xc5\xae\x23\xed\x32\x62\x30\x62\x3e))",
       GPG_ERR_SEXP_UNMATCHED_PAREN },
     { "(7:sig-val(3:dsa"
       "(1:r20:\x7e\xff\xd5\xba\xc9\xc9\xa4\x9b\xd4\x26\x8b\x64"
       "\x06\x7a\xcf\x42\x7b\x6c\x51\xfb)"
       "(1:s21:\x01\x8c\x6c\x6f\x37\x1a\x8d\xfd\x5a\xb3\x2a\x3d"
       "\xc5\xae\x23\xed\x32\x62\x30\x62\x3e))))",
       GPG_ERR_SEXP_UNMATCHED_PAREN },
     { NULL, 0 }
   };
   int idx;
   gcry_error_t err;
   gcry_sexp_t s;
 
   info ("checking gcry_sexp_sscan\n");
   for (idx=0; values[idx].text; idx++)
     {
       err = gcry_sexp_sscan (&s, NULL,
                              values[idx].text,
                              strlen (values[idx].text));
       if (gpg_err_code (err) != values[idx].expected_err)
         fail ("gcry_sexp_sscan test %d failed: %s\n", idx, gpg_strerror (err));
       gcry_sexp_release (s);
     }
 }
 
 
 static void
 check_extract_param (void)
 {
   /* This sample data is a real key but with some parameters of the
      public key modified.  */
   static char sample1[] =
     "(key-data"
     " (public-key"
     "  (ecc"
     "   (curve Ed25519)"
     "   (p #6FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED#)"
     "   (a #EF#)"
     "   (b #C2036CEE2B6FFE738CC740797779E89800700A4D4141D8AB75EB4DCA135978B6#)"
     "   (g #14"
     "       216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A"
     "       6666666666666666666666666666666666666666666666666666666666666658#)"
     "   (n #0000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED#)"
     "   (q #20B37806015CA06B3AEB9423EE84A41D7F31AA65F4148553755206D679F8BF62#)"
     "))"
     " (private-key"
     "  (ecc"
     "   (curve Ed25519)"
     "   (p #7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED#)"
     "   (a #FF#)"
     "   (b #D2036CEE2B6FFE738CC740797779E89800700A4D4141D8AB75EB4DCA135978B6#)"
     "   (g #04"
     "       216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A"
     "       6666666666666666666666666666666666666666666666666666666666666658#)"
     "   (n #1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED#)"
     "   (q #30B37806015CA06B3AEB9423EE84A41D7F31AA65F4148553755206D679F8BF62#)"
     "   (d #56BEA284A22F443A7AEA8CEFA24DA5055CDF1D490C94D8C568FE0802C9169276#)"
     ")))";
 
   static char sample1_p[] =
     "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED";
   static char sample1_px[] =
     "6FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED";
   static char sample1_a[] = "FF";
   static char sample1_ax[] = "EF";
   static char sample1_b[] =
     "D2036CEE2B6FFE738CC740797779E89800700A4D4141D8AB75EB4DCA135978B6";
   static char sample1_bx[] =
     "C2036CEE2B6FFE738CC740797779E89800700A4D4141D8AB75EB4DCA135978B6";
   static char sample1_g[] =
     "04"
     "216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A"
     "6666666666666666666666666666666666666666666666666666666666666658";
   static char sample1_gx[] =
     "14"
     "216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A"
     "6666666666666666666666666666666666666666666666666666666666666658";
   static char sample1_n[] =
     "1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED";
   static char sample1_nx[] =
     "0000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED";
   static char sample1_q[] =
     "30B37806015CA06B3AEB9423EE84A41D7F31AA65F4148553755206D679F8BF62";
   static char sample1_qx[] =
     "20B37806015CA06B3AEB9423EE84A41D7F31AA65F4148553755206D679F8BF62";
   static char sample1_d[] =
     "56BEA284A22F443A7AEA8CEFA24DA5055CDF1D490C94D8C568FE0802C9169276";
 
   static struct {
     const char *sexp_str;
     const char *path;
     const char *list;
     int nparam;
     gpg_err_code_t expected_err;
     const char *exp_p;
     const char *exp_a;
     const char *exp_b;
     const char *exp_g;
     const char *exp_n;
     const char *exp_q;
     const char *exp_d;
   } tests[] = {
     {
       sample1,
       NULL,
       "pabgnqd", 6,
       GPG_ERR_MISSING_VALUE,
     },
     {
       sample1,
       NULL,
       "pabgnq", 7,
       GPG_ERR_INV_ARG
     },
     {
       sample1,
       NULL,
       "pab'gnq", 7,
       GPG_ERR_SYNTAX
     },
     {
       sample1,
       NULL,
       "pab''gnq", 7,
       GPG_ERR_SYNTAX
     },
     {
       sample1,
       NULL,
       "pabgnqd", 7,
       0,
       sample1_px, sample1_ax, sample1_bx, sample1_gx, sample1_nx,
       sample1_qx, sample1_d
     },
     {
       sample1,
       NULL,
       "  pab\tg nq\nd  ", 7,
       0,
       sample1_px, sample1_ax, sample1_bx, sample1_gx, sample1_nx,
       sample1_qx, sample1_d
     },
     {
       sample1,
       NULL,
       "abg", 3,
       0,
       sample1_ax, sample1_bx, sample1_gx
     },
     {
       sample1,
       NULL,
       "ab'g'", 3,
       0,
       sample1_ax, sample1_bx, sample1_gx
     },
     {
       sample1,
       NULL,
       "x?abg", 4,
       0,
       NULL, sample1_ax, sample1_bx, sample1_gx
     },
     {
       sample1,
       NULL,
       "p?abg", 4,
       GPG_ERR_USER_1,
       NULL, sample1_ax, sample1_bx, sample1_gx
     },
     {
       sample1,
       NULL,
       "pax?gnqd", 7,
       0,
       sample1_px, sample1_ax, NULL, sample1_gx, sample1_nx,
       sample1_qx, sample1_d
     },
     {
       sample1,
       "public-key",
       "pabgnqd", 7,
       GPG_ERR_NO_OBJ,  /* d is not in public key.  */
       sample1_px, sample1_ax, sample1_bx, sample1_gx, sample1_nx,
       sample1_qx, sample1_d
     },
     {
       sample1,
       "private-key",
       "pabgnqd", 7,
       0,
       sample1_p, sample1_a, sample1_b, sample1_g, sample1_n,
       sample1_q, sample1_d
     },
     {
       sample1,
       "public-key!ecc",
       "pabgnq", 6,
       0,
       sample1_px, sample1_ax, sample1_bx, sample1_gx, sample1_nx,
       sample1_qx
     },
     {
       sample1,
       "public-key!ecc!foo",
       "pabgnq", 6,
       GPG_ERR_NOT_FOUND
     },
     {
       sample1,
       "public-key!!ecc",
       "pabgnq", 6,
       GPG_ERR_NOT_FOUND
     },
     {
       sample1,
       "private-key",
       "pa/bgnqd", 7,
       0,
       sample1_p, sample1_a, sample1_b, sample1_g, sample1_n,
       sample1_q, sample1_d
     },
     {
       sample1,
       "private-key",
       "p-a+bgnqd", 7,
       0,
       sample1_p, "-01", sample1_b, sample1_g, sample1_n,
       sample1_q, sample1_d
     },
     {NULL}
   };
   int idx, i;
   const char *paramstr;
   int paramidx;
   gpg_error_t err;
   gcry_sexp_t sxp;
   gcry_mpi_t mpis[7];
   gcry_buffer_t ioarray[7];
   char iobuffer[200];
 
   info ("checking gcry_sexp_extract_param\n");
   for (idx=0; tests[idx].sexp_str; idx++)
     {
       err = gcry_sexp_new (&sxp, tests[idx].sexp_str, 0, 1);
       if (err)
         die ("converting string to sexp failed: %s", gpg_strerror (err));
 
       memset (mpis, 0, sizeof mpis);
       switch (tests[idx].nparam)
         {
         case 0:
           err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
                                          NULL);
           break;
         case 1:
           err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
                                          mpis+0, NULL);
           break;
         case 2:
           err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
                                          mpis+0, mpis+1, NULL);
           break;
         case 3:
           err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
                                          mpis+0, mpis+1, mpis+2, NULL);
           break;
         case 4:
           err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
                                          mpis+0, mpis+1, mpis+2, mpis+3, NULL);
           break;
         case 5:
           err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
                                          mpis+0, mpis+1, mpis+2, mpis+3, mpis+4,
                                          NULL);
           break;
         case 6:
           err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
                                          mpis+0, mpis+1, mpis+2, mpis+3, mpis+4,
                                          mpis+5, NULL);
           break;
         case 7:
           err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
                                          mpis+0, mpis+1, mpis+2, mpis+3, mpis+4,
                                          mpis+5, mpis+6, NULL);
           break;
         default:
           die ("test %d: internal error", idx);
         }
 
       if (tests[idx].expected_err
           && tests[idx].expected_err != GPG_ERR_USER_1)
         {
           if (tests[idx].expected_err != gpg_err_code (err))
             fail ("gcry_sexp_extract_param test %d failed: "
                   "expected error '%s' - got '%s'", idx,
                   gpg_strerror (tests[idx].expected_err),gpg_strerror (err));
 
         }
       else if (err)
         {
           fail ("gcry_sexp_extract_param test %d failed: %s",
                 idx, gpg_strerror (err));
         }
       else /* No error - check the extracted values.  */
         {
           for (paramidx=0; paramidx < DIM (mpis); paramidx++)
             {
               switch (paramidx)
                 {
                 case 0: paramstr = tests[idx].exp_p; break;
                 case 1: paramstr = tests[idx].exp_a; break;
                 case 2: paramstr = tests[idx].exp_b; break;
                 case 3: paramstr = tests[idx].exp_g; break;
                 case 4: paramstr = tests[idx].exp_n; break;
                 case 5: paramstr = tests[idx].exp_q; break;
                 case 6: paramstr = tests[idx].exp_d; break;
                 default:
                   die ("test %d: internal error: bad param %d",
                        idx, paramidx);
                 }
 
               if (tests[idx].expected_err == GPG_ERR_USER_1
                   && mpis[paramidx] && !paramstr && paramidx == 0)
                 ; /* Okay  Special case error for param 0.  */
               else if (!mpis[paramidx] && !paramstr)
                 ; /* Okay.  */
               else if (!mpis[paramidx] && paramstr)
                 fail ("test %d: value for param %d expected but not returned",
                       idx, paramidx);
               else if (mpis[paramidx] && !paramstr)
                 fail ("test %d: value for param %d not expected",
                       idx, paramidx);
               else if (cmp_mpihex (mpis[paramidx], paramstr))
                 {
                   fail ("test %d: param %d mismatch", idx, paramidx);
                   gcry_log_debug    ("expected: %s\n", paramstr);
                   gcry_log_debugmpi ("     got", mpis[paramidx]);
                 }
               else if (tests[idx].expected_err && paramidx == 0)
                 fail ("test %d: param %d: expected error '%s' - got 'Success'",
                       idx, paramidx, gpg_strerror (tests[idx].expected_err));
             }
 
         }
 
       for (i=0; i < DIM (mpis); i++)
         gcry_mpi_release (mpis[i]);
       gcry_sexp_release (sxp);
     }
 
   info ("checking gcry_sexp_extract_param/desc\n");
 
   memset (ioarray, 0, sizeof ioarray);
 
   err = gcry_sexp_new (&sxp, sample1, 0, 1);
   if (err)
     die ("converting string to sexp failed: %s", gpg_strerror (err));
 
   ioarray[1].size = sizeof iobuffer;
   ioarray[1].data = iobuffer;
   ioarray[1].off  = 0;
   ioarray[2].size = sizeof iobuffer;
   ioarray[2].data = iobuffer;
   ioarray[2].off  = 50;
   assert (ioarray[2].off < sizeof iobuffer);
   err = gcry_sexp_extract_param (sxp, "key-data!private-key", "&pab",
                                  ioarray+0, ioarray+1, ioarray+2, NULL);
   if (err)
     fail ("gcry_sexp_extract_param with desc failed: %s", gpg_strerror (err));
   else
     {
       if (!ioarray[0].data)
         fail ("gcry_sexp_extract_param/desc failed: no P");
       else if (ioarray[0].size != 32)
         fail ("gcry_sexp_extract_param/desc failed: P has wrong size");
       else if (ioarray[0].len != 32)
         fail ("gcry_sexp_extract_param/desc failed: P has wrong length");
       else if (ioarray[0].off)
         fail ("gcry_sexp_extract_param/desc failed: P has OFF set");
       else if (cmp_bufhex (ioarray[0].data, ioarray[0].len, sample1_p))
         {
           fail ("gcry_sexp_extract_param/desc failed: P mismatch");
           gcry_log_debug    ("expected: %s\n", sample1_p);
           gcry_log_debughex ("     got", ioarray[0].data, ioarray[0].len);
         }
 
       if (!ioarray[1].data)
         fail ("gcry_sexp_extract_param/desc failed: A buffer lost");
       else if (ioarray[1].size != sizeof iobuffer)
         fail ("gcry_sexp_extract_param/desc failed: A size changed");
       else if (ioarray[1].off != 0)
         fail ("gcry_sexp_extract_param/desc failed: A off changed");
       else if (ioarray[1].len != 1)
         fail ("gcry_sexp_extract_param/desc failed: A has wrong length");
       else if (cmp_bufhex ((char *)ioarray[1].data + ioarray[1].off,
                            ioarray[1].len, sample1_a))
         {
           fail ("gcry_sexp_extract_param/desc failed: A mismatch");
           gcry_log_debug    ("expected: %s\n", sample1_a);
           gcry_log_debughex ("     got",
                              (char *)ioarray[1].data + ioarray[1].off,
                              ioarray[1].len);
         }
 
       if (!ioarray[2].data)
         fail ("gcry_sexp_extract_param/desc failed: B buffer lost");
       else if (ioarray[2].size != sizeof iobuffer)
         fail ("gcry_sexp_extract_param/desc failed: B size changed");
       else if (ioarray[2].off != 50)
         fail ("gcry_sexp_extract_param/desc failed: B off changed");
       else if (ioarray[2].len != 32)
         fail ("gcry_sexp_extract_param/desc failed: B has wrong length");
       else if (cmp_bufhex ((char *)ioarray[2].data + ioarray[2].off,
                            ioarray[2].len, sample1_b))
         {
           fail ("gcry_sexp_extract_param/desc failed: B mismatch");
           gcry_log_debug    ("expected: %s\n", sample1_b);
           gcry_log_debughex ("     got",
                              (char *)ioarray[2].data + ioarray[2].off,
                              ioarray[2].len);
         }
 
       xfree (ioarray[0].data);
     }
 
   gcry_sexp_release (sxp);
 
   info ("checking gcry_sexp_extract_param long name\n");
 
   memset (ioarray, 0, sizeof ioarray);
   memset (mpis, 0, sizeof mpis);
 
   err = gcry_sexp_new (&sxp, sample1, 0, 1);
   if (err)
     die ("converting string to sexp failed: %s", gpg_strerror (err));
 
   err = gcry_sexp_extract_param (sxp, "key-data!private-key",
                                  "&'curve'+p",
                                  ioarray+0, mpis+0, NULL);
   if (err)
     fail ("gcry_sexp_extract_param long name failed: %s", gpg_strerror (err));
 
   if (!ioarray[0].data)
     fail ("gcry_sexp_extract_param long name failed: no curve");
   else if (ioarray[0].size != 7)
     fail ("gcry_sexp_extract_param long name failed: curve has wrong size");
   else if (ioarray[0].len != 7)
     fail ("gcry_sexp_extract_param long name failed: curve has wrong length");
   else if (ioarray[0].off)
     fail ("gcry_sexp_extract_param long name failed: curve has OFF set");
   else if (strncmp (ioarray[0].data, "Ed25519", 7))
     {
       fail ("gcry_sexp_extract_param long name failed: curve mismatch");
       gcry_log_debug ("expected: %s\n", "Ed25519");
       gcry_log_debug ("     got: %.*s\n",
                       (int)ioarray[0].len, (char*)ioarray[0].data);
     }
 
   if (!mpis[0])
     fail ("gcry_sexp_extract_param long name failed: p not returned");
   else if (cmp_mpihex (mpis[0], sample1_p))
     {
       fail ("gcry_sexp_extract_param long name failed: p mismatch");
       gcry_log_debug    ("expected: %s\n", sample1_p);
       gcry_log_debugmpi ("     got", mpis[0]);
     }
 
   gcry_free (ioarray[0].data);
   gcry_mpi_release (mpis[0]);
 
   gcry_sexp_release (sxp);
 
 }
 
 
 /* A test based on bug 1594.  */
 static void
 bug_1594 (void)
 {
 static char thing[] =
   "(signature"
   " (public-key"
   "  (rsa"
   "   (n #00A53A6B3A50BE571F805BD98ECE1FCE4CE291C3D4D3E971740E1EE6D447F526"
   "       6AC8973DDC82F0ADD234CC82E0A0A3F48B81ACC8B038DB8ACC3E78DC2ED2642F"
   "       6BA353FCA60F47C2801DEB477B37FB8B2F5508AA1C6D922780DB142DEA19B812"
   "       C4E64F1138AD3BD61C58DB2D2591BE0BF36A1AC588AA45763BCDFF581050ABA8"
   "       CA47BD9723ADD6A308AE28471EDD2B16D03C941D4F2B7E019C43AF8972880633"
   "       54E97B7E19F1677D84B69A26B184A77B719DD72C48E0EE36107046F786566A9D"
   "       13BAD724D6D78F24700FC22FC000E1B2A8C1B08ED62008395B0764CD9B55E80D"
   "       A0A2B61C698DC27EA98E68BB576ACFC2B91B4D7283E7D960948D049D6E3C4CB1"
   "       F489B460A120A4BB6C04A843FD3A67454136DE61CF68A927871EFFA9141BD372"
   "       A748593C703E0301F039A9E674C50301BFC385BABE5B154250E7D57B82DB31F1"
   "       E1AC696F870DCD8FE8DEC75608B988FCA3B484F1FD7755BF452F99597269AF02"
   "       E8AF87D0F93DB427291659183D077254C835BFB6DDFD87CD0B5E0738682FCD34"
   "       923F22551F73944E6CBE3ED6879B4414676B5DA0F30ED21DFA12BD2230C3C5D2"
   "       EA116A3EFEB4AEC21C58E63FAFA549A63190F01859445E9B80F427B80FD4C884"
   "       2AD41FE760A3E9DEDFB56CEBE8EA783838B2B392CACDDC760CCE212E388AFBC1"
   "       95DC6D0ED87E9091F82A82CE372738C8DE8ABD76ACD06AC8B80AA0597162DF59"
   "       67#)"
   "   (e #010001#))))";
   gcry_sexp_t sig, pubkey, n, n_val;
 
   info ("checking fix for bug 1594\n");
 
   if (gcry_sexp_new (&sig, thing, 0, 1))
     die ("scanning fixed string failed\n");
   pubkey = gcry_sexp_find_token (sig, "public-key", 0);
   gcry_sexp_release (sig);
   if (!pubkey)
     {
       fail ("'public-key' token not found");
       return;
     }
   n = gcry_sexp_find_token (pubkey, "n", 0);
   if (!n)
     {
       fail ("'n' token not found");
       gcry_sexp_release (pubkey);
       return;
     }
   n_val = gcry_sexp_nth (n, 1);
   /* Bug 1594 would require the following test:
    *   if (n_val)
    *     fail ("extracting 1-th of 'n' list did not fail");
    * However, we meanwhile modified the S-expression functions to
    * behave like Scheme to allow the access of any element of a list.
    */
   if (!n_val)
     fail ("extracting 1-th of 'n' list failed");
   /*gcry_log_debugsxp ("1-th", n_val); => "(#00A5...#)"  */
   gcry_sexp_release (n_val);
   n_val = gcry_sexp_nth (n, 2);
   if (n_val)
     fail ("extracting 2-th of 'n' list did not fail");
   n_val = gcry_sexp_nth (n, 0);
   if (!n_val)
     fail ("extracting 0-th of 'n' list failed");
   /*gcry_log_debugsxp ("0-th", n_val); => "(n)"  */
   if (gcry_sexp_nth (n_val, 1))
     fail ("extracting 1-th of car of 'n' list did not fail");
   gcry_sexp_release (n_val);
   gcry_sexp_release (n);
   gcry_sexp_release (pubkey);
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
 
   if (argc)
     {
       argc--; argv++;
     }
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--help"))
         {
           puts (
 "usage: " PGM " [options]\n"
 "\n"
 "Options:\n"
 "  --verbose      Show what is going on\n"
 "  --debug        Flyswatter\n"
 );
           exit (0);
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose = 1;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           verbose = debug = 1;
           argc--; argv++;
         }
       else if (!strncmp (*argv, "--", 2))
         die ("unknown option '%s'", *argv);
     }
 
   if (debug)
-    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
-  xgcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
-  xgcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
+    xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM_WARN));
+  xgcry_control ((GCRYCTL_INIT_SECMEM, 16384, 0));
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch");
   /* #include "../src/gcrypt-int.h" indicates that internal interfaces
      may be used; thus better do an exact version check. */
   if (strcmp (gcry_check_version (NULL), GCRYPT_VERSION))
     die ("exact version match failed");
-  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
-  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+  xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
+  xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
 
   basic ();
   canon_len ();
   back_and_forth ();
   check_sscan ();
   check_extract_param ();
   bug_1594 ();
 
   return error_count? 1:0;
 }
diff --git a/tests/version.c b/tests/version.c
index 7e68cd60..1d540ba4 100644
--- a/tests/version.c
+++ b/tests/version.c
@@ -1,166 +1,166 @@
 /* version.c  -  This version test should be run first.
    Copyright (C) 2007 Free Software Foundation, Inc.
 
    This file is part of Libgcrypt.
 
    Libgcrypt is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2.1 of
    the License, or (at your option) any later version.
 
    Libgcrypt is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
    USA.  */
 
 /* This test should be run first because due to a failing config.links
    script or bad configure parameters the just build libgcrypt may
    crash in case MPI function for specific CPU revisions have been
    enabled.  Running this test first will print out information so to
    make it easier to figure out the problem. */
 
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <errno.h>
 
 #include "../src/gcrypt-int.h"
 
 #define PGM "version"
 #include "t-common.h"
 
 static void
 test_get_config (void)
 {
   char *string;
   const char *s;
   int i;
 
   string = gcry_get_config (0, NULL);
   if (!string)
     fail ("gcry_get_config does not return anything: %s\n",
           gpg_strerror (gpg_error_from_syserror ()));
   else if ( !strchr (string, '\n') )
     fail ("gcry_get_config(0, NULL) did not return multiple lines\n");
 
   xfree (string);
   string = gcry_get_config (0, "version");
   if (!string)
     fail ("gcry_get_config(\"version\") returned NULL: %s\n",
           gpg_strerror (gpg_error_from_syserror ()));
   else if ( strchr (string, '\n') )
     fail ("gcry_get_config(\"version\") returned more than one line\n");
   else if ( strncmp (string, "version:", 8) )
     fail ("gcry_get_config(\"version\") returned wrong line\n");
 
   /* Test an item which is not the first.  */
   xfree (string);
   string = gcry_get_config (0, "cpu-arch");
   if (!string)
     fail ("gcry_get_config(\"cpu-arch\") returned NULL: %s\n",
           gpg_strerror (gpg_error_from_syserror ()));
   else if ( strchr (string, '\n') )
     fail ("gcry_get_config(\"cpu-arch\") returned more than one line\n");
   else if ( strncmp (string, "cpu-arch:", 9) )
     fail ("gcry_get_config(\"cpu-arch\") returned wrong line\n");
 
   /* Test that an unknown item return sthe correct error.  */
   xfree (string);
   string = gcry_get_config (0, "no-such-item");
   if (string)
     fail ("gcry_get_config(\"no-such-item\") returned something\n");
   else if (errno)
     fail ("gcry_get_config(\"no-such-item\") returned wrong error: %s\n",
           gpg_strerror (gpg_error_from_syserror ()));
 
   /* Check the rng-type.  */
   xfree (string);
   string = gcry_get_config (0, "rng-type");
   if (!string)
     fail ("gcry_get_config(\"rng-type\") not returned\n");
   else
     {
       for (i=0, s = string; *s; s++)
         if (*s == ':')
           i++;
       if (i < 5)
         fail ("gcry_get_config(\"rng-type\") has not enough fields\n");
     }
 
 
   xfree (string);
 }
 
 
 int
 main (int argc, char **argv)
 {
   int last_argc = -1;
 
   if (argc)
     { argc--; argv++; }
 
   while (argc && last_argc != argc )
     {
       last_argc = argc;
       if (!strcmp (*argv, "--"))
         {
           argc--; argv++;
           break;
         }
       else if (!strcmp (*argv, "--verbose"))
         {
           verbose++;
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--debug"))
         {
           /* Dummy option */
           argc--; argv++;
         }
       else if (!strcmp (*argv, "--disable-hwf"))
         {
           argc--;
           argv++;
           if (argc)
             {
               if (gcry_control (GCRYCTL_DISABLE_HWF, *argv, NULL))
                 fprintf (stderr,
                         PGM
                         ": unknown hardware feature '%s' - option ignored\n",
                         *argv);
               argc--;
               argv++;
             }
         }
     }
 
-  xgcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
+  xgcry_control ((GCRYCTL_SET_VERBOSITY, (int)verbose));
 
-  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
   if (strcmp (GCRYPT_VERSION, gcry_check_version (NULL)))
     {
       int oops = !gcry_check_version (GCRYPT_VERSION);
       fprintf (stderr, PGM ": %sversion mismatch; pgm=%s, library=%s\n",
                oops? "":"warning: ", GCRYPT_VERSION, gcry_check_version (NULL));
       if (oops)
         exit (1);
     }
 
-  xgcry_control (GCRYCTL_PRINT_CONFIG, NULL);
+  xgcry_control ((GCRYCTL_PRINT_CONFIG, NULL));
 
   test_get_config ();
 
 
   return 0;
 }