src/util/test_crypto_rsa.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2002, 2003, 2004, 2006, 2009 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19
  20 */
  21 /**
  22  * @file util/test_crypto_rsa.c
  23  * @brief testcase for RSA public key crypto
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_common.h"
  28 #include "gnunet_crypto_lib.h"
  29 #include "gnunet_signatures.h"
  30 #include "gnunet_time_lib.h"
  31
  32 #define TESTSTRING "Hello World\0"
  33 #define MAX_TESTVAL sizeof(struct GNUNET_CRYPTO_AesSessionKey)
  34 #define ITER 25
  35 #define KEYFILE "/tmp/test-gnunet-crypto-rsa.key"
  36
  37 #define PERF GNUNET_YES
  38
  39 static struct GNUNET_CRYPTO_RsaPrivateKey *key;
  40
  41
  42 static int
  43 testEncryptDecrypt ()
  44 {
  45   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
  46   struct GNUNET_CRYPTO_RsaEncryptedData target;
  47   char result[MAX_TESTVAL];
  48   int i;
  49   struct GNUNET_TIME_Absolute start;
  50   int ok;
  51
  52   FPRINTF (stderr, "%s",  "W");
  53   GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
  54   ok = 0;
  55   start = GNUNET_TIME_absolute_get ();
  56   for (i = 0; i < ITER; i++)
  57   {
  58     FPRINTF (stderr, "%s",  ".");
  59     if (GNUNET_SYSERR ==
  60         GNUNET_CRYPTO_rsa_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, &pkey,
  61                                    &target))
  62     {
  63       FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
  64       ok++;
  65       continue;
  66     }
  67     if (-1 ==
  68         GNUNET_CRYPTO_rsa_decrypt (key, &target, result,
  69                                    strlen (TESTSTRING) + 1))
  70     {
  71       FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
  72       ok++;
  73       continue;
  74
  75     }
  76     if (strncmp (TESTSTRING, result, strlen (TESTSTRING)) != 0)
  77     {
  78       printf ("%s != %.*s - testEncryptDecrypt failed!\n", TESTSTRING,
  79               (int) MAX_TESTVAL, result);
  80       ok++;
  81       continue;
  82     }
  83   }
  84   printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n", ITER,
  85           (unsigned long long)
  86           GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
  87   if (ok == 0)
  88     return GNUNET_OK;
  89   return GNUNET_SYSERR;
  90 }
  91
  92
  93 #if PERF
  94 static int
  95 testEncryptPerformance ()
  96 {
  97   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
  98   struct GNUNET_CRYPTO_RsaEncryptedData target;
  99   int i;
 100   struct GNUNET_TIME_Absolute start;
 101   int ok;
 102
 103   FPRINTF (stderr, "%s",  "W");
 104   GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
 105   ok = 0;
 106   start = GNUNET_TIME_absolute_get ();
 107   for (i = 0; i < ITER; i++)
 108   {
 109     FPRINTF (stderr, "%s",  ".");
 110     if (GNUNET_SYSERR ==
 111         GNUNET_CRYPTO_rsa_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, &pkey,
 112                                    &target))
 113     {
 114       FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
 115       ok++;
 116       continue;
 117     }
 118   }
 119   printf ("%d RSA encrypt operations %llu ms (%d failures)\n", ITER,
 120           (unsigned long long)
 121           GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
 122   if (ok != 0)
 123     return GNUNET_SYSERR;
 124   return GNUNET_OK;
 125 }
 126 #endif
 127
 128 static int
 129 testEncryptDecryptSK ()
 130 {
 131   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
 132   struct GNUNET_CRYPTO_RsaEncryptedData target;
 133   struct GNUNET_CRYPTO_AesSessionKey insk;
 134   struct GNUNET_CRYPTO_AesSessionKey outsk;
 135   int i;
 136   struct GNUNET_TIME_Absolute start;
 137   int ok;
 138
 139   FPRINTF (stderr, "%s",  "W");
 140   GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
 141   ok = 0;
 142   start = GNUNET_TIME_absolute_get ();
 143   for (i = 0; i < ITER; i++)
 144   {
 145     FPRINTF (stderr, "%s",  ".");
 146     GNUNET_CRYPTO_aes_create_session_key (&insk);
 147     if (GNUNET_SYSERR ==
 148         GNUNET_CRYPTO_rsa_encrypt (&insk,
 149                                    sizeof (struct GNUNET_CRYPTO_AesSessionKey),
 150                                    &pkey, &target))
 151     {
 152       FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
 153       ok++;
 154       continue;
 155     }
 156     if (-1 ==
 157         GNUNET_CRYPTO_rsa_decrypt (key, &target, &outsk,
 158                                    sizeof (struct GNUNET_CRYPTO_AesSessionKey)))
 159     {
 160       FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
 161       ok++;
 162       continue;
 163     }
 164     if (0 !=
 165         memcmp (&insk, &outsk, sizeof (struct GNUNET_CRYPTO_AesSessionKey)))
 166     {
 167       printf ("testEncryptDecryptSK failed!\n");
 168       ok++;
 169       continue;
 170     }
 171   }
 172   printf ("%d RSA encrypt/decrypt SK operations %llums (%d failures)\n", ITER,
 173           (unsigned long long)
 174           GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
 175   if (ok != 0)
 176     return GNUNET_SYSERR;
 177   return GNUNET_OK;
 178 }
 179
 180
 181 static int
 182 testSignVerify ()
 183 {
 184   struct GNUNET_CRYPTO_RsaSignature sig;
 185   struct GNUNET_CRYPTO_RsaSignaturePurpose purp;
 186   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
 187   int i;
 188   struct GNUNET_TIME_Absolute start;
 189   int ok = GNUNET_OK;
 190
 191   FPRINTF (stderr, "%s",  "W");
 192   GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
 193   start = GNUNET_TIME_absolute_get ();
 194   purp.size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose));
 195   purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
 196
 197   for (i = 0; i < ITER; i++)
 198   {
 199     FPRINTF (stderr, "%s",  ".");
 200     if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_sign (key, &purp, &sig))
 201     {
 202       FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_rsa_sign returned SYSERR\n");
 203       ok = GNUNET_SYSERR;
 204       continue;
 205     }
 206     if (GNUNET_SYSERR ==
 207         GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST, &purp, &sig,
 208                                   &pkey))
 209     {
 210       printf ("GNUNET_CRYPTO_rsa_verify failed!\n");
 211       ok = GNUNET_SYSERR;
 212       continue;
 213     }
 214     if (GNUNET_SYSERR !=
 215         GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
 216                                   &purp, &sig, &pkey))
 217     {
 218       printf ("GNUNET_CRYPTO_rsa_verify failed to fail!\n");
 219       ok = GNUNET_SYSERR;
 220       continue;
 221     }
 222   }
 223   printf ("%d RSA sign/verify operations %llums\n", ITER,
 224           (unsigned long long)
 225           GNUNET_TIME_absolute_get_duration (start).rel_value);
 226   return ok;
 227 }
 228
 229
 230 #if PERF
 231 static int
 232 testSignPerformance ()
 233 {
 234   struct GNUNET_CRYPTO_RsaSignaturePurpose purp;
 235   struct GNUNET_CRYPTO_RsaSignature sig;
 236   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
 237   int i;
 238   struct GNUNET_TIME_Absolute start;
 239   int ok = GNUNET_OK;
 240
 241   purp.size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose));
 242   purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
 243   FPRINTF (stderr, "%s",  "W");
 244   GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
 245   start = GNUNET_TIME_absolute_get ();
 246   for (i = 0; i < ITER; i++)
 247   {
 248     FPRINTF (stderr, "%s",  ".");
 249     if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_sign (key, &purp, &sig))
 250     {
 251       FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_rsa_sign returned SYSERR\n");
 252       ok = GNUNET_SYSERR;
 253       continue;
 254     }
 255   }
 256   printf ("%d RSA sign operations %llu ms\n", ITER,
 257           (unsigned long long)
 258           GNUNET_TIME_absolute_get_duration (start).rel_value);
 259   return ok;
 260 }
 261 #endif
 262
 263
 264 static int
 265 testCreateFromFile ()
 266 {
 267   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded p1;
 268   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded p2;
 269
 270   key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
 271   GNUNET_assert (NULL != key);
 272   GNUNET_CRYPTO_rsa_key_get_public (key, &p1);
 273   GNUNET_CRYPTO_rsa_key_free (key);
 274   key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
 275   GNUNET_assert (NULL != key);
 276   GNUNET_CRYPTO_rsa_key_get_public (key, &p2);
 277   GNUNET_assert (0 == memcmp (&p1, &p2, sizeof (p1)));
 278   GNUNET_CRYPTO_rsa_key_free (key);
 279   GNUNET_assert (0 == UNLINK (KEYFILE));
 280   key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
 281   GNUNET_assert (NULL != key);
 282   GNUNET_CRYPTO_rsa_key_get_public (key, &p2);
 283   GNUNET_assert (0 != memcmp (&p1, &p2, sizeof (p1)));
 284   return GNUNET_OK;
 285 }
 286
 287
 288 static void
 289 key_cont (void *cls,
 290           struct GNUNET_CRYPTO_RsaPrivateKey *pk,
 291           const char *emsg)
 292 {
 293   const char *txt = cls;
 294   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub1;
 295   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub2;
 296
 297   GNUNET_assert (0 == strcmp ("ok", txt));
 298   GNUNET_CRYPTO_rsa_key_get_public (pk, &pub1);
 299   GNUNET_CRYPTO_rsa_key_get_public (key, &pub2);
 300   GNUNET_assert (0 == memcmp (&pub1, &pub2,
 301                               sizeof (pub1)));
 302   GNUNET_CRYPTO_rsa_key_free (pk);
 303 }
 304
 305
 306 static void
 307 test_async_creation (void *cls,
 308                      const struct GNUNET_SCHEDULER_TaskContext *tc)
 309 {
 310   struct GNUNET_CRYPTO_RsaKeyGenerationContext *gc;
 311
 312   gc = GNUNET_CRYPTO_rsa_key_create_start (KEYFILE,
 313                                            &key_cont,
 314                                            (void*) "bug");
 315   GNUNET_CRYPTO_rsa_key_create_stop (gc);
 316   gc = GNUNET_CRYPTO_rsa_key_create_start (KEYFILE,
 317                                            &key_cont,
 318                                            (void*) "ok");
 319 }
 320
 321
 322 int
 323 main (int argc, char *argv[])
 324 {
 325   int failureCount = 0;
 326
 327   GNUNET_log_setup ("test-crypto-rsa", "WARNING", NULL);
 328   GNUNET_CRYPTO_random_disable_entropy_gathering ();
 329   if (GNUNET_OK != testCreateFromFile ())
 330     failureCount++;
 331   GNUNET_SCHEDULER_run (&test_async_creation, NULL);
 332 #if PERF
 333   if (GNUNET_OK != testEncryptPerformance ())
 334     failureCount++;
 335   if (GNUNET_OK != testSignPerformance ())
 336     failureCount++;
 337 #endif
 338   if (GNUNET_OK != testEncryptDecryptSK ())
 339     failureCount++;
 340   if (GNUNET_OK != testEncryptDecrypt ())
 341     failureCount++;
 342   if (GNUNET_OK != testSignVerify ())
 343     failureCount++;
 344   GNUNET_CRYPTO_rsa_key_free (key);
 345   GNUNET_assert (0 == UNLINK (KEYFILE));
 346
 347   if (failureCount != 0)
 348   {
 349     printf ("\n\n%d TESTS FAILED!\n\n", failureCount);
 350     return -1;
 351   }
 352   return 0;
 353 }                               /* end of main */