1 files changed, 63 insertions, 63 deletions
diff --git a/src/util/test_crypto_rsa.c b/src/util/test_crypto_rsa.c
index 0d8827c84..423f1d6f1 100644
--- a/src/util/test_crypto_rsa.c
+++ b/src/util/test_crypto_rsa.c
@@ -32,8 +32,8 @@
 int
-main(int argc,
+main (int argc,
-     char *argv[])
+      char *argv[])
 {
 #define RND_BLK_SIZE 4096
  unsigned char rnd_blk[RND_BLK_SIZE];
@@ -49,79 +49,79 @@ main(int argc,
  char *blind_buf;
  size_t bsize;
-  GNUNET_log_setup("test-rsa", "WARNING", NULL);
+  GNUNET_log_setup ("test-rsa", "WARNING", NULL);
-  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                             rnd_blk,
+                              rnd_blk,
-                             RND_BLK_SIZE);
+                              RND_BLK_SIZE);
-  GNUNET_CRYPTO_hash(rnd_blk,
+  GNUNET_CRYPTO_hash (rnd_blk,
-                     RND_BLK_SIZE,
+                      RND_BLK_SIZE,
-                     &hash);
+                      &hash);
-  priv = GNUNET_CRYPTO_rsa_private_key_create(KEY_SIZE);
+  priv = GNUNET_CRYPTO_rsa_private_key_create (KEY_SIZE);
-  priv_copy = GNUNET_CRYPTO_rsa_private_key_dup(priv);
+  priv_copy = GNUNET_CRYPTO_rsa_private_key_dup (priv);
-  GNUNET_assert(NULL != priv_copy);
+  GNUNET_assert (NULL != priv_copy);
-  GNUNET_assert(0 == GNUNET_CRYPTO_rsa_private_key_cmp(priv, priv_copy));
+  GNUNET_assert (0 == GNUNET_CRYPTO_rsa_private_key_cmp (priv, priv_copy));
-  pub = GNUNET_CRYPTO_rsa_private_key_get_public(priv);
+  pub = GNUNET_CRYPTO_rsa_private_key_get_public (priv);
  /* Encoding */
  size_t size;
  char *enc;
  enc = NULL;
-  size = GNUNET_CRYPTO_rsa_private_key_encode(priv, &enc);
+  size = GNUNET_CRYPTO_rsa_private_key_encode (priv, &enc);
  /* Decoding */
-  GNUNET_CRYPTO_rsa_private_key_free(priv);
+  GNUNET_CRYPTO_rsa_private_key_free (priv);
  priv = NULL;
-  priv = GNUNET_CRYPTO_rsa_private_key_decode(enc, size);
+  priv = GNUNET_CRYPTO_rsa_private_key_decode (enc, size);
-  GNUNET_assert(NULL != priv);
+  GNUNET_assert (NULL != priv);
-  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                             enc, size);
+                              enc, size);
-  GNUNET_assert(NULL == GNUNET_CRYPTO_rsa_private_key_decode(enc, size));
+  GNUNET_assert (NULL == GNUNET_CRYPTO_rsa_private_key_decode (enc, size));
-  (void)fprintf(stderr, "The above warning is expected.\n");
+  (void) fprintf (stderr, "The above warning is expected.\n");
-  GNUNET_free(enc);
+  GNUNET_free (enc);
  /* try ordinary sig first */
-  sig = GNUNET_CRYPTO_rsa_sign_fdh(priv,
+  sig = GNUNET_CRYPTO_rsa_sign_fdh (priv,
-                                   &hash);
+                                    &hash);
-  sig_copy = GNUNET_CRYPTO_rsa_signature_dup(sig);
+  sig_copy = GNUNET_CRYPTO_rsa_signature_dup (sig);
-  GNUNET_assert(NULL != sig);
+  GNUNET_assert (NULL != sig);
-  GNUNET_assert(0 == GNUNET_CRYPTO_rsa_signature_cmp(sig, sig_copy));
+  GNUNET_assert (0 == GNUNET_CRYPTO_rsa_signature_cmp (sig, sig_copy));
-  pub_copy = GNUNET_CRYPTO_rsa_public_key_dup(pub);
+  pub_copy = GNUNET_CRYPTO_rsa_public_key_dup (pub);
-  GNUNET_assert(NULL != pub_copy);
+  GNUNET_assert (NULL != pub_copy);
-  GNUNET_assert(GNUNET_OK ==
+  GNUNET_assert (GNUNET_OK ==
-                GNUNET_CRYPTO_rsa_verify(&hash, sig, pub_copy));
+                 GNUNET_CRYPTO_rsa_verify (&hash, sig, pub_copy));
  /* corrupt our hash and see if the signature is still valid */
