1 files changed, 111 insertions, 75 deletions
diff --git a/src/util/gnunet-crypto-tvg.c b/src/util/gnunet-crypto-tvg.c
index 7d151c10b..c3fead62e 100644
--- a/src/util/gnunet-crypto-tvg.c
+++ b/src/util/gnunet-crypto-tvg.c
@@ -86,62 +86,84 @@ 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_get_public (priv, &pub);
+    GNUNET_CRYPTO_eddsa_key_create (&priv);
-    data.purpose.size = htonl (sizeof (struct TestSignatureDataPS));
+    GNUNET_CRYPTO_eddsa_key_get_public (&priv,
-    data.purpose.size = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
+                                        &pub);
-    GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (priv, &data.purpose,
+    data.purpose.size = htonl (sizeof (data));
-                                                          &sig));
+    data.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
-    GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_verify (0,
+    GNUNET_CRYPTO_eddsa_sign (&priv,
-                                                            &data.purpose,
+                              &data,
-                                                            &sig,
+                              &sig);
-                                                            &pub));
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
+                                               &data,
+                                               &sig,
+                                               &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));
  }
  {
@@ -151,15 +173,16 @@ run (void *cls,
    char *salt = "I'm very salty";
    char *ctx = "I'm a context chunk, also known as 'info' in the RFC";
-    GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_kdf (&out,
+    GNUNET_assert (GNUNET_OK ==
-                                                   out_len,
+                   GNUNET_CRYPTO_kdf (&out,
-                                                   salt,
+                                      out_len,
-                                                   strlen (salt),
+                                      salt,
-                                                   ikm,
+                                      strlen (salt),
-                                                   strlen (ikm),
+                                      ikm,
-                                                   ctx,
+                                      strlen (ikm),
-                                                   strlen (ctx),
+                                      ctx,
-                                                   NULL));
+                                      strlen (ctx),
+                                      NULL));
    printf ("kdf:\n");
    display_data ("  salt", salt, strlen (salt));
@@ -169,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));
  }
  {
@@ -200,23 +229,29 @@ run (void *cls,
    struct GNUNET_CRYPTO_RsaBlindingKeySecret bks;
    struct GNUNET_CRYPTO_RsaSignature *blinded_sig;
    struct GNUNET_CRYPTO_RsaSignature *sig;
-    char *blinded_data;
+    void *blinded_data;
    size_t blinded_len;
-    char *public_enc_data;
+    void *public_enc_data;
    size_t public_enc_len;
-    char *blinded_sig_enc_data;
+    void *blinded_sig_enc_data;
    size_t blinded_sig_enc_length;
-    char *sig_enc_data;
+    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, &message_hash,
+    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+                                &message_hash,
                                sizeof (struct GNUNET_HashCode));
-    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, &bks, sizeof (struct
+    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                                                                          GNUNET_CRYPTO_RsaBlindingKeySecret));
+                                &bks,
-    GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_rsa_blind (&message_hash, &bks,
+                                sizeof (struct
-                                                          pkey, &blinded_data,
+                                        GNUNET_CRYPTO_RsaBlindingKeySecret));
-                                                          &blinded_len));
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CRYPTO_rsa_blind (&message_hash,
+                                            &bks,
+                                            pkey,
+                                            &blinded_data,
+                                            &blinded_len));
    blinded_sig = GNUNET_CRYPTO_rsa_sign_blinded (skey, blinded_data,
                                                  blinded_len);
    sig = GNUNET_CRYPTO_rsa_unblind (blinded_sig, &bks, pkey);
@@ -275,4 +310,5 @@ main (int argc,
  return 0;
 }
 /* end of gnunet-crypto-tvg.c */

