Add GMAC to MAC API
[libgcrypt.git] / tests / benchmark.c
index 5cdf4f0..8bb8584 100644 (file)
@@ -1,5 +1,5 @@
 /* benchmark.c - for libgcrypt
- * Copyright (C) 2002, 2004, 2005, 2006 Free Software Foundation, Inc.
+ * Copyright (C) 2002, 2004, 2005, 2006, 2008 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
@@ -14,8 +14,7 @@
  * 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
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef HAVE_CONFIG_H
 #endif
 #include <stdio.h>
 #include <stdlib.h>
-#include <time.h>
 #include <stdarg.h>
-#ifndef _WIN32
-#include <sys/times.h>
+
+#ifdef _GCRYPT_IN_LIBGCRYPT
+# include "../src/gcrypt-int.h"
+# include "../compat/libcompat.h"
+#else
+# include <gcrypt.h>
 #endif
-#include <gcrypt.h>
+
+#include "stopwatch.h"
+
 
 #define PGM "benchmark"
 
+static int verbose;
+
+/* Do encryption tests with large buffers.  */
+static int large_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;
+
+
 static const char sample_private_dsa_key_1024[] =
 "(private-key\n"
 "  (dsa\n"
@@ -225,10 +253,6 @@ static const char sample_public_dsa_key_3072[] =
                  exit(2);} while(0)
 
 
-/* Helper for the start and stop timer. */
-static clock_t started_at, stopped_at;
-
-
 static void
 die (const char *format, ...)
 {
@@ -242,41 +266,32 @@ die (const char *format, ...)
   exit (1);
 }
 
-
 static void
-start_timer (void)
+show_sexp (const char *prefix, gcry_sexp_t a)
 {
-#ifdef _WIN32
-  started_at = stopped_at = clock ();
-#else
-  struct tms tmp;
+  char *buf;
+  size_t size;
 
-  times (&tmp);
-  started_at = stopped_at = tmp.tms_utime;
-#endif
-}
-
-static void
-stop_timer (void)
-{
-#ifdef _WIN32
-  stopped_at = clock ();
-#else
-  struct tms tmp;
+  fputs (prefix, stderr);
+  size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
+  buf = malloc (size);
+  if (!buf)
+    die ("out of core\n");
 
-  times (&tmp);
-  stopped_at = tmp.tms_utime;
-#endif
+  gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
+  fprintf (stderr, "%.*s", (int)size, buf);
 }
 
-static const char *
-elapsed_time (void)
+
+static void
+progress_cb (void *cb_data, const char *what, int printchar,
+             int current, int total)
 {
-  static char buf[50];
+  (void)cb_data;
 
-  sprintf (buf, "%5.0fms",
-           (((double) (stopped_at - started_at))/CLOCKS_PER_SEC)*10000000);
-  return buf;
+  fprintf (stderr, PGM ": progress (%s %c %d %d)\n",
+           what, printchar, current, total);
+  fflush (stderr);
 }
 
 
@@ -305,6 +320,8 @@ random_bench (int very_strong)
   printf (" %s", elapsed_time ());
 
   putchar ('\n');
+  if (verbose)
+    gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
 }
 
 
@@ -314,18 +331,27 @@ md_bench ( const char *algoname )
 {
   int algo;
   gcry_md_hd_t hd;
-  int i;
-  char buf[1000];
+  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 ( !gcry_md_test_algo (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)
     {
@@ -340,38 +366,232 @@ md_bench ( const char *algoname )
       exit (1);
     }
 
-  for (i=0; i < sizeof buf; i++)
+  for (i=0; i < bufsize; i++)
     buf[i] = i;
 
   printf ("%-12s", gcry_md_algo_name (algo));
 
   start_timer ();
-  for (i=0; i < 1000; i++)
-    gcry_md_write (hd, buf, sizeof buf);
+  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 ());
+  fflush (stdout);
 
   gcry_md_reset (hd);
   start_timer ();
-  for (i=0; i < 10000; i++)
-    gcry_md_write (hd, buf, sizeof buf/10);
+  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 ());
+  fflush (stdout);
 
   gcry_md_reset (hd);
   start_timer ();
