Update plibc header

[oweals/gnunet.git] / src / util / test_crypto_ecc.c

diff --git a/src/util/test_crypto_ecc.c b/src/util/test_crypto_ecc.c
index 668f15761f313912bad02c3832058209fcde4475..c89568bb9e66a60c3fe450975984298e82021636 100644 (file)
--- a/src/util/test_crypto_ecc.c
+++ b/src/util/test_crypto_ecc.c
@@ -24,18 +24,17 @@
  * @author Christian Grothoff
  */
 #include "platform.h"
-#include "gnunet_common.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_signatures.h"
 #include <gcrypt.h>
 
-#define TESTSTRING "Hello World\0"
-#define MAX_TESTVAL sizeof(struct GNUNET_CRYPTO_AesSessionKey)
 #define ITER 25
+
 #define KEYFILE "/tmp/test-gnunet-crypto-ecc.key"
 
 #define PERF GNUNET_YES
 
+
 static struct GNUNET_CRYPTO_EccPrivateKey *key;
 
 
@@ -44,13 +43,13 @@ testSignVerify ()
 {
   struct GNUNET_CRYPTO_EccSignature sig;
   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
-  struct GNUNET_CRYPTO_EccPublicKey pkey;
+  struct GNUNET_CRYPTO_EccPublicSignKey pkey;
   int i;
   struct GNUNET_TIME_Absolute start;
   int ok = GNUNET_OK;
 
   FPRINTF (stderr, "%s",  "W");
-  GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &pkey);
   start = GNUNET_TIME_absolute_get ();
   purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
   purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
@@ -87,13 +86,67 @@ testSignVerify ()
 }
 
 
+static int
+testDeriveSignVerify ()
+{
+  struct GNUNET_CRYPTO_EccSignature sig;
+  struct GNUNET_CRYPTO_EccSignaturePurpose purp;
+  struct GNUNET_CRYPTO_EccPrivateKey *dpriv;
+  struct GNUNET_CRYPTO_EccPublicSignKey pkey;
+  struct GNUNET_CRYPTO_EccPublicSignKey dpub;
+
+  dpriv = GNUNET_CRYPTO_ecc_key_derive (key, "test-derive", "test-CTX");
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &pkey);
+  GNUNET_CRYPTO_ecc_public_key_derive (&pkey, "test-derive", "test-CTX", &dpub);
+  purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
+  purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
+
+  if (GNUNET_SYSERR == GNUNET_CRYPTO_ecc_sign (dpriv, &purp, &sig))
+  {
+    FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_ecc_sign returned SYSERR\n");
+    GNUNET_free (dpriv);
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_SYSERR ==
+      GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
+                               &purp, &sig,
+                               &dpub))
+  {
+    printf ("GNUNET_CRYPTO_ecc_verify failed!\n");
+    GNUNET_free (dpriv);
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_SYSERR !=
+      GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
+                               &purp, &sig,
+                               &pkey))
+  {
+    printf ("GNUNET_CRYPTO_ecc_verify failed to fail!\n");
+    GNUNET_free (dpriv);
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_SYSERR !=
+      GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
+                               &purp, &sig, &dpub))
+  {
+    printf ("GNUNET_CRYPTO_ecc_verify failed to fail!\n");
+    GNUNET_free (dpriv);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (dpriv);
+  return GNUNET_OK;
+}
+
+
+
+
 #if PERF
 static int
 testSignPerformance ()
 {
   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
   struct GNUNET_CRYPTO_EccSignature sig;
-  struct GNUNET_CRYPTO_EccPublicKey pkey;
+  struct GNUNET_CRYPTO_EccPublicSignKey pkey;
   int i;
   struct GNUNET_TIME_Absolute start;
   int ok = GNUNET_OK;
@@ -101,7 +154,7 @@ testSignPerformance ()
   purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
   purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
   FPRINTF (stderr, "%s",  "W");
-  GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &pkey);
   start = GNUNET_TIME_absolute_get ();
   for (i = 0; i < ITER; i++)
   {
@@ -113,9 +166,9 @@ testSignPerformance ()
       continue;
     }
   }
-  printf ("%d ECC sign operations %llu ms\n", ITER,
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value);
+  printf ("%d ECC sign operations %s\n", ITER,
+          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
+                                                 GNUNET_YES));
   return ok;
 }
 #endif
@@ -124,23 +177,24 @@ testSignPerformance ()
 static int
 testCreateFromFile ()
 {
-  struct GNUNET_CRYPTO_EccPublicKey p1;
-  struct GNUNET_CRYPTO_EccPublicKey p2;
+  struct GNUNET_CRYPTO_EccPublicSignKey p1;
+  struct GNUNET_CRYPTO_EccPublicSignKey p2;
 
   key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE);
   GNUNET_assert (NULL != key);