-  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, &hash,
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, &hash,
-                             sizeof(struct GNUNET_HashCode));
+                              sizeof(struct GNUNET_HashCode));
-  GNUNET_assert(GNUNET_OK != GNUNET_CRYPTO_rsa_verify(&hash,
+  GNUNET_assert (GNUNET_OK != GNUNET_CRYPTO_rsa_verify (&hash,
-                                                      sig,
+                                                        sig,
-                                                      pub));
+                                                        pub));
-  (void)fprintf(stderr, "The above warning is expected.\n");
+  (void) fprintf (stderr, "The above warning is expected.\n");
-  GNUNET_CRYPTO_rsa_signature_free(sig);
+  GNUNET_CRYPTO_rsa_signature_free (sig);
  /* test blind signing */
-  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                             &bsec,
+                              &bsec,
-                             sizeof(bsec));
+                              sizeof(bsec));
-  GNUNET_CRYPTO_rsa_blind(&hash,
+  GNUNET_CRYPTO_rsa_blind (&hash,
-                          &bsec,
+                           &bsec,
-                          pub,
+                           pub,
-                          &blind_buf, &bsize);
+                           &blind_buf, &bsize);
-  GNUNET_assert(0 != bsize);
+  GNUNET_assert (0 != bsize);
-  bsig = GNUNET_CRYPTO_rsa_sign_blinded(priv,
+  bsig = GNUNET_CRYPTO_rsa_sign_blinded (priv,
-                                        blind_buf,
+                                         blind_buf,
-                                        bsize);
+                                         bsize);
-  GNUNET_free(blind_buf);
+  GNUNET_free (blind_buf);
-  sig = GNUNET_CRYPTO_rsa_unblind(bsig,
+  sig = GNUNET_CRYPTO_rsa_unblind (bsig,
-                                  &bsec,
+                                   &bsec,
-                                  pub);
+                                   pub);
-  GNUNET_CRYPTO_rsa_signature_free(bsig);
+  GNUNET_CRYPTO_rsa_signature_free (bsig);
-  GNUNET_assert(GNUNET_OK ==
+  GNUNET_assert (GNUNET_OK ==
-                GNUNET_CRYPTO_rsa_verify(&hash, sig, pub));
+                 GNUNET_CRYPTO_rsa_verify (&hash, sig, pub));
-  GNUNET_CRYPTO_rsa_signature_free(sig);
+  GNUNET_CRYPTO_rsa_signature_free (sig);
-  GNUNET_CRYPTO_rsa_signature_free(sig_copy);
+  GNUNET_CRYPTO_rsa_signature_free (sig_copy);
-  GNUNET_CRYPTO_rsa_private_key_free(priv);
+  GNUNET_CRYPTO_rsa_private_key_free (priv);
-  GNUNET_CRYPTO_rsa_private_key_free(priv_copy);
+  GNUNET_CRYPTO_rsa_private_key_free (priv_copy);
-  GNUNET_CRYPTO_rsa_public_key_free(pub);
+  GNUNET_CRYPTO_rsa_public_key_free (pub);
-  GNUNET_CRYPTO_rsa_public_key_free(pub_copy);
+  GNUNET_CRYPTO_rsa_public_key_free (pub_copy);
  return 0;
 }