-  for (i=0; i < 1000000; i++)
-    gcry_md_write (hd, "", 1);
+  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 ());
+  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 ());
+  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");
+
+  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 ());
+  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 < 500; 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;
+
+  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 ());
+  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 ());
+  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 ());
+  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];
+  size_t 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 void
 cipher_bench ( const char *algoname )
 {
@@ -381,15 +601,28 @@ cipher_bench ( const char *algoname )
   int i;
   int keylen, blklen;
   char key[128];
-  char outbuf[1000], buf[1000];
-  size_t buflen;
-  static struct { int mode; const char *name; int blocked; } modes[] = {
-    { GCRY_CIPHER_MODE_ECB, "ECB", 1 },
-    { GCRY_CIPHER_MODE_CBC, "CBC", 1 },
-    { GCRY_CIPHER_MODE_CFB, "CFB", 0 },
-    { GCRY_CIPHER_MODE_OFB, "OFB", 0 },
-    { GCRY_CIPHER_MODE_CTR, "CTR", 0 },
-    { GCRY_CIPHER_MODE_STREAM, "STREAM", 0 },
+  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;
+    void (* const aead_init)(gcry_cipher_hd_t hd, size_t buflen, int authlen);
+    int req_blocksize;
+    int authlen;
+  } modes[] = {
+    { GCRY_CIPHER_MODE_ECB, "   ECB/Stream", 1 },
+    { GCRY_CIPHER_MODE_CBC, "      CBC", 1 },
+    { GCRY_CIPHER_MODE_CFB, "      CFB", 0 },
+    { GCRY_CIPHER_MODE_OFB, "      OFB", 0 },
+    { GCRY_CIPHER_MODE_CTR, "      CTR", 0 },
+    { GCRY_CIPHER_MODE_CCM, "      CCM", 0,
+      ccm_aead_init, GCRY_CCM_BLOCK_LEN, 8 },
+    { GCRY_CIPHER_MODE_GCM, "      GCM", 0,
+      NULL, GCRY_GCM_BLOCK_LEN, GCRY_GCM_BLOCK_LEN },
+    { GCRY_CIPHER_MODE_STREAM, "", 0 },
     {0}
   };
   int modeidx;
@@ -404,16 +637,38 @@ cipher_bench ( const char *algoname )
       return;
     }
 
+  if (large_buffers)
+    {
+      allocated_buflen = 1024 * 100;
+      repetitions = 10;
+    }
+  else
+    {
+      allocated_buflen = 1024;
+      repetitions = 1000;
+    }
+  repetitions *= cipher_repetitions;
+
+  raw_buf = gcry_xmalloc (allocated_buflen+15);
+  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)
     {
-      printf ("%-10s", "");
+      if (cipher_repetitions != 1)
+        printf ("Running each test %d times.\n", cipher_repetitions);
+      printf ("%-12s", "");
       for (modeidx=0; modes[modeidx].mode; modeidx++)
-        printf (" %-15s", modes[modeidx].name );
+        if (*modes[modeidx].name)
+          printf (" %-15s", modes[modeidx].name );
       putchar ('\n');
-      printf ("%-10s", "");
+      printf ("%-12s", "");
       for (modeidx=0; modes[modeidx].mode; modeidx++)
-        printf (" ---------------" );
+        if (*modes[modeidx].name)
+          printf (" ---------------" );
       putchar ('\n');
       header_printed = 1;
     }
@@ -449,15 +704,19 @@ cipher_bench ( const char *algoname )
       exit (1);
     }
 
-  printf ("%-10s", gcry_cipher_algo_name (algo));
+  printf ("%-12s", gcry_cipher_algo_name (algo));
   fflush (stdout);
 
   for (modeidx=0; modes[modeidx].mode; modeidx++)
     {
       if ((blklen > 1 && modes[modeidx].mode == GCRY_CIPHER_MODE_STREAM)
-          | (blklen == 1 && modes[modeidx].mode != GCRY_CIPHER_MODE_STREAM))
+          || (blklen == 1 && modes[modeidx].mode != GCRY_CIPHER_MODE_STREAM))
+        continue;
+
+      if (modes[modeidx].req_blocksize > 0
+          && blklen != modes[modeidx].req_blocksize)
         {
-          printf ("                " );
+          printf (" %7s %7s", "-", "-" );
           continue;
         }
 
@@ -470,29 +729,57 @@ cipher_bench ( const char *algoname )
           fprintf (stderr, PGM ": error opening cipher `%s'\n", algoname);
           exit (1);
         }