diff --git a/src/util/gnunet-crypto-tvg.c b/src/util/gnunet-crypto-tvg.c index 7d151c10b..c3fead62e 100644 --- a/src/util/gnunet-crypto-tvg.c +++ b/src/util/gnunet-crypto-tvg.c
@@ -86,62 +86,84 @@ 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	priv = GNUNET_CRYPTO_eddsa_key_create ();	139
128	GNUNET_CRYPTO_eddsa_key_get_public (priv, &pub);	140	GNUNET_CRYPTO_eddsa_key_create (&priv);
129	data.purpose.size = htonl (sizeof (struct TestSignatureDataPS));	141	GNUNET_CRYPTO_eddsa_key_get_public (&priv,
130	data.purpose.size = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);	142	&pub);
131	GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (priv, &data.purpose,	143	data.purpose.size = htonl (sizeof (data));
132	&sig));	144	data.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
133	GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_verify (0,	145	GNUNET_CRYPTO_eddsa_sign (&priv,
134	&data.purpose,	146	&data,
135	&sig,	147	&sig);
136	&pub));	148	GNUNET_assert (GNUNET_OK ==
		149	GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
		150	&data,
		151	&sig,
		152	&pub));
137		153
138	printf ("eddsa sig:\n");	154	printf ("eddsa sig:\n");
139	display_data (" priv", priv, sizeof (struct	155	display_data (" priv",
140	GNUNET_CRYPTO_EddsaPrivateKey));	156	&priv,
141	display_data (" pub", &pub, sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));	157	sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
142	display_data (" data", &data, sizeof (struct TestSignatureDataPS));	158	display_data (" pub",
143	display_data (" sig", &sig, sizeof (struct GNUNET_CRYPTO_EddsaSignature));	159	&pub,
144	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));
145	}	167	}
146		168
147	{	169	{
@@ -151,15 +173,16 @@ run (void *cls,
151	char *salt = "I'm very salty";	173	char *salt = "I'm very salty";
152	char *ctx = "I'm a context chunk, also known as 'info' in the RFC";	174	char *ctx = "I'm a context chunk, also known as 'info' in the RFC";
153		175
154	GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_kdf (&out,	176	GNUNET_assert (GNUNET_OK ==
155	out_len,	177	GNUNET_CRYPTO_kdf (&out,
156	salt,	178	out_len,
157	strlen (salt),	179	salt,
158	ikm,	180	strlen (salt),
159	strlen (ikm),	181	ikm,
160	ctx,	182	strlen (ikm),
161	strlen (ctx),	183	ctx,
162	NULL));	184	strlen (ctx),
		185	NULL));
163		186
164	printf ("kdf:\n");	187	printf ("kdf:\n");
165	display_data (" salt", salt, strlen (salt));	188	display_data (" salt", salt, strlen (salt));
@@ -169,28 +192,34 @@ run (void *cls,
169	display_data (" out", out, out_len);	192	display_data (" out", out, out_len);
170	}	193	}
171	{	194	{
172	struct GNUNET_CRYPTO_EcdhePrivateKey *priv_ecdhe;	195	struct GNUNET_CRYPTO_EcdhePrivateKey priv_ecdhe;
173	struct GNUNET_CRYPTO_EcdhePublicKey pub_ecdhe;	196	struct GNUNET_CRYPTO_EcdhePublicKey pub_ecdhe;
174	struct GNUNET_CRYPTO_EddsaPrivateKey *priv_eddsa;	197	struct GNUNET_CRYPTO_EddsaPrivateKey priv_eddsa;
175	struct GNUNET_CRYPTO_EddsaPublicKey pub_eddsa;	198	struct GNUNET_CRYPTO_EddsaPublicKey pub_eddsa;
176	struct GNUNET_HashCode key_material;	199	struct GNUNET_HashCode key_material;
177	priv_ecdhe = GNUNET_CRYPTO_ecdhe_key_create ();	200
178	GNUNET_CRYPTO_ecdhe_key_get_public (priv_ecdhe, &pub_ecdhe);	201	GNUNET_CRYPTO_ecdhe_key_create (&priv_ecdhe);
179	priv_eddsa = GNUNET_CRYPTO_eddsa_key_create ();	202	GNUNET_CRYPTO_ecdhe_key_get_public (&priv_ecdhe, &pub_ecdhe);
180	GNUNET_CRYPTO_eddsa_key_get_public (priv_eddsa, &pub_eddsa);	203	GNUNET_CRYPTO_eddsa_key_create (&priv_eddsa);
181	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);
182		206
183	printf ("eddsa_ecdh:\n");	207	printf ("eddsa_ecdh:\n");
184	display_data (" priv_ecdhe", priv_ecdhe, sizeof (struct	208	display_data (" priv_ecdhe",
185	GNUNET_CRYPTO_EcdhePrivateKey));	209	&priv_ecdhe,
186	display_data (" pub_ecdhe", &pub_ecdhe, sizeof (struct	210	sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey));
187	GNUNET_CRYPTO_EcdhePublicKey));	211	display_data (" pub_ecdhe",
188	display_data (" priv_eddsa", priv_eddsa, sizeof (struct	212	&pub_ecdhe,
189	GNUNET_CRYPTO_EddsaPrivateKey));	213	sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
190	display_data (" pub_eddsa", &pub_eddsa, sizeof (struct	214	display_data (" priv_eddsa",
191	GNUNET_CRYPTO_EddsaPublicKey));	215	&priv_eddsa,
192	display_data (" key_material", &key_material, sizeof (struct	216	sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
193	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));
194	}	223	}
195		224
196	{	225	{
@@ -200,23 +229,29 @@ run (void *cls,
200	struct GNUNET_CRYPTO_RsaBlindingKeySecret bks;	229	struct GNUNET_CRYPTO_RsaBlindingKeySecret bks;
201	struct GNUNET_CRYPTO_RsaSignature *blinded_sig;	230	struct GNUNET_CRYPTO_RsaSignature *blinded_sig;
202	struct GNUNET_CRYPTO_RsaSignature *sig;	231	struct GNUNET_CRYPTO_RsaSignature *sig;
203	char *blinded_data;	232	void *blinded_data;
204	size_t blinded_len;	233	size_t blinded_len;
205	char *public_enc_data;	234	void *public_enc_data;
206	size_t public_enc_len;	235	size_t public_enc_len;
207	char *blinded_sig_enc_data;	236	void *blinded_sig_enc_data;
208	size_t blinded_sig_enc_length;	237	size_t blinded_sig_enc_length;
209	char *sig_enc_data;	238	void *sig_enc_data;
210	size_t sig_enc_length;	239	size_t sig_enc_length;
211	skey = GNUNET_CRYPTO_rsa_private_key_create (2048);	240	skey = GNUNET_CRYPTO_rsa_private_key_create (2048);
212	pkey = GNUNET_CRYPTO_rsa_private_key_get_public (skey);	241	pkey = GNUNET_CRYPTO_rsa_private_key_get_public (skey);
213	GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, &message_hash,	242	GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
		243	&message_hash,
214	sizeof (struct GNUNET_HashCode));	244	sizeof (struct GNUNET_HashCode));
215	GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, &bks, sizeof (struct	245	GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
216	GNUNET_CRYPTO_RsaBlindingKeySecret));	246	&bks,
217	GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_rsa_blind (&message_hash, &bks,	247	sizeof (struct
218	pkey, &blinded_data,	248	GNUNET_CRYPTO_RsaBlindingKeySecret));
219	&blinded_len));	249	GNUNET_assert (GNUNET_YES ==
		250	GNUNET_CRYPTO_rsa_blind (&message_hash,
		251	&bks,
		252	pkey,
		253	&blinded_data,
		254	&blinded_len));
220	blinded_sig = GNUNET_CRYPTO_rsa_sign_blinded (skey, blinded_data,	255	blinded_sig = GNUNET_CRYPTO_rsa_sign_blinded (skey, blinded_data,
221	blinded_len);	256	blinded_len);
222	sig = GNUNET_CRYPTO_rsa_unblind (blinded_sig, &bks, pkey);	257	sig = GNUNET_CRYPTO_rsa_unblind (blinded_sig, &bks, pkey);
@@ -275,4 +310,5 @@ main (int argc,
275	return 0;	310	return 0;
276	}	311	}
277		312
		313
278	/* end of gnunet-crypto-tvg.c */	314	/* end of gnunet-crypto-tvg.c */