src/util/test_crypto_ksk.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2004, 2005, 2006 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_ksk.c
  23  * @brief testcase for util/crypto_ksk.c
  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 20
  34 #define UNIQUE_ITER 6
  35 #define ITER 25
  36
  37
  38 static int
  39 testCorrectKey ()
  40 {
  41   const char *want =
  42       "010601000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b73c215f7a5e6b09bec55713c901786c09324a150980e014bdb0d04426934929c3b4971a9711af5455536cd6eeb8bfa004ee904972a737455f53c752987d8c82b755bc02882b44950c4acdc1672ba74c3b94d81a4c1ea3d74e7700ae5594c3a4f3c559e4bff2df6844fac302e4b66175e14dc8bad3ce44281d2fec1a1abef06301010000";
  43   GNUNET_HashCode in;
  44   struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
  45   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
  46   int i;
  47   char out[3];
  48
  49   fprintf (stderr, "Testing KBlock key correctness");
  50   GNUNET_CRYPTO_hash ("X", strlen ("X"), &in);
  51   hostkey = GNUNET_CRYPTO_rsa_key_create_from_hash (&in);
  52   if (hostkey == NULL)
  53   {
  54     GNUNET_break (0);
  55     return GNUNET_SYSERR;
  56   }
  57   GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
  58   GNUNET_CRYPTO_rsa_key_free (hostkey);
  59 #if 0
  60   for (i = 0; i < sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded); i++)
  61     printf ("%02x", ((unsigned char *) &pkey)[i]);
  62   printf ("\n");
  63 #endif
  64   for (i = 0; i < sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded); i++)
  65   {
  66     snprintf (out, sizeof (out), "%02x", ((unsigned char *) &pkey)[i]);
  67     if (0 != strncmp (out, &want[i * 2], 2))
  68     {
  69       fprintf (stderr,
  70                " Failed! Wanted %.2s but got %2s at %d\n",
  71                &want[i * 2], out, i);
  72       return GNUNET_SYSERR;
  73     }
  74   }
  75   fprintf (stderr, " OK\n");
  76   return GNUNET_OK;
  77 }
  78
  79
  80 static int
  81 testMultiKey (const char *word)
  82 {
  83   GNUNET_HashCode in;
  84   struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
  85   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
  86   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey1;
  87   int i;
  88
  89   fprintf (stderr, "Testing KBlock key uniqueness (%s) ", word);
  90   GNUNET_CRYPTO_hash (word, strlen (word), &in);
  91   hostkey = GNUNET_CRYPTO_rsa_key_create_from_hash (&in);
  92   if (hostkey == NULL)
  93   {
  94     GNUNET_break (0);
  95     return GNUNET_SYSERR;
  96   }
  97   GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
  98   /*
  99    * for (i=0;i<sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);i++)
 100    * printf("%02x", ((unsigned char*) &pkey)[i]);
 101    * printf("\n"); */
 102   GNUNET_CRYPTO_rsa_key_free (hostkey);
 103   for (i = 0; i < UNIQUE_ITER; i++)
 104   {
 105     fprintf (stderr, ".");
 106     hostkey = GNUNET_CRYPTO_rsa_key_create_from_hash (&in);
 107     if (hostkey == NULL)
 108     {
 109       GNUNET_break (0);
 110       fprintf (stderr, " ERROR\n");
 111       return GNUNET_SYSERR;
 112     }
 113     GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey1);
 114     GNUNET_CRYPTO_rsa_key_free (hostkey);
 115     if (0 !=
 116         memcmp (&pkey, &pkey1,
 117                 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)))
 118     {
 119       GNUNET_break (0);
 120       fprintf (stderr, " ERROR\n");
 121       return GNUNET_SYSERR;
 122     }
 123   }
 124   fprintf (stderr, " OK\n");
 125   return GNUNET_OK;
 126 }
 127
 128
 129 static int
 130 testEncryptDecrypt (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
 131 {
 132   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
 133   struct GNUNET_CRYPTO_RsaEncryptedData target;
 134   char result[MAX_TESTVAL];
 135   int i;
 136   struct GNUNET_TIME_Absolute start;
 137   int ok;
 138
 139   fprintf (stderr, "W");
 140   GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
 141
 142   ok = 0;
 143   start = GNUNET_TIME_absolute_get ();
 144   for (i = 0; i < ITER; i++)
 145   {
 146     fprintf (stderr, ".");
 147     if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_encrypt (TESTSTRING,
 148                                                     strlen (TESTSTRING) + 1,
 149                                                     &pkey, &target))
 150     {
 151       fprintf (stderr, "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
 152       ok++;
 153       continue;
 154     }
 155     if (-1 == GNUNET_CRYPTO_rsa_decrypt (hostkey,
 156                                          &target, result,
 157                                          strlen (TESTSTRING) + 1))
 158     {
 159       fprintf (stderr, "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
 160       ok++;
 161       continue;
 162     }
 163     if (strncmp (TESTSTRING, result, strlen (TESTSTRING)) != 0)
 164     {
 165       printf ("%s != %.*s - testEncryptDecrypt failed!\n",
 166               TESTSTRING, MAX_TESTVAL, result);
 167       ok++;
 168       continue;
 169     }
 170   }
 171   printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n",
 172           ITER,
 173           (unsigned long long)
 174           GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
 175   if (ok == 0)
 176     return GNUNET_OK;
 177   else
 178     return GNUNET_SYSERR;
 179 }
 180
 181 static int
 182 testSignVerify (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
 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, "W");
 192   GNUNET_CRYPTO_rsa_key_get_public (hostkey, &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   for (i = 0; i < ITER; i++)
 197   {
 198     fprintf (stderr, ".");
 199     if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_sign (hostkey, &purp, &sig))
 200     {
 201       fprintf (stderr, "GNUNET_CRYPTO_rsa_sign returned SYSERR\n");
 202       ok = GNUNET_SYSERR;
 203       continue;
 204     }
 205     if (GNUNET_SYSERR ==
 206         GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
 207                                   &purp, &sig, &pkey))
 208     {
 209       printf ("GNUNET_CRYPTO_rsa_verify failed!\n");
 210       ok = GNUNET_SYSERR;
 211       continue;
 212     }
 213     if (GNUNET_SYSERR !=
 214         GNUNET_CRYPTO_rsa_verify
 215         (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN, &purp, &sig, &pkey))
 216     {
 217       printf ("GNUNET_CRYPTO_rsa_verify failed to fail!\n");
 218       ok = GNUNET_SYSERR;
 219       continue;
 220     }
 221   }
 222   printf ("%d RSA sign/verify operations %llums\n",
 223           ITER,
 224           (unsigned long long)
 225           GNUNET_TIME_absolute_get_duration (start).rel_value);
 226   return ok;
 227 }
 228
 229
 230 int
 231 main (int argc, char *argv[])
 232 {
 233   int failureCount = 0;
 234   GNUNET_HashCode in;
 235   struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
 236
 237   GNUNET_log_setup ("test-crypto-ksk", "WARNING", NULL);
 238   if (GNUNET_OK != testCorrectKey ())
 239     failureCount++;
 240   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &in);
 241   hostkey = GNUNET_CRYPTO_rsa_key_create_from_hash (&in);
 242   if (hostkey == NULL)
 243   {
 244     printf ("\nGNUNET_CRYPTO_rsa_key_create_from_hash failed!\n");
 245     return 1;
 246   }
 247   if (GNUNET_OK != testMultiKey ("foo"))
 248     failureCount++;
 249   if (GNUNET_OK != testMultiKey ("bar"))
 250     failureCount++;
 251   if (GNUNET_OK != testEncryptDecrypt (hostkey))
 252     failureCount++;
 253   if (GNUNET_OK != testSignVerify (hostkey))
 254     failureCount++;
 255   GNUNET_CRYPTO_rsa_key_free (hostkey);
 256
 257   if (failureCount != 0)
 258   {
 259     printf ("\n\n%d TESTS FAILED!\n\n", failureCount);
 260     return -1;
 261   }
 262   return 0;
 263 }