1 files changed, 74 insertions, 49 deletions
diff --git a/src/util/gnunet-crypto-tvg.c b/src/util/gnunet-crypto-tvg.c
index e0ef9a622..c3fead62e 100644
--- a/src/util/gnunet-crypto-tvg.c
+++ b/src/util/gnunet-crypto-tvg.c
@@ -86,50 +86,63 @@ run (void *cls,
    display_data ("  output", &hc, sizeof (struct GNUNET_HashCode));
  }
  {
-    struct GNUNET_CRYPTO_EcdhePrivateKey *priv1;
+    struct GNUNET_CRYPTO_EcdhePrivateKey priv1;
    struct GNUNET_CRYPTO_EcdhePublicKey pub1;
-    struct GNUNET_CRYPTO_EcdhePrivateKey *priv2;
+    struct GNUNET_CRYPTO_EcdhePrivateKey priv2;
    struct GNUNET_HashCode skm;
-    priv1 = GNUNET_CRYPTO_ecdhe_key_create ();
-    priv2 = GNUNET_CRYPTO_ecdhe_key_create ();
+    GNUNET_CRYPTO_ecdhe_key_create (&priv1);
-    GNUNET_CRYPTO_ecdhe_key_get_public (priv1, &pub1);
+    GNUNET_CRYPTO_ecdhe_key_create (&priv2);
-    GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecc_ecdh (priv2, &pub1, &skm));
+    GNUNET_CRYPTO_ecdhe_key_get_public (&priv1,
+                                        &pub1);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CRYPTO_ecc_ecdh (&priv2,
+                                           &pub1,
+                                           &skm));
    printf ("ecdhe key:\n");