-  GNUNET_CRYPTO_ecc_key_get_public (key, &p1);
-  GNUNET_CRYPTO_ecc_key_free (key);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &p1);
+  GNUNET_free (key);
   key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE);
   GNUNET_assert (NULL != key);
-  GNUNET_CRYPTO_ecc_key_get_public (key, &p2);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &p2);
   GNUNET_assert (0 == memcmp (&p1, &p2, sizeof (p1)));
-  GNUNET_CRYPTO_ecc_key_free (key);
+  GNUNET_free (key);
   GNUNET_assert (0 == UNLINK (KEYFILE));
   key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE);
   GNUNET_assert (NULL != key);
-  GNUNET_CRYPTO_ecc_key_get_public (key, &p2);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &p2);
   GNUNET_assert (0 != memcmp (&p1, &p2, sizeof (p1)));
+  GNUNET_free (key);
   return GNUNET_OK;
 }
 
@@ -150,21 +204,21 @@ test_ecdh ()
 {
   struct GNUNET_CRYPTO_EccPrivateKey *priv1;
   struct GNUNET_CRYPTO_EccPrivateKey *priv2;
-  struct GNUNET_CRYPTO_EccPublicKey pub1;
-  struct GNUNET_CRYPTO_EccPublicKey pub2;
+  struct GNUNET_CRYPTO_EccPublicEncryptKey pub1;
+  struct GNUNET_CRYPTO_EccPublicEncryptKey pub2;
   struct GNUNET_HashCode ecdh1;
   struct GNUNET_HashCode ecdh2;
 
   priv1 = GNUNET_CRYPTO_ecc_key_create ();
   priv2 = GNUNET_CRYPTO_ecc_key_create ();
-  GNUNET_CRYPTO_ecc_key_get_public (priv1, &pub1);
-  GNUNET_CRYPTO_ecc_key_get_public (priv2, &pub2);
+  GNUNET_CRYPTO_ecc_key_get_public_for_encryption (priv1, &pub1);
+  GNUNET_CRYPTO_ecc_key_get_public_for_encryption (priv2, &pub2);
   GNUNET_CRYPTO_ecc_ecdh (priv1, &pub2, &ecdh1);
   GNUNET_CRYPTO_ecc_ecdh (priv2, &pub1, &ecdh2);
   GNUNET_assert (0 == memcmp (&ecdh1, &ecdh2,
                              sizeof (struct GNUNET_HashCode)));
-  GNUNET_CRYPTO_ecc_key_free (priv1);
-  GNUNET_CRYPTO_ecc_key_free (priv2);
+  GNUNET_free (priv1);
+  GNUNET_free (priv2);
 }
 
 
@@ -180,7 +234,7 @@ perf_keygen ()
   {
     fprintf (stderr, ".");
     pk = GNUNET_CRYPTO_ecc_key_create ();
-    GNUNET_CRYPTO_ecc_key_free (pk);
+    GNUNET_free (pk);
   }
   fprintf (stderr, "\n");
   printf ("Creating 10 ECC keys took %s\n",
@@ -191,9 +245,9 @@ perf_keygen ()
 int
 main (int argc, char *argv[])
 {
-  int failureCount = 0;
+  int failure_count = 0;
 
-  if (!gcry_check_version ("1.5.0"))
+  if (! gcry_check_version ("1.5.0"))
   {
     FPRINTF (stderr,
              _
@@ -202,22 +256,32 @@ main (int argc, char *argv[])
     return 0;
   }
   GNUNET_log_setup ("test-crypto-ecc", "WARNING", NULL);
-  if (GNUNET_OK != testCreateFromFile ())
-    failureCount++;
+  key = GNUNET_CRYPTO_ecc_key_create ();
+  if (GNUNET_OK != testDeriveSignVerify ())
+  {
+    failure_count++;
+    fprintf (stderr,
+            "\n\n%d TESTS FAILED!\n\n", failure_count);
+    return -1;
+  }
 #if PERF
   if (GNUNET_OK != testSignPerformance ())
-    failureCount++;
+    failure_count++;
 #endif
   if (GNUNET_OK != testSignVerify ())
-    failureCount++;
-  GNUNET_CRYPTO_ecc_key_free (key);
+    failure_count++;
+  GNUNET_free (key);
+  if (GNUNET_OK != testCreateFromFile ())
+    failure_count++;
   GNUNET_assert (0 == UNLINK (KEYFILE));
   test_ecdh ();
   perf_keygen ();
 
-  if (failureCount != 0)
+  if (0 != failure_count)
   {
-    printf ("\n\n%d TESTS FAILED!\n\n", failureCount);
+    fprintf (stderr,
+            "\n\n%d TESTS FAILED!\n\n",
+            failure_count);
     return -1;
   }
   return 0;