diff --git a/src/util/test_crypto_rsa.c b/src/util/test_crypto_rsa.c index 0d8827c84..423f1d6f1 100644 --- a/src/util/test_crypto_rsa.c +++ b/src/util/test_crypto_rsa.c
@@ -32,8 +32,8 @@
32		32
33		33
34	int	34	int
35	main(int argc,	35	main (int argc,
36	char *argv[])	36	char *argv[])
37	{	37	{
38	#define RND_BLK_SIZE 4096	38	#define RND_BLK_SIZE 4096
39	unsigned char rnd_blk[RND_BLK_SIZE];	39	unsigned char rnd_blk[RND_BLK_SIZE];
@@ -49,79 +49,79 @@ main(int argc,
49	char *blind_buf;	49	char *blind_buf;
50	size_t bsize;	50	size_t bsize;
51		51
52	GNUNET_log_setup("test-rsa", "WARNING", NULL);	52	GNUNET_log_setup ("test-rsa", "WARNING", NULL);
53	GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,	53	GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
54	rnd_blk,	54	rnd_blk,
55	RND_BLK_SIZE);	55	RND_BLK_SIZE);
56	GNUNET_CRYPTO_hash(rnd_blk,	56	GNUNET_CRYPTO_hash (rnd_blk,
57	RND_BLK_SIZE,	57	RND_BLK_SIZE,
58	&hash);	58	&hash);
59	priv = GNUNET_CRYPTO_rsa_private_key_create(KEY_SIZE);	59	priv = GNUNET_CRYPTO_rsa_private_key_create (KEY_SIZE);
60	priv_copy = GNUNET_CRYPTO_rsa_private_key_dup(priv);	60	priv_copy = GNUNET_CRYPTO_rsa_private_key_dup (priv);
61	GNUNET_assert(NULL != priv_copy);	61	GNUNET_assert (NULL != priv_copy);
62	GNUNET_assert(0 == GNUNET_CRYPTO_rsa_private_key_cmp(priv, priv_copy));	62	GNUNET_assert (0 == GNUNET_CRYPTO_rsa_private_key_cmp (priv, priv_copy));
63	pub = GNUNET_CRYPTO_rsa_private_key_get_public(priv);	63	pub = GNUNET_CRYPTO_rsa_private_key_get_public (priv);
64		64
65	/* Encoding */	65	/* Encoding */
66	size_t size;	66	size_t size;
67	char *enc;	67	char *enc;
68	enc = NULL;	68	enc = NULL;
69	size = GNUNET_CRYPTO_rsa_private_key_encode(priv, &enc);	69	size = GNUNET_CRYPTO_rsa_private_key_encode (priv, &enc);
70		70
71	/* Decoding */	71	/* Decoding */
72	GNUNET_CRYPTO_rsa_private_key_free(priv);	72	GNUNET_CRYPTO_rsa_private_key_free (priv);
73	priv = NULL;	73	priv = NULL;
74	priv = GNUNET_CRYPTO_rsa_private_key_decode(enc, size);	74	priv = GNUNET_CRYPTO_rsa_private_key_decode (enc, size);
75	GNUNET_assert(NULL != priv);	75	GNUNET_assert (NULL != priv);
76	GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,	76	GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
77	enc, size);	77	enc, size);
78	GNUNET_assert(NULL == GNUNET_CRYPTO_rsa_private_key_decode(enc, size));	78	GNUNET_assert (NULL == GNUNET_CRYPTO_rsa_private_key_decode (enc, size));
79	(void)fprintf(stderr, "The above warning is expected.\n");	79	(void) fprintf (stderr, "The above warning is expected.\n");
80	GNUNET_free(enc);	80	GNUNET_free (enc);
81		81
82	/* try ordinary sig first */	82	/* try ordinary sig first */
83	sig = GNUNET_CRYPTO_rsa_sign_fdh(priv,	83	sig = GNUNET_CRYPTO_rsa_sign_fdh (priv,
84	&hash);	84	&hash);
85	sig_copy = GNUNET_CRYPTO_rsa_signature_dup(sig);	85	sig_copy = GNUNET_CRYPTO_rsa_signature_dup (sig);
86	GNUNET_assert(NULL != sig);	86	GNUNET_assert (NULL != sig);
87	GNUNET_assert(0 == GNUNET_CRYPTO_rsa_signature_cmp(sig, sig_copy));	87	GNUNET_assert (0 == GNUNET_CRYPTO_rsa_signature_cmp (sig, sig_copy));
88	pub_copy = GNUNET_CRYPTO_rsa_public_key_dup(pub);	88	pub_copy = GNUNET_CRYPTO_rsa_public_key_dup (pub);
89	GNUNET_assert(NULL != pub_copy);	89	GNUNET_assert (NULL != pub_copy);
90	GNUNET_assert(GNUNET_OK ==	90	GNUNET_assert (GNUNET_OK ==
91	GNUNET_CRYPTO_rsa_verify(&hash, sig, pub_copy));	91	GNUNET_CRYPTO_rsa_verify (&hash, sig, pub_copy));
92	/* corrupt our hash and see if the signature is still valid */	92	/* corrupt our hash and see if the signature is still valid */
93	GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, &hash,	93	GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, &hash,
94	sizeof(struct GNUNET_HashCode));	94	sizeof(struct GNUNET_HashCode));
95	GNUNET_assert(GNUNET_OK != GNUNET_CRYPTO_rsa_verify(&hash,	95	GNUNET_assert (GNUNET_OK != GNUNET_CRYPTO_rsa_verify (&hash,
96	sig,	96	sig,
97	pub));	97	pub));
98	(void)fprintf(stderr, "The above warning is expected.\n");	98	(void) fprintf (stderr, "The above warning is expected.\n");
99	GNUNET_CRYPTO_rsa_signature_free(sig);	99	GNUNET_CRYPTO_rsa_signature_free (sig);
100		100
101	/* test blind signing */	101	/* test blind signing */
102	GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK,	102	GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
103	&bsec,	103	&bsec,
104	sizeof(bsec));	104	sizeof(bsec));
105	GNUNET_CRYPTO_rsa_blind(&hash,	105	GNUNET_CRYPTO_rsa_blind (&hash,
106	&bsec,	106	&bsec,
107	pub,	107	pub,
108	&blind_buf, &bsize);	108	&blind_buf, &bsize);
109	GNUNET_assert(0 != bsize);	109	GNUNET_assert (0 != bsize);
110	bsig = GNUNET_CRYPTO_rsa_sign_blinded(priv,	110	bsig = GNUNET_CRYPTO_rsa_sign_blinded (priv,
111	blind_buf,	111	blind_buf,
112	bsize);	112	bsize);
113	GNUNET_free(blind_buf);	113	GNUNET_free (blind_buf);
114	sig = GNUNET_CRYPTO_rsa_unblind(bsig,	114	sig = GNUNET_CRYPTO_rsa_unblind (bsig,
115	&bsec,	115	&bsec,
116	pub);	116	pub);
117	GNUNET_CRYPTO_rsa_signature_free(bsig);	117	GNUNET_CRYPTO_rsa_signature_free (bsig);
118	GNUNET_assert(GNUNET_OK ==	118	GNUNET_assert (GNUNET_OK ==
119	GNUNET_CRYPTO_rsa_verify(&hash, sig, pub));	119	GNUNET_CRYPTO_rsa_verify (&hash, sig, pub));
120	GNUNET_CRYPTO_rsa_signature_free(sig);	120	GNUNET_CRYPTO_rsa_signature_free (sig);
121	GNUNET_CRYPTO_rsa_signature_free(sig_copy);	121	GNUNET_CRYPTO_rsa_signature_free (sig_copy);
122	GNUNET_CRYPTO_rsa_private_key_free(priv);	122	GNUNET_CRYPTO_rsa_private_key_free (priv);
123	GNUNET_CRYPTO_rsa_private_key_free(priv_copy);	123	GNUNET_CRYPTO_rsa_private_key_free (priv_copy);
124	GNUNET_CRYPTO_rsa_public_key_free(pub);	124	GNUNET_CRYPTO_rsa_public_key_free (pub);
125	GNUNET_CRYPTO_rsa_public_key_free(pub_copy);	125	GNUNET_CRYPTO_rsa_public_key_free (pub_copy);
126	return 0;	126	return 0;
127	}	127	}