-    display_data ("  priv1", priv1, sizeof (struct
+    display_data ("  priv1",
-                                            GNUNET_CRYPTO_EcdhePrivateKey));
+                  &priv1,
-    display_data ("  pub1", &pub1, sizeof (struct
+                  sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
-                                           GNUNET_CRYPTO_EcdhePublicKey));
+    display_data ("  pub1",
-    display_data ("  priv2", priv2, sizeof (struct
+                  &pub1,
-                                            GNUNET_CRYPTO_EcdhePrivateKey));
+                  sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
-    display_data ("  skm", &skm, sizeof (struct GNUNET_HashCode));
+    display_data ("  priv2",
-    GNUNET_free (priv1);
+                  &priv2,
-    GNUNET_free (priv2);
+                  sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
+    display_data ("  skm",
+                  &skm,
+                  sizeof (struct GNUNET_HashCode));
  }
  {
-    struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
+    struct GNUNET_CRYPTO_EddsaPrivateKey priv;
    struct GNUNET_CRYPTO_EddsaPublicKey pub;
-    priv = GNUNET_CRYPTO_eddsa_key_create ();
-    GNUNET_CRYPTO_eddsa_key_get_public (priv, &pub);
+    GNUNET_CRYPTO_eddsa_key_create (&priv);
+    GNUNET_CRYPTO_eddsa_key_get_public (&priv,
+                                        &pub);
    printf ("eddsa key:\n");
-    display_data ("  priv", priv, sizeof (struct
+    display_data ("  priv",
-                                          GNUNET_CRYPTO_EddsaPrivateKey));
+                  &priv,
-    display_data ("  pub", &pub, sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+                  sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
-    GNUNET_free (priv);
+    display_data ("  pub",
+                  &pub,
+                  sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
  }
  {
-    struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
+    struct GNUNET_CRYPTO_EddsaPrivateKey priv;
    struct GNUNET_CRYPTO_EddsaPublicKey pub;
    struct GNUNET_CRYPTO_EddsaSignature sig;
    struct TestSignatureDataPS data = { 0 };
-    priv = GNUNET_CRYPTO_eddsa_key_create ();
+    GNUNET_CRYPTO_eddsa_key_create (&priv);
-    GNUNET_CRYPTO_eddsa_key_get_public (priv, &pub);
+    GNUNET_CRYPTO_eddsa_key_get_public (&priv,
+                                        &pub);
    data.purpose.size = htonl (sizeof (data));
    data.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
-    GNUNET_CRYPTO_eddsa_sign (priv,
+    GNUNET_CRYPTO_eddsa_sign (&priv,
                              &data,
                              &sig);
    GNUNET_assert (GNUNET_OK ==
@@ -139,12 +152,18 @@ run (void *cls,
                                               &pub));
    printf ("eddsa sig:\n");
-    display_data ("  priv", priv, sizeof (struct
+    display_data ("  priv",
-                                          GNUNET_CRYPTO_EddsaPrivateKey));
+                  &priv,
-    display_data ("  pub", &pub, sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+                  sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
-    display_data ("  data", &data, sizeof (struct TestSignatureDataPS));
+    display_data ("  pub",
-    display_data ("  sig", &sig, sizeof (struct GNUNET_CRYPTO_EddsaSignature));
+                  &pub,
-    GNUNET_free (priv);
+                  sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+    display_data ("  data",
+                  &data,
+                  sizeof (struct TestSignatureDataPS));
+    display_data ("  sig",
+                  &sig,
+                  sizeof (struct GNUNET_CRYPTO_EddsaSignature));
  }
  {
@@ -173,28 +192,34 @@ run (void *cls,
    display_data ("  out", out, out_len);
  }
  {
-    struct GNUNET_CRYPTO_EcdhePrivateKey *priv_ecdhe;
+    struct GNUNET_CRYPTO_EcdhePrivateKey priv_ecdhe;
    struct GNUNET_CRYPTO_EcdhePublicKey pub_ecdhe;
-    struct GNUNET_CRYPTO_EddsaPrivateKey *priv_eddsa;
+    struct GNUNET_CRYPTO_EddsaPrivateKey priv_eddsa;
    struct GNUNET_CRYPTO_EddsaPublicKey pub_eddsa;
    struct GNUNET_HashCode key_material;
-    priv_ecdhe = GNUNET_CRYPTO_ecdhe_key_create ();
-    GNUNET_CRYPTO_ecdhe_key_get_public (priv_ecdhe, &pub_ecdhe);
+    GNUNET_CRYPTO_ecdhe_key_create (&priv_ecdhe);
-    priv_eddsa = GNUNET_CRYPTO_eddsa_key_create ();
+    GNUNET_CRYPTO_ecdhe_key_get_public (&priv_ecdhe, &pub_ecdhe);
-    GNUNET_CRYPTO_eddsa_key_get_public (priv_eddsa, &pub_eddsa);
+    GNUNET_CRYPTO_eddsa_key_create (&priv_eddsa);
-    GNUNET_CRYPTO_ecdh_eddsa (priv_ecdhe, &pub_eddsa, &key_material);
+    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", priv_ecdhe, sizeof (struct
+    display_data ("  priv_ecdhe",
-                                                      GNUNET_CRYPTO_EcdhePrivateKey));
+                  &priv_ecdhe,
-    display_data ("  pub_ecdhe", &pub_ecdhe, sizeof (struct
+                  sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
-                                                     GNUNET_CRYPTO_EcdhePublicKey));
+    display_data ("  pub_ecdhe",
-    display_data ("  priv_eddsa", priv_eddsa, sizeof (struct
+                  &pub_ecdhe,
-                                                      GNUNET_CRYPTO_EddsaPrivateKey));
+                  sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
-    display_data ("  pub_eddsa", &pub_eddsa, sizeof (struct
+    display_data ("  priv_eddsa",
-                                                     GNUNET_CRYPTO_EddsaPublicKey));
+                  &priv_eddsa,
-    display_data ("  key_material", &key_material, sizeof (struct
+                  sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
-                                                           GNUNET_HashCode));
+    display_data ("  pub_eddsa",
+                  &pub_eddsa,
+                  sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+    display_data ("  key_material",
+                  &key_material,
+                  sizeof (struct GNUNET_HashCode));
  }
  {

diff --git a/src/util/gnunet-crypto-tvg.c b/src/util/gnunet-crypto-tvg.c index e0ef9a622..c3fead62e 100644 --- a/src/util/gnunet-crypto-tvg.c +++ b/src/util/gnunet-crypto-tvg.c
@@ -86,50 +86,63 @@ run (void *cls,
86	display_data (" output", &hc, sizeof (struct GNUNET_HashCode));	86	display_data (" output", &hc, sizeof (struct GNUNET_HashCode));
87	}	87	}
88	{	88	{
89	struct GNUNET_CRYPTO_EcdhePrivateKey *priv1;	89	struct GNUNET_CRYPTO_EcdhePrivateKey priv1;
90	struct GNUNET_CRYPTO_EcdhePublicKey pub1;	90	struct GNUNET_CRYPTO_EcdhePublicKey pub1;
91	struct GNUNET_CRYPTO_EcdhePrivateKey *priv2;	91	struct GNUNET_CRYPTO_EcdhePrivateKey priv2;
92	struct GNUNET_HashCode skm;	92	struct GNUNET_HashCode skm;
93	priv1 = GNUNET_CRYPTO_ecdhe_key_create ();	93
94	priv2 = GNUNET_CRYPTO_ecdhe_key_create ();	94	GNUNET_CRYPTO_ecdhe_key_create (&priv1);
95	GNUNET_CRYPTO_ecdhe_key_get_public (priv1, &pub1);	95	GNUNET_CRYPTO_ecdhe_key_create (&priv2);
96	GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecc_ecdh (priv2, &pub1, &skm));	96	GNUNET_CRYPTO_ecdhe_key_get_public (&priv1,
		97	&pub1);
		98	GNUNET_assert (GNUNET_OK ==
		99	GNUNET_CRYPTO_ecc_ecdh (&priv2,
		100	&pub1,
		101	&skm));
97		102
98	printf ("ecdhe key:\n");	103	printf ("ecdhe key:\n");
99	display_data (" priv1", priv1, sizeof (struct	104	display_data (" priv1",
100	GNUNET_CRYPTO_EcdhePrivateKey));	105	&priv1,
101	display_data (" pub1", &pub1, sizeof (struct	106	sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
102	GNUNET_CRYPTO_EcdhePublicKey));	107	display_data (" pub1",
103	display_data (" priv2", priv2, sizeof (struct	108	&pub1,
104	GNUNET_CRYPTO_EcdhePrivateKey));	109	sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
105	display_data (" skm", &skm, sizeof (struct GNUNET_HashCode));	110	display_data (" priv2",
106	GNUNET_free (priv1);	111	&priv2,
107	GNUNET_free (priv2);	112	sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
		113	display_data (" skm",
		114	&skm,
		115	sizeof (struct GNUNET_HashCode));
108	}	116	}
109		117
110	{	118	{
111	struct GNUNET_CRYPTO_EddsaPrivateKey *priv;	119	struct GNUNET_CRYPTO_EddsaPrivateKey priv;
112	struct GNUNET_CRYPTO_EddsaPublicKey pub;	120	struct GNUNET_CRYPTO_EddsaPublicKey pub;
113	priv = GNUNET_CRYPTO_eddsa_key_create ();	121
114	GNUNET_CRYPTO_eddsa_key_get_public (priv, &pub);	122	GNUNET_CRYPTO_eddsa_key_create (&priv);
		123	GNUNET_CRYPTO_eddsa_key_get_public (&priv,
		124	&pub);
115		125
116	printf ("eddsa key:\n");	126	printf ("eddsa key:\n");
117	display_data (" priv", priv, sizeof (struct	127	display_data (" priv",
118	GNUNET_CRYPTO_EddsaPrivateKey));	128	&priv,
119	display_data (" pub", &pub, sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));	129	sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
120	GNUNET_free (priv);	130	display_data (" pub",
		131	&pub,
		132	sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
121	}	133	}
122	{	134	{
123	struct GNUNET_CRYPTO_EddsaPrivateKey *priv;	135	struct GNUNET_CRYPTO_EddsaPrivateKey priv;
124	struct GNUNET_CRYPTO_EddsaPublicKey pub;	136	struct GNUNET_CRYPTO_EddsaPublicKey pub;
125	struct GNUNET_CRYPTO_EddsaSignature sig;	137	struct GNUNET_CRYPTO_EddsaSignature sig;
126	struct TestSignatureDataPS data = { 0 };	138	struct TestSignatureDataPS data = { 0 };
127		139
128	priv = GNUNET_CRYPTO_eddsa_key_create ();	140	GNUNET_CRYPTO_eddsa_key_create (&priv);
129	GNUNET_CRYPTO_eddsa_key_get_public (priv, &pub);	141	GNUNET_CRYPTO_eddsa_key_get_public (&priv,
		142	&pub);
130	data.purpose.size = htonl (sizeof (data));	143	data.purpose.size = htonl (sizeof (data));
131	data.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);	144	data.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
132	GNUNET_CRYPTO_eddsa_sign (priv,	145	GNUNET_CRYPTO_eddsa_sign (&priv,
133	&data,	146	&data,
134	&sig);	147	&sig);
135	GNUNET_assert (GNUNET_OK ==	148	GNUNET_assert (GNUNET_OK ==
@@ -139,12 +152,18 @@ run (void *cls,
139	&pub));	152	&pub));
140		153
141	printf ("eddsa sig:\n");	154	printf ("eddsa sig:\n");
142	display_data (" priv", priv, sizeof (struct	155	display_data (" priv",
143	GNUNET_CRYPTO_EddsaPrivateKey));	156	&priv,
144	display_data (" pub", &pub, sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));	157	sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
145	display_data (" data", &data, sizeof (struct TestSignatureDataPS));	158	display_data (" pub",
146	display_data (" sig", &sig, sizeof (struct GNUNET_CRYPTO_EddsaSignature));	159	&pub,
147	GNUNET_free (priv);	160	sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
		161	display_data (" data",
		162	&data,
		163	sizeof (struct TestSignatureDataPS));
		164	display_data (" sig",
		165	&sig,
		166	sizeof (struct GNUNET_CRYPTO_EddsaSignature));
148	}	167	}
149		168
150	{	169	{
@@ -173,28 +192,34 @@ run (void *cls,
173	display_data (" out", out, out_len);	192	display_data (" out", out, out_len);
174	}	193	}
175	{	194	{
176	struct GNUNET_CRYPTO_EcdhePrivateKey *priv_ecdhe;	195	struct GNUNET_CRYPTO_EcdhePrivateKey priv_ecdhe;
177	struct GNUNET_CRYPTO_EcdhePublicKey pub_ecdhe;	196	struct GNUNET_CRYPTO_EcdhePublicKey pub_ecdhe;
178	struct GNUNET_CRYPTO_EddsaPrivateKey *priv_eddsa;	197	struct GNUNET_CRYPTO_EddsaPrivateKey priv_eddsa;
179	struct GNUNET_CRYPTO_EddsaPublicKey pub_eddsa;	198	struct GNUNET_CRYPTO_EddsaPublicKey pub_eddsa;
180	struct GNUNET_HashCode key_material;	199	struct GNUNET_HashCode key_material;
181	priv_ecdhe = GNUNET_CRYPTO_ecdhe_key_create ();	200
182	GNUNET_CRYPTO_ecdhe_key_get_public (priv_ecdhe, &pub_ecdhe);	201	GNUNET_CRYPTO_ecdhe_key_create (&priv_ecdhe);
183	priv_eddsa = GNUNET_CRYPTO_eddsa_key_create ();	202	GNUNET_CRYPTO_ecdhe_key_get_public (&priv_ecdhe, &pub_ecdhe);
184	GNUNET_CRYPTO_eddsa_key_get_public (priv_eddsa, &pub_eddsa);	203	GNUNET_CRYPTO_eddsa_key_create (&priv_eddsa);
185	GNUNET_CRYPTO_ecdh_eddsa (priv_ecdhe, &pub_eddsa, &key_material);	204	GNUNET_CRYPTO_eddsa_key_get_public (&priv_eddsa, &pub_eddsa);
		205	GNUNET_CRYPTO_ecdh_eddsa (&priv_ecdhe, &pub_eddsa, &key_material);
186		206
187	printf ("eddsa_ecdh:\n");	207	printf ("eddsa_ecdh:\n");
188	display_data (" priv_ecdhe", priv_ecdhe, sizeof (struct	208	display_data (" priv_ecdhe",
189	GNUNET_CRYPTO_EcdhePrivateKey));	209	&priv_ecdhe,
190	display_data (" pub_ecdhe", &pub_ecdhe, sizeof (struct	210	sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
191	GNUNET_CRYPTO_EcdhePublicKey));	211	display_data (" pub_ecdhe",
192	display_data (" priv_eddsa", priv_eddsa, sizeof (struct	212	&pub_ecdhe,
193	GNUNET_CRYPTO_EddsaPrivateKey));	213	sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
194	display_data (" pub_eddsa", &pub_eddsa, sizeof (struct	214	display_data (" priv_eddsa",
195	GNUNET_CRYPTO_EddsaPublicKey));	215	&priv_eddsa,
196	display_data (" key_material", &key_material, sizeof (struct	216	sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
197	GNUNET_HashCode));	217	display_data (" pub_eddsa",
		218	&pub_eddsa,
		219	sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
		220	display_data (" key_material",
		221	&key_material,
		222	sizeof (struct GNUNET_HashCode));
198	}	223	}
199		224
200	{	225	{