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, "%s",  "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, " Failed! Wanted %.2s but got %2s at %d\n", &want[i * 2],
  70                out, i);
  71       return GNUNET_SYSERR;
  72     }
  73   }
  74   FPRINTF (stderr, "%s",  " OK\n");
  75   return GNUNET_OK;
  76 }
  77
  78
  79 static int
  80 testMultiKey (const char *word)
  81 {
  82   GNUNET_HashCode in;
  83   struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
  84   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
  85   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey1;
  86   int i;
  87
  88   FPRINTF (stderr, "Testing KBlock key uniqueness (%s) ", word);
  89   GNUNET_CRYPTO_hash (word, strlen (word), &in);
  90   hostkey = GNUNET_CRYPTO_rsa_key_create_from_hash (&in);
  91   if (hostkey == NULL)
  92   {
  93     GNUNET_break (0);
  94     return GNUNET_SYSERR;
  95   }
  96   GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
  97   /*
  98    * for (i=0;i<sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);i++)
  99    * printf("%02x", ((unsigned char*) &pkey)[i]);
 100    * printf("\n"); */
 101   GNUNET_CRYPTO_rsa_key_free (hostkey);
 102   for (i = 0; i < UNIQUE_ITER; i++)
 103   {
 104     FPRINTF (stderr, "%s",  ".");
 105     hostkey = GNUNET_CRYPTO_rsa_key_create_from_hash (&in);
 106     if (hostkey == NULL)
 107     {
 108       GNUNET_break (0);
 109       FPRINTF (stderr, "%s",  " ERROR\n");
 110       return GNUNET_SYSERR;
 111     }
 112     GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey1);
 113     GNUNET_CRYPTO_rsa_key_free (hostkey);
 114     if (0 !=
 115         memcmp (&pkey, &pkey1,
 116                 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)))
 117     {
 118       GNUNET_break (0);
 119       FPRINTF (stderr, "%s",  " ERROR\n");
 120       return GNUNET_SYSERR;
 121     }
 122   }
 123   FPRINTF (stderr, "%s",  " OK\n");
 124   return GNUNET_OK;
 125 }
 126
 127
 128 static int
 129 testEncryptDecrypt (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
 130 {
 131   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
 132   struct GNUNET_CRYPTO_RsaEncryptedData target;
 133   char result[MAX_TESTVAL];
 134   int i;
 135   struct GNUNET_TIME_Absolute start;
 136   int ok;
 137
 138   FPRINTF (stderr, "%s",  "W");
 139   GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
 140
 141   ok = 0;
 142   start = GNUNET_TIME_absolute_get ();
 143   for (i = 0; i < ITER; i++)
 144   {
 145     FPRINTF (stderr, "%s",  ".");
 146     if (GNUNET_SYSERR ==
 147         GNUNET_CRYPTO_rsa_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, &pkey,
 148                                    &target))
 149     {
 150       FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
 151       ok++;
 152       continue;
 153     }
 154     if (-1 ==
 155         GNUNET_CRYPTO_rsa_decrypt (hostkey, &target, result,
 156                                    strlen (TESTSTRING) + 1))
 157     {
 158       FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
 159       ok++;
 160       continue;
 161     }
 162     if (strncmp (TESTSTRING, result, strlen (TESTSTRING)) != 0)
 163     {
 164       printf ("%s != %.*s - testEncryptDecrypt failed!\n", TESTSTRING,
 165               MAX_TESTVAL, result);
 166       ok++;
 167       continue;
 168     }
 169   }
 170   printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n", ITER,
 171           (unsigned long long)
 172           GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
 173   if (ok == 0)
 174     return GNUNET_OK;
 175   else
 176     return GNUNET_SYSERR;
 177 }
 178
 179 static int
 180 testSignVerify (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
 181 {
 182   struct GNUNET_CRYPTO_RsaSignature sig;
 183   struct GNUNET_CRYPTO_RsaSignaturePurpose purp;
 184   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
 185   int i;
 186   struct GNUNET_TIME_Absolute start;
 187   int ok = GNUNET_OK;
 188
 189   FPRINTF (stderr, "%s",  "W");
 190   GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
 191   start = GNUNET_TIME_absolute_get ();
 192   purp.size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose));
 193   purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
 194   for (i = 0; i < ITER; i++)
 195   {
 196     FPRINTF (stderr, "%s",  ".");
 197     if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_sign (hostkey, &purp, &sig))
 198     {
 199       FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_rsa_sign returned SYSERR\n");
 200       ok = GNUNET_SYSERR;
 201       continue;
 202     }
 203     if (GNUNET_SYSERR ==
 204         GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST, &purp, &sig,
 205                                   &pkey))
 206     {
 207       printf ("GNUNET_CRYPTO_rsa_verify failed!\n");
 208       ok = GNUNET_SYSERR;
 209       continue;
 210     }
 211     if (GNUNET_SYSERR !=
 212         GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
 213                                   &purp, &sig, &pkey))
 214     {
 215       printf ("GNUNET_CRYPTO_rsa_verify failed to fail!\n");
 216       ok = GNUNET_SYSERR;
 217       continue;
 218     }
 219   }
 220   printf ("%d RSA sign/verify operations %llums\n", ITER,
 221           (unsigned long long)
 222           GNUNET_TIME_absolute_get_duration (start).rel_value);
 223   return ok;
 224 }
 225
 226
 227 int
 228 main (int argc, char *argv[])
 229 {
 230   int failureCount = 0;
 231   GNUNET_HashCode in;
 232   struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
 233
 234   GNUNET_log_setup ("test-crypto-ksk", "WARNING", NULL);
 235   if (GNUNET_OK != testCorrectKey ())
 236     failureCount++;
 237   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &in);
 238   hostkey = GNUNET_CRYPTO_rsa_key_create_from_hash (&in);
 239   if (hostkey == NULL)
 240   {
 241     printf ("\nGNUNET_CRYPTO_rsa_key_create_from_hash failed!\n");
 242     return 1;
 243   }
 244   if (GNUNET_OK != testMultiKey ("foo"))
 245     failureCount++;
 246   if (GNUNET_OK != testMultiKey ("bar"))
 247     failureCount++;
 248   if (GNUNET_OK != testEncryptDecrypt (hostkey))
 249     failureCount++;
 250   if (GNUNET_OK != testSignVerify (hostkey))
 251     failureCount++;
 252   GNUNET_CRYPTO_rsa_key_free (hostkey);
 253
 254   if (failureCount != 0)
 255   {
 256     printf ("\n\n%d TESTS FAILED!\n\n", failureCount);
 257     return -1;
 258   }
 259   return 0;
 260 }