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 = "010601000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b73c215f7a5e6b09bec55713c901786c09324a150980e014bdb0d04426934929c3b4971a9711af5455536cd6eeb8bfa004ee904972a737455f53c752987d8c82b755bc02882b44950c4acdc1672ba74c3b94d81a4c1ea3d74e7700ae5594c3a4f3c559e4bff2df6844fac302e4b66175e14dc8bad3ce44281d2fec1a1abef06301010000";
  42   GNUNET_HashCode in;
  43   struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
  44   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
  45   int i;
  46   char out[3];
  47
  48   fprintf (stderr, "Testing KBlock key correctness");
  49   GNUNET_CRYPTO_hash ("X", strlen ("X"), &in);
  50   hostkey = GNUNET_CRYPTO_rsa_key_create_from_hash (&in);
  51   if (hostkey == NULL)
  52     {
  53       GNUNET_break (0);
  54       return GNUNET_SYSERR;
  55     }
  56   GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
  57   GNUNET_CRYPTO_rsa_key_free (hostkey);
  58 #if 0
  59   for (i=0;i<sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);i++)
  60     printf("%02x", ((unsigned char*) &pkey)[i]);
  61   printf ("\n");
  62 #endif
  63   for (i=0;i<sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);i++)
  64     {
  65       snprintf(out, sizeof (out), "%02x", ((unsigned char*) &pkey)[i]);
  66       if (0 != strncmp (out, &want[i*2], 2))
  67         {
  68           fprintf (stderr,
  69                    " Failed! Wanted %.2s but got %2s at %d\n",
  70                    &want[i*2],
  71                    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 }