src/util/test_crypto_symmetric.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2002, 2003, 2004, 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  * @author Christian Grothoff
  23  * @file util/test_crypto_symmetric.c
  24  * @brief test for AES ciphers
  25  */
  26 #include "platform.h"
  27 #include "gnunet_common.h"
  28 #include "gnunet_crypto_lib.h"
  29
  30 #define TESTSTRING "Hello World!"
  31 #define INITVALUE "InitializationVectorValueinitializationvectorvalue"
  32
  33 static int
  34 testSymcipher ()
  35 {
  36   struct GNUNET_CRYPTO_SymmetricSessionKey key;
  37   char result[100];
  38   int size;
  39   char res[100];
  40
  41   GNUNET_CRYPTO_symmetric_create_session_key (&key);
  42   size =
  43       GNUNET_CRYPTO_symmetric_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, &key,
  44                                  (const struct
  45                                   GNUNET_CRYPTO_SymmetricInitializationVector *)
  46                                  INITVALUE, result);
  47   if (size == -1)
  48   {
  49     printf ("symciphertest failed: encryptBlock returned %d\n", size);
  50     return 1;
  51   }
  52   size =
  53       GNUNET_CRYPTO_symmetric_decrypt (result, size, &key,
  54                                  (const struct
  55                                   GNUNET_CRYPTO_SymmetricInitializationVector *)
  56                                  INITVALUE, res);
  57   if (strlen (TESTSTRING) + 1 != size)
  58   {
  59     printf ("symciphertest failed: decryptBlock returned %d\n", size);
  60     return 1;
  61   }
  62   if (0 != strcmp (res, TESTSTRING))
  63   {
  64     printf ("symciphertest failed: %s != %s\n", res, TESTSTRING);
  65     return 1;
  66   }
  67   else
  68     return 0;
  69 }
  70
  71
  72 static int
  73 verifyCrypto ()
  74 {
  75   struct GNUNET_CRYPTO_SymmetricSessionKey key;
  76   char result[GNUNET_CRYPTO_AES_KEY_LENGTH];
  77   char *res;
  78   int ret;
  79
  80   unsigned char plain[] =
  81   {
  82     29, 128, 192, 253, 74, 171, 38, 187, 84, 219, 76, 76, 209, 118, 33, 249,
  83     172, 124, 96, 9, 157, 110, 8, 215, 200, 63, 69, 230, 157, 104, 247, 164
  84   };
  85   unsigned char raw_key_aes[] =
  86   {
  87     106, 74, 209, 88, 145, 55, 189, 135, 125, 180, 225, 108, 183, 54, 25,
  88     169, 129, 188, 131, 75, 227, 245, 105, 10, 225, 15, 115, 159, 148, 184,
  89     34, 191
  90   };
  91   unsigned char raw_key_twofish[] =
  92   {
  93     145, 55, 189, 135, 125, 180, 225, 108, 183, 54, 25,
  94     169, 129, 188, 131, 75, 227, 245, 105, 10, 225, 15, 115, 159, 148, 184,
  95     34, 191, 106, 74, 209, 88
  96   };
  97   unsigned char encrresult[] =
  98   {
  99     161, 152, 186, 231, 214, 55, 225, 206, 85, 43, 80, 134, 145, 198, 20,
 100     233, 236, 57, 194, 10, 147, 149, 30, 106, 179, 54, 182, 247, 71, 204,
 101     179, 51, 1
 102   };
 103
 104   res = NULL;
 105   ret = 0;
 106
 107   memcpy (key.aes_key, raw_key_aes, GNUNET_CRYPTO_AES_KEY_LENGTH);
 108   memcpy (key.twofish_key, raw_key_twofish, GNUNET_CRYPTO_AES_KEY_LENGTH);
 109   if (GNUNET_CRYPTO_AES_KEY_LENGTH !=
 110       GNUNET_CRYPTO_symmetric_encrypt (plain, GNUNET_CRYPTO_AES_KEY_LENGTH, &key,
 111                                  (const struct
 112                                   GNUNET_CRYPTO_SymmetricInitializationVector *)
 113                                  "testtesttesttest", result))
 114   {
 115     printf ("Wrong return value from encrypt block.\n");
 116     ret = 1;
 117     goto error;
 118   }
 119
 120   if (0 != memcmp (encrresult, result, GNUNET_CRYPTO_AES_KEY_LENGTH))
 121   {
 122     int i;
 123     printf ("Encrypted result wrong.\n");
 124     for (i=0;i<GNUNET_CRYPTO_AES_KEY_LENGTH;i++)
 125       printf ("%u, ", (uint8_t) result[i]);
 126     ret = 1;
 127     goto error;
 128   }
 129
 130   res = GNUNET_malloc (GNUNET_CRYPTO_AES_KEY_LENGTH);
 131   if (GNUNET_CRYPTO_AES_KEY_LENGTH !=
 132       GNUNET_CRYPTO_symmetric_decrypt (result, GNUNET_CRYPTO_AES_KEY_LENGTH, &key,
 133                                  (const struct
 134                                   GNUNET_CRYPTO_SymmetricInitializationVector *)
 135                                  "testtesttesttest", res))
 136   {
 137     printf ("Wrong return value from decrypt block.\n");
 138     ret = 1;
 139     goto error;
 140   }
 141   if (0 != memcmp (res, plain, GNUNET_CRYPTO_AES_KEY_LENGTH))
 142   {
 143     printf ("Decrypted result does not match input.\n");
 144     ret = 1;
 145   }
 146 error:
 147   GNUNET_free_non_null (res);
 148   return ret;
 149 }
 150
 151
 152 int
 153 main (int argc, char *argv[])
 154 {
 155   int failureCount = 0;
 156
 157   GNUNET_log_setup ("test-crypto-aes", "WARNING", NULL);
 158   GNUNET_assert (strlen (INITVALUE) >
 159                  sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector));
 160   failureCount += testSymcipher ();
 161   failureCount += verifyCrypto ();
 162
 163   if (failureCount != 0)
 164   {
 165     printf ("%d TESTS FAILED!\n", failureCount);
 166     return -1;
 167   }
 168   return 0;
 169 }
 170
 171 /* end of test_crypto_aes.c */