-clean up test a bit

1 files changed, 159 insertions, 124 deletions

diff --git a/src/util/test_crypto_cs.c b/src/util/test_crypto_cs.c
index d3406516e..f7ac10982 100644
--- a/src/util/test_crypto_cs.c
+++ b/src/util/test_crypto_cs.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet
-   Copyright (C) 2014,2015 GNUnet e.V.
+   Copyright (C) 2021,2022 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -30,148 +30,166 @@
 
 #define ITER 25
 
-void
+static void
 test_create_priv (struct GNUNET_CRYPTO_CsPrivateKey *priv)
 {
   /* TEST 1
    * Check that privkey is set
    */
   struct GNUNET_CRYPTO_CsPrivateKey other_priv;
-  memcpy (&other_priv.scalar, &priv->scalar, sizeof(other_priv.scalar));
 
+  other_priv = *priv;
   GNUNET_CRYPTO_cs_private_key_generate (priv);
-
-  GNUNET_assert (0 != memcmp (&other_priv.scalar,
-                              &priv->scalar,
-                              sizeof(other_priv.scalar)));
+  GNUNET_assert (0 !=
+                 GNUNET_memcmp (&other_priv.scalar,
+                                &priv->scalar));
 }
 
 
-void
+static void
 test_generate_pub (const struct GNUNET_CRYPTO_CsPrivateKey *priv,
-                       struct GNUNET_CRYPTO_CsPublicKey *pub)
+                   struct GNUNET_CRYPTO_CsPublicKey *pub)
 {
   /* TEST 1
    * Check that pubkey is set
    */
   struct GNUNET_CRYPTO_CsPublicKey other_pub;
-  memcpy (&other_pub.point, &pub->point, sizeof(other_pub.point));
-
-  GNUNET_CRYPTO_cs_private_key_get_public (priv, pub);
 
-  GNUNET_assert (0 != memcmp (&other_pub.point,
-                              &pub->point,
-                              sizeof(other_pub.point)));
+  other_pub = *pub;
+  GNUNET_CRYPTO_cs_private_key_get_public (priv,
+                                           pub);
+  GNUNET_assert (0 !=
+                 GNUNET_memcmp (&other_pub.point,
+                                &pub->point));
 
   /* TEST 2
    * Check that pubkey is a valid point
    */
-  GNUNET_assert (1 == crypto_core_ed25519_is_valid_point (pub->point.y));
+  GNUNET_assert (1 ==
+                 crypto_core_ed25519_is_valid_point (pub->point.y));
 
   /* TEST 3
    * Check if function gives the same result for the same output
    */
-  memcpy (&other_pub.point, &pub->point, sizeof(other_pub.point));
-
-  for (int i = 0; i<ITER; i++) {
-    GNUNET_CRYPTO_cs_private_key_get_public (priv, pub);
-    GNUNET_assert (0 == memcmp (&other_pub.point,
-                                &pub->point,
-                                sizeof(other_pub.point)));
+  other_pub = *pub;
+  for (unsigned int i = 0; i<ITER; i++)
+  {
+    GNUNET_CRYPTO_cs_private_key_get_public (priv,
+                                             pub);
+    GNUNET_assert (0 ==
+                   GNUNET_memcmp (&other_pub.point,
+                                  &pub->point));
   }
 }
 
 
-void
+static void
 test_derive_rsecret (const struct GNUNET_CRYPTO_CsNonce *nonce,
-                   const struct GNUNET_CRYPTO_CsPrivateKey *priv,
-                   struct GNUNET_CRYPTO_CsRSecret r[2])
+                     const struct GNUNET_CRYPTO_CsPrivateKey *priv,
+                     struct GNUNET_CRYPTO_CsRSecret r[2])
 {
   /* TEST 1
    * Check that r are set
    */
   struct GNUNET_CRYPTO_CsPrivateKey other_r[2];
-  memcpy (&other_r[0], &r[0], sizeof(struct GNUNET_CRYPTO_CsPrivateKey) * 2);
 
-  GNUNET_CRYPTO_cs_r_derive (nonce, priv, r);
-
-  GNUNET_assert (0 != memcmp (&other_r[0],
-                              &r[0],
-                              sizeof(struct GNUNET_CRYPTO_CsPrivateKey) * 2));
+  memcpy (other_r,
+          r,
+          sizeof(struct GNUNET_CRYPTO_CsPrivateKey) * 2);
+  GNUNET_CRYPTO_cs_r_derive (nonce,
+                             priv,
+                             r);
+  GNUNET_assert (0 !=
+                 memcmp (&other_r[0],
+                         &r[0],
+                         sizeof(struct GNUNET_CRYPTO_CsPrivateKey) * 2));
 
   /* TEST 2
    * Check if function gives the same result for the same input.
    * This test ensures that the derivation is deterministic.
    */
-  memcpy (&other_r[0], &r[0], sizeof(struct GNUNET_CRYPTO_CsPrivateKey) * 2);
-  for (int i = 0; i<ITER; i++) {
-    GNUNET_CRYPTO_cs_r_derive (nonce, priv, r);
-    GNUNET_assert (0 == memcmp (&other_r[0],
-                                &r[0],
-                                sizeof(struct GNUNET_CRYPTO_CsPrivateKey) * 2));
+  memcpy (other_r,
+          r,
+          sizeof(struct GNUNET_CRYPTO_CsPrivateKey) * 2);
+  for (unsigned int i = 0; i<ITER; i++)
+  {
+    GNUNET_CRYPTO_cs_r_derive (nonce,
+                               priv,
+                               r);
+    GNUNET_assert (0 ==
+                   memcmp (other_r,
+                           r,
+                           sizeof(struct GNUNET_CRYPTO_CsPrivateKey) * 2));
   }
 }
 
 
-void
+static void
 test_generate_rpublic (const struct GNUNET_CRYPTO_CsRSecret *r_priv,
-                     struct GNUNET_CRYPTO_CsRPublic *r_pub)
+                       struct GNUNET_CRYPTO_CsRPublic *r_pub)
 {
   /* TEST 1
    * Check that r_pub is set
    */
   struct GNUNET_CRYPTO_CsRPublic other_r_pub;
-  memcpy (&other_r_pub.point, &r_pub->point, sizeof(other_r_pub.point));
-
-  GNUNET_CRYPTO_cs_r_get_public (r_priv, r_pub);
-
-  GNUNET_assert (0 != memcmp (&other_r_pub.point,
-                              &r_pub->point,
-                              sizeof(other_r_pub.point)));
 
+  other_r_pub = *r_pub;
+  GNUNET_CRYPTO_cs_r_get_public (r_priv,
+                                 r_pub);
+  GNUNET_assert (0 !=
+                 GNUNET_memcmp (&other_r_pub.point,
+                                &r_pub->point));
   /* TEST 2
    * Check that r_pub is a valid point
    */
-  GNUNET_assert (1 == crypto_core_ed25519_is_valid_point (r_pub->point.y));
+  GNUNET_assert (1 ==
+                 crypto_core_ed25519_is_valid_point (r_pub->point.y));
 
   /* TEST 3
    * Check if function gives the same result for the same output
    */
-  memcpy (&other_r_pub.point, &r_pub->point, sizeof(other_r_pub.point));
-  for (int i = 0; i<ITER; i++) {
-    GNUNET_CRYPTO_cs_r_get_public (r_priv, r_pub);
-    GNUNET_assert (0 == memcmp (&other_r_pub.point,
-                                &r_pub->point,
-                                sizeof(other_r_pub.point)));
+  other_r_pub.point = r_pub->point;
+  for (int i = 0; i<ITER; i++)
+  {
+    GNUNET_CRYPTO_cs_r_get_public (r_priv,
+                                   r_pub);
+    GNUNET_assert (0 ==
+                   GNUNET_memcmp (&other_r_pub.point,
+                                  &r_pub->point));
   }
 }
 
 
-void
+static void
 test_derive_blindingsecrets (const struct GNUNET_CRYPTO_CsNonce *blind_seed,
-                           struct GNUNET_CRYPTO_CsBlindingSecret bs[2])
+                             struct GNUNET_CRYPTO_CsBlindingSecret bs[2])
 {
   /* TEST 1
    * Check that blinding secrets are set
    */
   struct GNUNET_CRYPTO_CsBlindingSecret other_bs[2];
-  memcpy (&other_bs[0], &bs[0], sizeof(struct GNUNET_CRYPTO_CsBlindingSecret)
-          * 2);
+
+  memcpy (other_bs,
+          bs,
+          sizeof(struct GNUNET_CRYPTO_CsBlindingSecret) * 2);
 
   GNUNET_CRYPTO_cs_blinding_secrets_derive (blind_seed, bs);
 
-  GNUNET_assert (0 != memcmp (&other_bs[0],
-                              &bs[0],
-                              sizeof(struct GNUNET_CRYPTO_CsBlindingSecret)
-                              * 2));
+  GNUNET_assert (0 !=
+                 memcmp (other_bs,
+                         bs,
+                         sizeof(struct GNUNET_CRYPTO_CsBlindingSecret)
+                         * 2));
 
   /* TEST 2
    * Check if function gives the same result for the same input.
    * This test ensures that the derivation is deterministic.
    */
-  memcpy (&other_bs[0], &bs[0], sizeof(struct GNUNET_CRYPTO_CsBlindingSecret)
-          * 2);
-  for (int i = 0; i<ITER; i++) {
+  memcpy (other_bs,
+          bs,
+          sizeof(struct GNUNET_CRYPTO_CsBlindingSecret) * 2);
+  for (unsigned int i = 0; i<ITER; i++)
+  {
     GNUNET_CRYPTO_cs_blinding_secrets_derive (blind_seed, bs);
     GNUNET_assert (0 == memcmp (&other_bs[0],
                                 &bs[0],
@@ -181,19 +199,20 @@ test_derive_blindingsecrets (const struct GNUNET_CRYPTO_CsNonce *blind_seed,
 }
 
 
-void
+static void
 test_calc_blindedc (const struct GNUNET_CRYPTO_CsBlindingSecret bs[2],
-                  const struct GNUNET_CRYPTO_CsRPublic r_pub[2],
-                  const struct GNUNET_CRYPTO_CsPublicKey *pub,
-                  const void *msg,
-                  size_t msg_len,
-                  struct GNUNET_CRYPTO_CsC blinded_cs[2],
-                  struct GNUNET_CRYPTO_CsRPublic blinded_r_pub[2])
+                    const struct GNUNET_CRYPTO_CsRPublic r_pub[2],
+                    const struct GNUNET_CRYPTO_CsPublicKey *pub,
+                    const void *msg,
+                    size_t msg_len,
+                    struct GNUNET_CRYPTO_CsC blinded_cs[2],
+                    struct GNUNET_CRYPTO_CsRPublic blinded_r_pub[2])
 {
   /* TEST 1
    * Check that the blinded c's and blinded r's
    */
   struct GNUNET_CRYPTO_CsC other_blinded_c[2];
+
   memcpy (&other_blinded_c[0],
           &blinded_cs[0],
           sizeof(struct GNUNET_CRYPTO_CsC) * 2);
@@ -222,7 +241,8 @@ test_calc_blindedc (const struct GNUNET_CRYPTO_CsBlindingSecret bs[2],
    * Check if R' - aG -bX = R for b = 0
    * This test does the opposite operations and checks wether the equation is still correct.
    */
-  for (unsigned int b = 0; b <= 1; b++) {
+  for (unsigned int b = 0; b <= 1; b++)
+  {
     struct GNUNET_CRYPTO_Cs25519Point aG;
     struct GNUNET_CRYPTO_Cs25519Point bX;
     struct GNUNET_CRYPTO_Cs25519Point r_min_aG;
@@ -252,7 +272,6 @@ test_calc_blindedc (const struct GNUNET_CRYPTO_CsBlindingSecret bs[2],
   }
 
 
-
   /* TEST 3
    * Check that the blinded r_pubs' are valid points
    */
@@ -271,7 +290,8 @@ test_calc_blindedc (const struct GNUNET_CRYPTO_CsBlindingSecret bs[2],
           &blinded_r_pub[0],
           sizeof(struct GNUNET_CRYPTO_CsRPublic) * 2);
 
-  for (int i = 0; i<ITER; i++) {
+  for (unsigned int i = 0; i<ITER; i++)
+  {
     GNUNET_CRYPTO_cs_calc_blinded_c (bs,
                                      r_pub,
                                      pub,
@@ -289,13 +309,13 @@ test_calc_blindedc (const struct GNUNET_CRYPTO_CsBlindingSecret bs[2],
 }
 
 
-void
+static void
 test_blind_sign (unsigned int *b,
-               const struct GNUNET_CRYPTO_CsPrivateKey *priv,
-               const struct GNUNET_CRYPTO_CsRSecret r[2],
-               const struct GNUNET_CRYPTO_CsC c[2],
-               const struct GNUNET_CRYPTO_CsNonce *nonce,
-               struct GNUNET_CRYPTO_CsBlindS *blinded_s)
+                 const struct GNUNET_CRYPTO_CsPrivateKey *priv,
+                 const struct GNUNET_CRYPTO_CsRSecret r[2],
+                 const struct GNUNET_CRYPTO_CsC c[2],
+                 const struct GNUNET_CRYPTO_CsNonce *nonce,
+                 struct GNUNET_CRYPTO_CsBlindS *blinded_s)
 {
   /* TEST 1
    * Check that blinded_s is set
@@ -336,8 +356,10 @@ test_blind_sign (unsigned int *b,
    * Check if function gives the same result for the same input.
    */
   memcpy (&other_blinded_s, blinded_s, sizeof(struct GNUNET_CRYPTO_CsBlindS));
-  unsigned int other_b;
-  for (int i = 0; i<ITER; i++) {
+  for (unsigned int i = 0; i<ITER; i++)
+  {
+    unsigned int other_b;
+
     other_b = GNUNET_CRYPTO_cs_sign_derive (priv, r, c, nonce, blinded_s);
 
     GNUNET_assert (other_b == *b);
@@ -348,10 +370,10 @@ test_blind_sign (unsigned int *b,
 }
 
 
-void
+static void
 test_unblinds (const struct GNUNET_CRYPTO_CsBlindS *blinded_signature_scalar,
-              const struct GNUNET_CRYPTO_CsBlindingSecret *bs,
-              struct GNUNET_CRYPTO_CsS *signature_scalar)
+               const struct GNUNET_CRYPTO_CsBlindingSecret *bs,
+               struct GNUNET_CRYPTO_CsS *signature_scalar)
 {
   /* TEST 1
    * Check that signature_scalar is set
@@ -387,7 +409,8 @@ test_unblinds (const struct GNUNET_CRYPTO_CsBlindS *blinded_signature_scalar,
   memcpy (&other_signature_scalar, signature_scalar,
           sizeof(struct GNUNET_CRYPTO_CsS));
 
-  for (int i = 0; i<ITER; i++) {
+  for (unsigned int i = 0; i<ITER; i++)
+  {
     GNUNET_CRYPTO_cs_unblind (blinded_signature_scalar, bs, signature_scalar);
     GNUNET_assert (0 == memcmp (&other_signature_scalar,
                                 signature_scalar,
@@ -396,10 +419,10 @@ test_unblinds (const struct GNUNET_CRYPTO_CsBlindS *blinded_signature_scalar,
 }
 
 
-void
+static void
 test_blind_verify (const struct GNUNET_CRYPTO_CsSignature *sig,
-                 const struct GNUNET_CRYPTO_CsPublicKey *pub,
-                 const struct GNUNET_CRYPTO_CsC *c)
+                   const struct GNUNET_CRYPTO_CsPublicKey *pub,
+                   const struct GNUNET_CRYPTO_CsC *c)
 {
   /* TEST 1
    * Test verifies the blinded signature sG == Rb + cbX
@@ -425,28 +448,30 @@ test_blind_verify (const struct GNUNET_CRYPTO_CsSignature *sig,
 }
 
 
-void
+static void
 test_verify (const struct GNUNET_CRYPTO_CsSignature *sig,
-            const struct GNUNET_CRYPTO_CsPublicKey *pub,
-            const void *msg,
-            size_t msg_len)
+             const struct GNUNET_CRYPTO_CsPublicKey *pub,
+             const void *msg,
+             size_t msg_len)
 {
   /* TEST 1
    * Test simple verification
    */
-  GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_cs_verify (sig,
-                                                        pub,
-                                                        msg,
-                                                        msg_len));
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CRYPTO_cs_verify (sig,
+                                          pub,
+                                          msg,
+                                          msg_len));
   /* TEST 2
    * Test verification of "wrong" message
    */
   char other_msg[] = "test massege";
   size_t other_msg_len = strlen ("test massege");
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_CRYPTO_cs_verify (sig,
-                                                       pub,
-                                                       other_msg,
-                                                       other_msg_len));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_CRYPTO_cs_verify (sig,
+                                          pub,
+                                          other_msg,
+                                          other_msg_len));
 }
 
 
@@ -468,16 +493,15 @@ main (int argc,
 
   // derive nonce
   struct GNUNET_CRYPTO_CsNonce nonce;
-  GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_hkdf (nonce.nonce,
-                                                   sizeof(nonce.nonce),
-                                                   GCRY_MD_SHA512,
-                                                   GCRY_MD_SHA256,
-                                                   "nonce",
-                                                   strlen ("nonce"),
-                                                   "nonce_secret",
-                                                   strlen ("nonce_secret"),
-                                                   NULL,
-                                                   0));
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CRYPTO_kdf (nonce.nonce,
+                                    sizeof(nonce.nonce),
+                                    "nonce",
+                                    strlen ("nonce"),
+                                    "nonce_secret",
+                                    strlen ("nonce_secret"),
+                                    NULL,
+                                    0));
 
   // generate r, R
   struct GNUNET_CRYPTO_CsRSecret r_secrets[2];
@@ -498,34 +522,45 @@ main (int argc,
   struct GNUNET_CRYPTO_CsC blinded_cs[2];
   struct GNUNET_CRYPTO_CsRPublic blinded_r_pubs[2];
   test_calc_blindedc (blindingsecrets,
-                    r_publics,
-                    &pub,
-                    message,
-                    message_len,
-                    blinded_cs,
-                    blinded_r_pubs);
+                      r_publics,
+                      &pub,
+                      message,
+                      message_len,
+                      blinded_cs,
+                      blinded_r_pubs);
 
   // ---------- actions performed by signer
   // sign blinded c's and get b and s in return
   unsigned int b;
   struct GNUNET_CRYPTO_CsBlindS blinded_s;
-  test_blind_sign (&b, &priv, r_secrets, blinded_cs, &nonce, &blinded_s);
+  test_blind_sign (&b,
+                   &priv,
+                   r_secrets,
+                   blinded_cs,
+                   &nonce,
+                   &blinded_s);
 
   // verify blinded signature
   struct GNUNET_CRYPTO_CsSignature blinded_signature;
   blinded_signature.r_point = r_publics[b];
   blinded_signature.s_scalar.scalar = blinded_s.scalar;
-  test_blind_verify (&blinded_signature, &pub, &blinded_cs[b]);
+  test_blind_verify (&blinded_signature,
+                     &pub,
+                     &blinded_cs[b]);
 
   // ---------- actions performed by user
-    struct GNUNET_CRYPTO_CsS sig_scalar;
-  test_unblinds (&blinded_s, &blindingsecrets[b], &sig_scalar);
+  struct GNUNET_CRYPTO_CsS sig_scalar;
+  test_unblinds (&blinded_s,
+                 &blindingsecrets[b],
+                 &sig_scalar);
 
   // verify unblinded signature
   struct GNUNET_CRYPTO_CsSignature signature;
   signature.r_point = blinded_r_pubs[b];
   signature.s_scalar = sig_scalar;
-  test_verify (&signature, &pub, message, message_len);
-
+  test_verify (&signature,
+               &pub,
+               message,
+               message_len);
   return 0;
 }