-      
-      err = gcry_cipher_setkey (hd, key, keylen);
-      if (err)
-      { 
-          fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
-                  gpg_strerror (err));
-          gcry_cipher_close (hd);
-          exit (1);
+
+      if (!cipher_with_keysetup)
+        {
+          err = gcry_cipher_setkey (hd, key, keylen);
+          if (err)
+            {
+              fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
+                       gpg_strerror (err));
+              gcry_cipher_close (hd);
+              exit (1);
+            }
         }
 
-      buflen = sizeof buf;
+      buflen = allocated_buflen;
       if (modes[modeidx].blocked)
         buflen = (buflen / blklen) * blklen;
 
       start_timer ();
-      for (i=err=0; !err && i < 1000; i++)
-        err = gcry_cipher_encrypt ( hd, outbuf, buflen, buf, buflen);
+      for (i=err=0; !err && i < repetitions; i++)
+        {
+          if (cipher_with_keysetup)
+            {
+              err = gcry_cipher_setkey (hd, key, keylen);
+              if (err)
+                {
+                  fprintf (stderr, "gcry_cipher_setkey 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);
+              err = gcry_cipher_encrypt (hd, outbuf, buflen, buf, buflen);
+              if (err)
+                break;
+              err = gcry_cipher_gettag (hd, outbuf, modes[modeidx].authlen);
+            }
+          else
+            {
+              err = gcry_cipher_encrypt (hd, outbuf, buflen, buf, buflen);
+            }
+        }
       stop_timer ();
+
       printf (" %s", elapsed_time ());
       fflush (stdout);
       gcry_cipher_close (hd);
       if (err)
-        { 
+        {
           fprintf (stderr, "gcry_cipher_encrypt failed: %s\n",
                    gpg_strerror (err) );
           exit (1);
@@ -504,25 +791,52 @@ cipher_bench ( const char *algoname )
           fprintf (stderr, PGM ": error opening cipher `%s'/n", algoname);
           exit (1);
         }
-      
-      err = gcry_cipher_setkey (hd, key, keylen);
-      if (err)
-        { 
-          fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
-                   gpg_strerror (err));
-          gcry_cipher_close (hd);
-          exit (1);
+
+      if (!cipher_with_keysetup)
+        {
+          err = gcry_cipher_setkey (hd, key, keylen);
+          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 < 1000; i++)
-        err = gcry_cipher_decrypt ( hd, outbuf, buflen,  buf, buflen);
+      for (i=err=0; !err && i < repetitions; i++)
+        {
+          if (cipher_with_keysetup)
+            {
+              err = gcry_cipher_setkey (hd, key, keylen);
+              if (err)
+                {
+                  fprintf (stderr, "gcry_cipher_setkey 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);
+              err = gcry_cipher_decrypt (hd, outbuf, buflen, buf, buflen);
+              if (err)
+                break;
+              err = gcry_cipher_checktag (hd, outbuf, modes[modeidx].authlen);
+              if (gpg_err_code (err) == GPG_ERR_CHECKSUM)
+                err = gpg_error (GPG_ERR_NO_ERROR);
+            }
+          else
+            err = gcry_cipher_decrypt (hd, outbuf, buflen, buf, buflen);
+        }
       stop_timer ();
       printf (" %s", elapsed_time ());
       fflush (stdout);
       gcry_cipher_close (hd);
       if (err)
-        { 
+        {
           fprintf (stderr, "gcry_cipher_decrypt failed: %s\n",
                    gpg_strerror (err) );
           exit (1);
@@ -530,19 +844,142 @@ cipher_bench ( const char *algoname )
     }
 
   putchar ('\n');
+  gcry_free (raw_buf);
+  gcry_free (raw_outbuf);
 }
 
 
 
 static void
-dsa_bench (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*sign %4d*verify\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;
+
+      printf ("RSA %3d bit    ", p_sizes[testno]);
+      fflush (stdout);
+
+      err = gcry_sexp_build (&key_spec, NULL,
+                             gcry_fips_mode_active ()
+                             ? "(genkey (RSA (nbits %d)))"
+                             : "(genkey (RSA (nbits %d)(transient-key)))",
+                             p_sizes[testno]);
+      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",
+             p_sizes[testno], 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 ());
+      fflush (stdout);
+
+      x = gcry_mpi_new (p_sizes[testno]);
+      gcry_mpi_randomize (x, p_sizes[testno]-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 ());
+      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 ());
+
+      if (no_blinding)
+        {
+          fflush (stdout);
+          x = gcry_mpi_new (p_sizes[testno]);
+          gcry_mpi_randomize (x, p_sizes[testno]-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 ());
+          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
+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;
+  gcry_sexp_t sig = NULL;
   int i, j;
 
   err = gcry_sexp_sscan (pub_key+0, NULL, sample_public_dsa_key_1024,
@@ -569,9 +1006,10 @@ dsa_bench (void)
       exit (1);
     }
 
-
-  fputs ("Algorithm       generate  100*sign  100*verify\n"
-         "----------------------------------------------\n", stdout);
+  if (print_header)
+    printf ("Algorithm         generate %4d*sign %4d*verify\n"
+            "------------------------------------------------\n",
+            iterations, iterations );
   for (i=0; i < DIM (q_sizes); i++)
     {
       gcry_mpi_t x;
@@ -587,12 +1025,13 @@ dsa_bench (void)
           exit (1);
         }
 
-      printf ("DSA %d/%d           -", p_sizes[i], q_sizes[i]);
+      printf ("DSA %d/%d             -", p_sizes[i], q_sizes[i]);
       fflush (stdout);
 
       start_timer ();
-      for (j=0; j < 100; j++)
+      for (j=0; j < iterations; j++)
         {
+          gcry_sexp_release (sig);
           err = gcry_pk_sign (&sig, data, sec_key[i]);
           if (err)
             {
@@ -607,7 +1046,7 @@ dsa_bench (void)
       fflush (stdout);
 
       start_timer ();
-      for (j=0; j < 100; j++)
+      for (j=0; j < iterations; j++)
         {
           err = gcry_pk_verify (sig, data, pub_key[i]);
           if (err)
@@ -624,6 +1063,7 @@ dsa_bench (void)
 
       gcry_sexp_release (sig);
       gcry_sexp_release (data);
+      sig = NULL;
     }
 
 
@@ -636,16 +1076,18 @@ dsa_bench (void)
 
 
 static void
-ecc_bench (void)
+ecc_bench (int iterations, int print_header)
 {
 #if USE_ECC
   gpg_error_t err;
-  int p_sizes[] = { 192, 256, 384 /*, 521*/ };
+  const char *p_sizes[] = { "192", "224", "256", "384", "521", "Ed25519",
+              "gost256", "gost512" };
   int testno;
 
-
-  fputs ("Algorithm       generate  100*sign  100*verify\n"
-         "----------------------------------------------\n", stdout);
+  if (print_header)
+    printf ("Algorithm         generate %4d*sign %4d*verify\n"
+            "------------------------------------------------\n",
+            iterations, iterations );
   for (testno=0; testno < DIM (p_sizes); testno++)
     {
       gcry_sexp_t key_spec, key_pair, pub_key, sec_key;
@@ -653,21 +1095,52 @@ ecc_bench (void)
       gcry_sexp_t data;
       gcry_sexp_t sig = NULL;
       int count;
+      int p_size;
+      int is_ed25519;
+      int is_gost;
 
-      printf ("ECDSA %3d bit ", p_sizes[testno]);
+      is_ed25519 = !strcmp (p_sizes[testno], "Ed25519");
+      is_gost = !strncmp (p_sizes[testno], "gost", 4);
+      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);
 
-      err = gcry_sexp_build (&key_spec, NULL,
-                             "(genkey (ECDSA (nbits %d)))", p_sizes[testno]);
+      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_sizes[testno], gcry_strerror (err));
+             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)
@@ -676,40 +1149,58 @@ ecc_bench (void)
       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 ());
+      printf ("     %s", elapsed_time ());
       fflush (stdout);
 
-      x = gcry_mpi_new (p_sizes[testno]);
-      gcry_mpi_randomize (x, p_sizes[testno], GCRY_WEAK_RANDOM);
-      err = gcry_sexp_build (&data, NULL, "(data (flags raw) (value %m))", x);
+      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 < 100; count++)
+      for (count=0; count < iterations; count++)
         {
           gcry_sexp_release (sig);
           err = gcry_pk_sign (&sig, data, sec_key);
           if (err)
-            die ("signing failed: %s\n", gpg_strerror (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 ());
       fflush (stdout);
 
       start_timer ();
-      for (count=0; count < 100; count++)
+      for (count=0; count < iterations; count++)
         {
           err = gcry_pk_verify (sig, data, pub_key);
           if (err)
             {
               putchar ('\n');
-              fprintf (stderr, PGM ": verify failed: %s\n",
-                       gpg_strerror (err));
-              exit (1);
+              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 ();
@@ -769,17 +1260,17 @@ mpi_bench (void)
 
   do_powm (
 "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E4",
-           "29", 
+           "29",
 "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8"
            );
   do_powm (
            "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA40716",
-           "29", 
+           "29",
            "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847"
            );
   do_powm (
            "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA4071620A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA40716",
-           "29", 
+           "29",
            "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847"
            );
 
@@ -792,36 +1283,207 @@ mpi_bench (void)
 int
 main( int argc, char **argv )
 {
+  int last_argc = -1;
+  int no_blinding = 0;
+  int use_random_daemon = 0;
+  int with_progress = 0;
+  int debug = 0;
+  int pk_count = 100;
+
+  buffer_alignment = 1;
+
   if (argc)
     { argc--; argv++; }
 
-  gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
-  if (!gcry_check_version (GCRYPT_VERSION))
+  /* 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);
+
+  while (argc && last_argc != argc )
     {
-      fprintf (stderr, PGM ": version mismatch\n");
-      exit (1);
+      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 [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, "--prefer-standard-rng"))
+        {
+          /* This is anyway the default, but we may want to use it for
+             debugging. */
+          gcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_STANDARD);
+          argc--; argv++;
+        }
+      else if (!strcmp (*argv, "--prefer-fips-rng"))
+        {
+          gcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_FIPS);
+          argc--; argv++;
+        }
+      else if (!strcmp (*argv, "--prefer-system-rng"))
+        {
+          gcry_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, "--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.  */
+          gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
+        }
+      else if (!strcmp (*argv, "--progress"))
+        {
+          argc--; argv++;
+          with_progress = 1;
+        }
     }
-  if (argc && !strcmp (*argv, "--use-random-daemon"))
+
+  if (buffer_alignment < 1 || buffer_alignment > 16)
+    die ("value for --alignment must be in the range 1 to 16\n");
+
+  gcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
+
+  if (!gcry_check_version (GCRYPT_VERSION))
     {
-      gcry_control (GCRYCTL_USE_RANDOM_DAEMON, 1);
-      argc--; argv++;
+      fprintf (stderr, PGM ": version mismatch; pgm=%s, library=%s\n",
+               GCRYPT_VERSION, gcry_check_version (NULL));
+      exit (1);
     }
+
+  if (debug)
+    gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
+
+  if (gcry_fips_mode_active ())
+    in_fips_mode = 1;
+  else
+    gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+
+  if (use_random_daemon)
+    gcry_control (GCRYCTL_USE_RANDOM_DAEMON, 1);
+
+  if (with_progress)
+    gcry_set_progress_handler (progress_cb, NULL);
+
   gcry_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 ( !argc )
     {
+      gcry_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);
+      dsa_bench (pk_count, 0);
+      ecc_bench (pk_count, 0);
+      putchar ('\n');
       mpi_bench ();
       putchar ('\n');
       random_bench (0);
     }
-  else if ( !strcmp (*argv, "--help"))
-     fputs ("usage: benchmark [md|cipher|random|mpi|dsa [algonames]]\n",
-            stdout);
   else if ( !strcmp (*argv, "random") || !strcmp (*argv, "strongrandom"))
     {
       if (argc == 1)
@@ -843,6 +1505,14 @@ main( int argc, char **argv )
         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)
@@ -855,23 +1525,30 @@ main( int argc, char **argv )
     {
         mpi_bench ();
     }
+  else if ( !strcmp (*argv, "rsa"))
+    {
+        gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+        rsa_bench (pk_count, 1, no_blinding);
+    }
   else if ( !strcmp (*argv, "dsa"))
     {
         gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
-        dsa_bench ();
+        dsa_bench (pk_count, 1);
     }
   else if ( !strcmp (*argv, "ecc"))
     {
         gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
-        ecc_bench ();
+        ecc_bench (pk_count, 1);
     }
   else
     {
       fprintf (stderr, PGM ": bad arguments\n");
       return 1;
     }
-  
-  return 0;
-}
 
 
+  if (in_fips_mode && !gcry_fips_mode_active ())
+    fprintf (stderr, PGM ": FIPS mode is not anymore active\n");
+
+  return 0;
+}