src/util/perf_crypto_rsa.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2014 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19 */
  20
  21 /**
  22  * @author Christian Grothoff
  23  * @file util/perf_crypto_rsa.c
  24  * @brief measure performance of RSA signing
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include <gauger.h>
  29
  30
  31 /**
  32  * Evaluate RSA performance.
  33  *
  34  * @param len keylength to evaluate with
  35  */
  36 static void
  37 eval (unsigned int len)
  38 {
  39   struct GNUNET_TIME_Absolute start;
  40   struct GNUNET_CRYPTO_RsaSignature *sig;
  41   struct GNUNET_CRYPTO_RsaSignature *rsig;
  42   struct GNUNET_CRYPTO_RsaPublicKey *public_key;
  43   struct GNUNET_CRYPTO_RsaPrivateKey *private_key;
  44   struct GNUNET_CRYPTO_RsaBlindingKeySecret bsec[10];
  45   unsigned int i;
  46   char sbuf[128];
  47   char *bbuf;
  48   size_t bbuf_len;
  49   struct GNUNET_HashCode hc;
  50
  51   start = GNUNET_TIME_absolute_get ();
  52   for (i=0;i<10;i++)
  53   {
  54     private_key = GNUNET_CRYPTO_rsa_private_key_create (len);
  55     GNUNET_CRYPTO_rsa_private_key_free (private_key);
  56   }
  57   printf ("10x %u-key generation took %s\n",
  58           len,
  59           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
  60                                                   GNUNET_YES));
  61   GNUNET_snprintf (sbuf,
  62                    sizeof (sbuf),
  63                    "RSA %u-key generation",
  64                    len);
  65   GAUGER ("UTIL", sbuf,
  66           64 * 1024 / (1 +
  67                        GNUNET_TIME_absolute_get_duration
  68                        (start).rel_value_us / 1000LL), "keys/ms");
  69   private_key = GNUNET_CRYPTO_rsa_private_key_create (len);
  70   public_key = GNUNET_CRYPTO_rsa_private_key_get_public (private_key);
  71   for (i=0;i<10;i++)
  72     GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
  73                                 &bsec[i], sizeof (bsec[0]));
  74   /*
  75   start = GNUNET_TIME_absolute_get ();
  76   for (i=0;i<10;i++)
  77     rsa_blinding_key_derive(public_key, &bsec[i]);
  78   printf ("10x %u-blinding key generation took %s\n",
  79           len,
  80           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
  81                                                   GNUNET_YES));
  82   GNUNET_snprintf (sbuf,
  83                    sizeof (sbuf),
  84                    "RSA %u-blinding key generation",
  85                    len);
  86   GAUGER ("UTIL", sbuf,
  87           64 * 1024 / (1 +
  88                        GNUNET_TIME_absolute_get_duration
  89                        (start).rel_value_us / 1000LL), "keys/ms");
  90   */
  91   start = GNUNET_TIME_absolute_get ();
  92   GNUNET_CRYPTO_hash ("test", 4, &hc);
  93   for (i=0;i<10;i++)
  94   {
  95     GNUNET_CRYPTO_rsa_blind (&hc,
  96                              &bsec[i],
  97                              public_key,
  98                              &bbuf, &bbuf_len);
  99     GNUNET_free (bbuf);
 100   }
 101   printf ("10x %u-blinding took %s\n",
 102           len,
 103           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
 104                                                   GNUNET_YES));
 105   GNUNET_snprintf (sbuf,
 106                    sizeof (sbuf),
 107                    "RSA %u-blinding",
 108                    len);
 109   GAUGER ("UTIL",
 110           sbuf,
 111           64 * 1024 / (1 +
 112                        GNUNET_TIME_absolute_get_duration
 113                        (start).rel_value_us / 1000LL), "ops/ms");
 114   GNUNET_CRYPTO_rsa_blind (&hc,
 115                            &bsec[0],
 116                            public_key,
 117                            &bbuf, &bbuf_len);
 118   start = GNUNET_TIME_absolute_get ();
 119   for (i=0;i<10;i++)
 120   {
 121     sig = GNUNET_CRYPTO_rsa_sign_blinded (private_key,
 122                                           bbuf, bbuf_len);
 123     GNUNET_CRYPTO_rsa_signature_free (sig);
 124   }
 125   printf ("10x %u-signing took %s\n",
 126           len,
 127           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
 128                                                   GNUNET_YES));
 129   GNUNET_snprintf (sbuf,
 130                    sizeof (sbuf),
 131                    "RSA %u-signing",
 132                    len);
 133   GAUGER ("UTIL",
 134           sbuf,
 135           64 * 1024 / (1 +
 136                        GNUNET_TIME_absolute_get_duration
 137                        (start).rel_value_us / 1000LL), "ops/ms");
 138   sig = GNUNET_CRYPTO_rsa_sign_blinded (private_key,
 139                                         bbuf,
 140                                         bbuf_len);
 141   start = GNUNET_TIME_absolute_get ();
 142   for (i=0;i<10;i++)
 143   {
 144     rsig = GNUNET_CRYPTO_rsa_unblind (sig,
 145                                       &bsec[0],
 146                                       public_key);
 147     GNUNET_CRYPTO_rsa_signature_free (rsig);
 148   }
 149   printf ("10x %u-unblinding took %s\n",
 150           len,
 151           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
 152                                                   GNUNET_YES));
 153   GNUNET_snprintf (sbuf,
 154                    sizeof (sbuf),
 155                    "RSA %u-unblinding",
 156                    len);
 157   GAUGER ("UTIL",
 158           sbuf,
 159           64 * 1024 / (1 +
 160                        GNUNET_TIME_absolute_get_duration
 161                        (start).rel_value_us / 1000LL), "ops/ms");
 162   rsig = GNUNET_CRYPTO_rsa_unblind (sig,
 163                                     &bsec[0],
 164                                     public_key);
 165   start = GNUNET_TIME_absolute_get ();
 166   for (i=0;i<10;i++)
 167   {
 168     GNUNET_assert (GNUNET_OK ==
 169                    GNUNET_CRYPTO_rsa_verify (&hc,
 170                                              rsig,
 171                                              public_key));
 172   }
 173   printf ("10x %u-verifying took %s\n",
 174           len,
 175           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
 176                                                   GNUNET_YES));
 177   GNUNET_snprintf (sbuf,
 178                    sizeof (sbuf),
 179                    "RSA %u-verification",
 180                    len);
 181   GAUGER ("UTIL",
 182           sbuf,
 183           64 * 1024 / (1 +
 184                        GNUNET_TIME_absolute_get_duration
 185                        (start).rel_value_us / 1000LL), "ops/ms");
 186   GNUNET_CRYPTO_rsa_signature_free (sig);
 187   GNUNET_CRYPTO_rsa_public_key_free (public_key);
 188   GNUNET_CRYPTO_rsa_private_key_free (private_key);
 189   GNUNET_free (bbuf);
 190 }
 191
 192
 193 int
 194 main (int argc, char *argv[])
 195 {
 196   eval (1024);
 197   /* eval (2048); */
 198   /* eval (4096); */
 199   return 0;
 200 }
 201
 202
 203 /* end of perf_crypto_rsa.c */