summaryrefslogtreecommitdiff
path: root/src/util/gnunet-crypto-tvg.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/util/gnunet-crypto-tvg.c')
-rw-r--r--src/util/gnunet-crypto-tvg.c874
1 files changed, 798 insertions, 76 deletions
diff --git a/src/util/gnunet-crypto-tvg.c b/src/util/gnunet-crypto-tvg.c
index c3fead62e..8949f427c 100644
--- a/src/util/gnunet-crypto-tvg.c
+++ b/src/util/gnunet-crypto-tvg.c
@@ -22,11 +22,36 @@
* @file util/gnunet-crypto-tgv.c
* @brief Generate test vectors for cryptographic operations.
* @author Florian Dold
+ *
+ * Note that this program shouldn't depend on code in src/json/,
+ * so we're using raw jansson and no GNUnet JSON helpers.
+ *
+ * Test vectors have the following format (TypeScript pseudo code):
+ *
+ * interface TestVectorFile {
+ * encoding: "base32crockford";
+ * producer?: string;
+ * vectors: TestVector[];
+ * }
+ *
+ * enum Operation {
+ * Hash("hash"),
+ * ...
+ * }
+ *
+ * interface TestVector {
+ * operation: Operation;
+ * // Inputs for the operation
+ * [ k: string]: string | number;
+ * };
+ *
+ *
*/
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_signatures.h"
#include "gnunet_testing_lib.h"
+#include <jansson.h>
#include <gcrypt.h>
GNUNET_NETWORK_STRUCT_BEGIN
@@ -46,46 +71,660 @@ GNUNET_NETWORK_STRUCT_END
/**
- * Print data base32-crockford with a preceding label.
+ * Should we verify or output test vectors?
+ */
+static int verify_flag = GNUNET_NO;
+
+
+/**
+ * Global exit code.
+ */
+static int global_ret = 0;
+
+
+/**
+ * Create a fresh test vector for a given operation label.
+ *
+ * @param vecs array of vectors to append the new vector to
+ * @param vecname label for the operation of the vector
+ * @returns the fresh test vector
+ */
+static json_t *
+vec_for (json_t *vecs, const char *vecname)
+{
+ json_t *t = json_object ();
+
+ json_object_set_new (t,
+ "operation",
+ json_string (vecname));
+ json_array_append_new (vecs, t);
+ return t;
+}
+
+
+/**
+ * Add a base32crockford encoded value
+ * to a test vector.
*
- * @param label label to print
- * @param data data to print
+ * @param vec test vector to add to
+ * @param label label for the value
+ * @param data data to add
* @param size size of data
*/
static void
-display_data (char *label, void *data, size_t size)
+d2j (json_t *vec,
+ const char *label,
+ const void *data,
+ size_t size)
{
- char *enc = GNUNET_STRINGS_data_to_string_alloc (data, size);
- printf ("%s %s\n", label, enc);
- GNUNET_free (enc);
-}
+ char *buf;
+ json_t *json;
+ buf = GNUNET_STRINGS_data_to_string_alloc (data, size);
+ json = json_string (buf);
+ GNUNET_free (buf);
+ GNUNET_break (NULL != json);
+
+ json_object_set_new (vec, label, json);
+}
/**
- * Main function that will be run.
+ * Add a number to a test vector.
*
- * @param cls closure
- * @param args remaining command-line arguments
- * @param cfgfile name of the configuration file used (for saving, can be NULL!)
- * @param cfg configuration
+ * @param vec test vector to add to
+ * @param label label for the value
+ * @param data data to add
+ * @param size size of data
*/
static void
-run (void *cls,
- char *const *args,
- const char *cfgfile,
- const struct GNUNET_CONFIGURATION_Handle *cfg)
+uint2j (json_t *vec,
+ const char *label,
+ unsigned int num)
+{
+ json_t *json = json_integer (num);
+
+ json_object_set_new (vec, label, json);
+}
+
+
+static int
+expect_data_fixed (json_t *vec,
+ const char *name,
+ void *data,
+ size_t expect_len)
+{
+ const char *s = json_string_value (json_object_get (vec, name));
+
+ if (NULL == s)
+ return GNUNET_NO;
+
+ if (GNUNET_OK != GNUNET_STRINGS_string_to_data (s,
+ strlen (s),
+ data,
+ expect_len))
+ return GNUNET_NO;
+ return GNUNET_OK;
+}
+
+static int
+expect_data_dynamic (json_t *vec,
+ const char *name,
+ void **data,
+ size_t *ret_len)
+{
+ const char *s = json_string_value (json_object_get (vec, name));
+ size_t len;
+
+ if (NULL == s)
+ return GNUNET_NO;
+
+ len = (strlen (s) * 5) / 8;
+ if (NULL != ret_len)
+ *ret_len = len;
+ *data = GNUNET_malloc (len);
+
+ if (GNUNET_OK != GNUNET_STRINGS_string_to_data (s, strlen (s), *data, len))
+ return GNUNET_NO;
+ return GNUNET_OK;
+}
+
+
+/**
+ * Check a single vector.
+ *
+ * @param operation operator of the vector
+ * @param vec the vector, a JSON object.
+ *
+ * @returns GNUNET_OK if the vector is okay
+ */
+static int
+checkvec (const char *operation,
+ json_t *vec)
+{
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "checking %s\n", operation);
+
+ if (0 == strcmp (operation, "hash"))
+ {
+ void *data;
+ size_t data_len;
+ struct GNUNET_HashCode hash_out;
+ struct GNUNET_HashCode hc;
+
+ if (GNUNET_OK != expect_data_dynamic (vec,
+ "input",
+ &data,
+ &data_len))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "output",
+ &hash_out,
+ sizeof (hash_out)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ GNUNET_CRYPTO_hash (data, data_len, &hc);
+
+ if (0 != GNUNET_memcmp (&hc, &hash_out))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+ }
+ else if (0 == strcmp (operation, "ecc_ecdh"))
+ {
+ struct GNUNET_CRYPTO_EcdhePrivateKey priv1;
+ struct GNUNET_CRYPTO_EcdhePublicKey pub1;
+ struct GNUNET_CRYPTO_EcdhePrivateKey priv2;
+ struct GNUNET_HashCode skm;
+ struct GNUNET_HashCode skm_comp;
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "priv1",
+ &priv1,
+ sizeof (priv1)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "priv2",
+ &priv2,
+ sizeof (priv2)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "pub1",
+ &pub1,
+ sizeof (pub1)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "skm",
+ &skm,
+ sizeof (skm)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CRYPTO_ecc_ecdh (&priv2,
+ &pub1,
+ &skm_comp));
+ if (0 != GNUNET_memcmp (&skm, &skm_comp))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+ }
+ else if (0 == strcmp (operation, "eddsa_key_derivation"))
+ {
+ struct GNUNET_CRYPTO_EddsaPrivateKey priv;
+ struct GNUNET_CRYPTO_EddsaPublicKey pub;
+ struct GNUNET_CRYPTO_EddsaPublicKey pub_comp;
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "priv",
+ &priv,
+ sizeof (priv)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "pub",
+ &pub,
+ sizeof (pub)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ GNUNET_CRYPTO_eddsa_key_get_public (&priv,
+ &pub_comp);
+ if (0 != GNUNET_memcmp (&pub, &pub_comp))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ }
+ else if (0 == strcmp (operation, "eddsa_signing"))
+ {
+ struct GNUNET_CRYPTO_EddsaPrivateKey priv;
+ struct GNUNET_CRYPTO_EddsaPublicKey pub;
+ struct TestSignatureDataPS data = { 0 };
+ struct GNUNET_CRYPTO_EddsaSignature sig;
+ struct GNUNET_CRYPTO_EddsaSignature sig_comp;
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "priv",
+ &priv,
+ sizeof (priv)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "pub",
+ &pub,
+ sizeof (pub)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "data",
+ &data,
+ sizeof (data)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "sig",
+ &sig,
+ sizeof (sig)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ GNUNET_CRYPTO_eddsa_sign (&priv,
+ &data,
+ &sig_comp);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
+ &data,
+ &sig,
+ &pub));
+ if (0 != GNUNET_memcmp (&sig, &sig_comp))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+ }
+ else if (0 == strcmp (operation, "kdf"))
+ {
+ size_t out_len;
+ void *out;
+ size_t out_len_comp;
+ void *out_comp;
+ void *ikm;
+ size_t ikm_len;
+ void *salt;
+ size_t salt_len;
+ void *ctx;
+ size_t ctx_len;
+
+ if (GNUNET_OK != expect_data_dynamic (vec,
+ "out",
+ &out,
+ &out_len))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+
+ out_len_comp = out_len;
+ out_comp = GNUNET_malloc (out_len_comp);
+
+ if (GNUNET_OK != expect_data_dynamic (vec,
+ "ikm",
+ &ikm,
+ &ikm_len))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+
+ if (GNUNET_OK != expect_data_dynamic (vec,
+ "salt",
+ &salt,
+ &salt_len))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+
+ if (GNUNET_OK != expect_data_dynamic (vec,
+ "ctx",
+ &ctx,
+ &ctx_len))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CRYPTO_kdf (out_comp,
+ out_len_comp,
+ salt,
+ salt_len,
+ ikm,
+ ikm_len,
+ ctx,
+ ctx_len,
+ NULL));
+
+ if (0 != memcmp (out, out_comp, out_len))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ }
+ else if (0 == strcmp (operation, "eddsa_ecdh"))
+ {
+ struct GNUNET_CRYPTO_EcdhePrivateKey priv_ecdhe;
+ struct GNUNET_CRYPTO_EcdhePublicKey pub_ecdhe;
+ struct GNUNET_CRYPTO_EddsaPrivateKey priv_eddsa;
+ struct GNUNET_CRYPTO_EddsaPublicKey pub_eddsa;
+ struct GNUNET_HashCode key_material;
+ struct GNUNET_HashCode key_material_comp;
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "priv_ecdhe",
+ &priv_ecdhe,
+ sizeof (priv_ecdhe)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "pub_ecdhe",
+ &pub_ecdhe,
+ sizeof (pub_ecdhe)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "priv_eddsa",
+ &priv_eddsa,
+ sizeof (priv_eddsa)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "pub_eddsa",
+ &pub_eddsa,
+ sizeof (pub_eddsa)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "key_material",
+ &key_material,
+ sizeof (key_material)))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+
+ GNUNET_CRYPTO_ecdh_eddsa (&priv_ecdhe, &pub_eddsa, &key_material_comp);
+
+ if (0 != GNUNET_memcmp (&key_material, &key_material_comp))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+ }
+ else if (0 == strcmp (operation, "rsa_blind_signing"))
+ {
+ struct GNUNET_CRYPTO_RsaPrivateKey *skey;
+ struct GNUNET_CRYPTO_RsaPublicKey *pkey;
+ struct GNUNET_HashCode message_hash;
+ struct GNUNET_CRYPTO_RsaBlindingKeySecret bks;
+ struct GNUNET_CRYPTO_RsaSignature *blinded_sig;
+ struct GNUNET_CRYPTO_RsaSignature *sig;
+ void *blinded_data;
+ size_t blinded_len;
+ void *blinded_data_comp;
+ size_t blinded_len_comp;
+ void *public_enc_data;
+ size_t public_enc_len;
+ void *secret_enc_data;
+ size_t secret_enc_len;
+ void *sig_enc_data;
+ size_t sig_enc_length;
+ void *sig_enc_data_comp;
+ size_t sig_enc_length_comp;
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "message_hash",
+ &message_hash,
+ sizeof (message_hash)))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+
+ if (GNUNET_OK != expect_data_fixed (vec,
+ "blinding_key_secret",
+ &bks,
+ sizeof (bks)))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+
+ if (GNUNET_OK != expect_data_dynamic (vec,
+ "blinded_message",
+ &blinded_data,
+ &blinded_len))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+
+ if (GNUNET_OK != expect_data_dynamic (vec,
+ "rsa_public_key",
+ &public_enc_data,
+ &public_enc_len))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+
+ if (GNUNET_OK != expect_data_dynamic (vec,
+ "rsa_private_key",
+ &secret_enc_data,
+ &secret_enc_len))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+
+ if (GNUNET_OK != expect_data_dynamic (vec,
+ "sig",
+ &sig_enc_data,
+ &sig_enc_length))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+
+ pkey = GNUNET_CRYPTO_rsa_public_key_decode (public_enc_data,
+ public_enc_len);
+ GNUNET_assert (NULL != pkey);
+ skey = GNUNET_CRYPTO_rsa_private_key_decode (secret_enc_data,
+ secret_enc_len);
+ GNUNET_assert (NULL != skey);
+
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_CRYPTO_rsa_blind (&message_hash,
+ &bks,
+ pkey,
+ &blinded_data_comp,
+ &blinded_len_comp));
+ if ( (blinded_len != blinded_len_comp) || (0 != memcmp (blinded_data,
+ blinded_data_comp,
+ blinded_len)) )
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+ blinded_sig = GNUNET_CRYPTO_rsa_sign_blinded (skey, blinded_data,
+ blinded_len);
+ sig = GNUNET_CRYPTO_rsa_unblind (blinded_sig, &bks, pkey);
+ GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_rsa_verify (&message_hash, sig,
+ pkey));
+ public_enc_len = GNUNET_CRYPTO_rsa_public_key_encode (pkey,
+ &public_enc_data);
+ sig_enc_length_comp = GNUNET_CRYPTO_rsa_signature_encode (sig, &sig_enc_data_comp);
+
+ if ( (sig_enc_length != sig_enc_length_comp) ||
+ (0 != memcmp (sig_enc_data, sig_enc_data_comp, sig_enc_length) ))
+ {
+ GNUNET_break (0);
+ return GNUNET_NO;
+ }
+ }
+ else
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "unsupported operation '%s'\n", operation);
+ }
+
+ return GNUNET_OK;
+}
+
+/**
+ * Check test vectors from stdin.
+ *
+ * @returns global exit code
+ */
+static int
+check_vectors ()
+{
+ json_error_t err;
+ json_t *vecfile = json_loadf (stdin, 0, &err);
+ const char *encoding;
+ json_t *vectors;
+
+ if (NULL == vecfile)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "unable to parse JSON\n");
+ return 1;
+ }
+ encoding = json_string_value (json_object_get (vecfile,
+ "encoding"));
+ if ( (NULL == encoding) || (0 != strcmp (encoding, "base32crockford")) )
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "unsupported or missing encoding\n");
+ json_decref (vecfile);
+ return 1;
+ }
+ vectors = json_object_get (vecfile, "vectors");
+ if (!json_is_array (vectors))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bad vectors\n");
+ json_decref (vecfile);
+ return 1;
+ }
+ {
+ /* array is a JSON array */
+ size_t index;
+ json_t *value;
+ int ret;
+
+ json_array_foreach (vectors, index, value) {
+ const char *op = json_string_value (json_object_get (value,
+ "operation"));
+
+ if (NULL == op)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "missing operation\n");
+ ret = GNUNET_SYSERR;
+ break;
+ }
+ ret = checkvec (op, value);
+ if (GNUNET_OK != ret)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "bad vector %u\n",
+ (unsigned int) index);
+ break;
+ }
+ }
+ return (ret == GNUNET_OK) ? 0 : 1;
+ }
+}
+
+/**
+ * Output test vectors.
+ *
+ * @returns global exit code
+ */
+static int
+output_vectors ()
{
+ json_t *vecfile = json_object ();
+ json_t *vecs = json_array ();
+
+ json_object_set_new (vecfile,
+ "encoding",
+ json_string ("base32crockford"));
+ json_object_set_new (vecfile,
+ "producer",
+ json_string ("GNUnet " PACKAGE_VERSION " " VCS_VERSION));
+ json_object_set_new (vecfile,
+ "vectors",
+ vecs);
+
{
+ json_t *vec = vec_for (vecs, "hash");
struct GNUNET_HashCode hc;
char *str = "Hello, GNUnet";
GNUNET_CRYPTO_hash (str, strlen (str), &hc);
- printf ("hash code:\n");
- display_data (" input", str, strlen (str));
- display_data (" output", &hc, sizeof (struct GNUNET_HashCode));
+ d2j (vec, "input", str, strlen (str));
+ d2j (vec, "output", &hc, sizeof (struct GNUNET_HashCode));
}
{
+ json_t *vec = vec_for (vecs, "ecc_ecdh");
struct GNUNET_CRYPTO_EcdhePrivateKey priv1;
struct GNUNET_CRYPTO_EcdhePublicKey pub1;
struct GNUNET_CRYPTO_EcdhePrivateKey priv2;
@@ -100,22 +739,26 @@ run (void *cls,
&pub1,
&skm));
- printf ("ecdhe key:\n");
- display_data (" priv1",
- &priv1,
- sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
- display_data (" pub1",
- &pub1,
- sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
- display_data (" priv2",
- &priv2,
- sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
- display_data (" skm",
- &skm,
- sizeof (struct GNUNET_HashCode));
+ d2j (vec,
+ "priv1",
+ &priv1,
+ sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
+ d2j (vec,
+ "pub1",
+ &pub1,
+ sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
+ d2j (vec,
+ "priv2",
+ &priv2,
+ sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
+ d2j (vec,
+ "skm",
+ &skm,
+ sizeof (struct GNUNET_HashCode));
}
{
+ json_t *vec = vec_for (vecs, "eddsa_key_derivation");
struct GNUNET_CRYPTO_EddsaPrivateKey priv;
struct GNUNET_CRYPTO_EddsaPublicKey pub;
@@ -123,15 +766,17 @@ run (void *cls,
GNUNET_CRYPTO_eddsa_key_get_public (&priv,
&pub);
- printf ("eddsa key:\n");
- display_data (" priv",
- &priv,
- sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
- display_data (" pub",
- &pub,
- sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+ d2j (vec,
+ "priv",
+ &priv,
+ sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
+ d2j (vec,
+ "pub",
+ &pub,
+ sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
}
{
+ json_t *vec = vec_for (vecs, "eddsa_signing");
struct GNUNET_CRYPTO_EddsaPrivateKey priv;
struct GNUNET_CRYPTO_EddsaPublicKey pub;
struct GNUNET_CRYPTO_EddsaSignature sig;
@@ -151,22 +796,26 @@ run (void *cls,
&sig,
&pub));
- printf ("eddsa sig:\n");
- display_data (" priv",
- &priv,
- sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
- display_data (" pub",
- &pub,
- sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
- display_data (" data",
- &data,
- sizeof (struct TestSignatureDataPS));
- display_data (" sig",
- &sig,
- sizeof (struct GNUNET_CRYPTO_EddsaSignature));
+ d2j (vec,
+ "priv",
+ &priv,
+ sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
+ d2j (vec,
+ "pub",
+ &pub,
+ sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+ d2j (vec,
+ "data",
+ &data,
+ sizeof (struct TestSignatureDataPS));
+ d2j (vec,
+ "sig",
+ &sig,
+ sizeof (struct GNUNET_CRYPTO_EddsaSignature));
}
{
+ json_t *vec = vec_for (vecs, "kdf");
size_t out_len = 64;
char out[out_len];
char *ikm = "I'm the secret input key material";
@@ -184,14 +833,28 @@ run (void *cls,
strlen (ctx),
NULL));
- printf ("kdf:\n");
- display_data (" salt", salt, strlen (salt));
- display_data (" ikm", ikm, strlen (ikm));
- display_data (" ctx", ctx, strlen (ctx));
- printf (" out_len %u\n", (unsigned int) out_len);
- display_data (" out", out, out_len);
+ d2j (vec,
+ "salt",
+ salt,
+ strlen (salt));
+ d2j (vec,
+ "ikm",
+ ikm,
+ strlen (ikm));
+ d2j (vec,
+ "ctx",
+ ctx,
+ strlen (ctx));
+ uint2j (vec,
+ "out_len",
+ (unsigned int) out_len);
+ d2j (vec,
+ "out",
+ out,
+ out_len);
}
{
+ json_t *vec = vec_for (vecs, "eddsa_ecdh");
struct GNUNET_CRYPTO_EcdhePrivateKey priv_ecdhe;
struct GNUNET_CRYPTO_EcdhePublicKey pub_ecdhe;
struct GNUNET_CRYPTO_EddsaPrivateKey priv_eddsa;
@@ -204,25 +867,26 @@ run (void *cls,
GNUNET_CRYPTO_eddsa_key_get_public (&priv_eddsa, &pub_eddsa);
GNUNET_CRYPTO_ecdh_eddsa (&priv_ecdhe, &pub_eddsa, &key_material);
- printf ("eddsa_ecdh:\n");
- display_data (" priv_ecdhe",
+ d2j (vec, "priv_ecdhe",
&priv_ecdhe,
sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
- display_data (" pub_ecdhe",
+ d2j (vec, "pub_ecdhe",
&pub_ecdhe,
sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
- display_data (" priv_eddsa",
+ d2j (vec, "priv_eddsa",
&priv_eddsa,
sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
- display_data (" pub_eddsa",
+ d2j (vec, "pub_eddsa",
&pub_eddsa,
sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
- display_data (" key_material",
+ d2j (vec, "key_material",
&key_material,
sizeof (struct GNUNET_HashCode));
}
{
+ json_t *vec = vec_for (vecs, "rsa_blind_signing");
+
struct GNUNET_CRYPTO_RsaPrivateKey *skey;
struct GNUNET_CRYPTO_RsaPublicKey *pkey;
struct GNUNET_HashCode message_hash;
@@ -233,10 +897,13 @@ run (void *cls,
size_t blinded_len;
void *public_enc_data;
size_t public_enc_len;
+ void *secret_enc_data;
+ size_t secret_enc_len;
void *blinded_sig_enc_data;
size_t blinded_sig_enc_length;
void *sig_enc_data;
size_t sig_enc_length;
+
skey = GNUNET_CRYPTO_rsa_private_key_create (2048);
pkey = GNUNET_CRYPTO_rsa_private_key_get_public (skey);
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
@@ -259,25 +926,75 @@ run (void *cls,
pkey));
public_enc_len = GNUNET_CRYPTO_rsa_public_key_encode (pkey,
&public_enc_data);
+ secret_enc_len = GNUNET_CRYPTO_rsa_private_key_encode (skey,
+ &secret_enc_data);
blinded_sig_enc_length = GNUNET_CRYPTO_rsa_signature_encode (blinded_sig,
&
blinded_sig_enc_data);
sig_enc_length = GNUNET_CRYPTO_rsa_signature_encode (sig, &sig_enc_data);
- printf ("blind signing:\n");
- display_data (" message_hash", &message_hash, sizeof (struct
- GNUNET_HashCode));
- display_data (" rsa_public_key", public_enc_data, public_enc_len);
- display_data (" blinding_key_secret", &bks, sizeof (struct
- GNUNET_CRYPTO_RsaBlindingKeySecret));
- display_data (" blinded_message", blinded_data, blinded_len);
- display_data (" blinded_sig", blinded_sig_enc_data,
- blinded_sig_enc_length);
- display_data (" sig", sig_enc_data, sig_enc_length);
+ d2j (vec,
+ "message_hash",
+ &message_hash,
+ sizeof (struct GNUNET_HashCode));
+ d2j (vec,
+ "rsa_public_key",
+ public_enc_data,
+ public_enc_len);
+ d2j (vec,
+ "rsa_private_key",
+ secret_enc_data,
+ secret_enc_len);
+ d2j (vec,
+ "blinding_key_secret",
+ &bks,
+ sizeof (struct GNUNET_CRYPTO_RsaBlindingKeySecret));
+ d2j (vec,
+ "blinded_message",
+ blinded_data,
+ blinded_len);
+ d2j (vec,
+ "blinded_sig",
+ blinded_sig_enc_data,
+ blinded_sig_enc_length);
+ d2j (vec,
+ "sig",
+ sig_enc_data,
+ sig_enc_length);
GNUNET_CRYPTO_rsa_private_key_free (skey);
GNUNET_CRYPTO_rsa_public_key_free (pkey);
GNUNET_CRYPTO_rsa_signature_free (sig);
GNUNET_CRYPTO_rsa_signature_free (blinded_sig);
+ GNUNET_free (public_enc_data);
+ GNUNET_free (blinded_data);
+ GNUNET_free (sig_enc_data);
+ GNUNET_free (blinded_sig_enc_data);
}
+
+ json_dumpf (vecfile, stdout, JSON_INDENT (2));
+ json_decref (vecfile);
+ printf ("\n");
+
+ return 0;
+}
+
+/**
+ * Main function that will be run.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param cfg configuration
+ */
+static void
+run (void *cls,
+ char *const *args,
+ const char *cfgfile,
+ const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+ if (GNUNET_YES == verify_flag)
+ global_ret = check_vectors ();
+ else
+ global_ret = output_vectors ();
}
@@ -293,6 +1010,11 @@ main (int argc,
char *const *argv)
{
const struct GNUNET_GETOPT_CommandLineOption options[] = {
+ GNUNET_GETOPT_option_flag ('V',
+ "verify",
+ gettext_noop (
+ "verify a test vector from stdin"),
+ &verify_flag),
GNUNET_GETOPT_OPTION_END
};
@@ -307,7 +1029,7 @@ main (int argc,
options,
&run, NULL))
return 1;
- return 0;
+ return global_ret;
}