diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/abe | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/abe')
-rw-r--r-- | src/abe/abe.c | 417 | ||||
-rw-r--r-- | src/abe/test_cpabe.c | 60 |
2 files changed, 241 insertions, 236 deletions
diff --git a/src/abe/abe.c b/src/abe/abe.c index 31c6e04e0..bba6e5c45 100644 --- a/src/abe/abe.c +++ b/src/abe/abe.c | |||
@@ -33,63 +33,65 @@ | |||
33 | #include "gnunet_crypto_lib.h" | 33 | #include "gnunet_crypto_lib.h" |
34 | #include "gnunet_abe_lib.h" | 34 | #include "gnunet_abe_lib.h" |
35 | 35 | ||
36 | struct GNUNET_ABE_AbeMasterKey { | 36 | struct GNUNET_ABE_AbeMasterKey |
37 | gabe_pub_t* pub; | 37 | { |
38 | gabe_msk_t* msk; | 38 | gabe_pub_t*pub; |
39 | gabe_msk_t*msk; | ||
39 | }; | 40 | }; |
40 | 41 | ||
41 | struct GNUNET_ABE_AbeKey { | 42 | struct GNUNET_ABE_AbeKey |
42 | gabe_pub_t* pub; | 43 | { |
43 | gabe_prv_t* prv; | 44 | gabe_pub_t*pub; |
45 | gabe_prv_t*prv; | ||
44 | }; | 46 | }; |
45 | 47 | ||
46 | static int | 48 | static int |
47 | init_aes(element_t k, int enc, | 49 | init_aes (element_t k, int enc, |
48 | gcry_cipher_hd_t* handle, | 50 | gcry_cipher_hd_t*handle, |
49 | struct GNUNET_CRYPTO_SymmetricSessionKey *key, | 51 | struct GNUNET_CRYPTO_SymmetricSessionKey *key, |
50 | unsigned char* iv) | 52 | unsigned char*iv) |
51 | { | 53 | { |
52 | int rc; | 54 | int rc; |
53 | int key_len; | 55 | int key_len; |
54 | unsigned char* key_buf; | 56 | unsigned char*key_buf; |
55 | 57 | ||
56 | key_len = element_length_in_bytes(k) < 33 ? 3 : element_length_in_bytes(k); | 58 | key_len = element_length_in_bytes (k) < 33 ? 3 : element_length_in_bytes (k); |
57 | key_buf = (unsigned char*)malloc(key_len); | 59 | key_buf = (unsigned char*) malloc (key_len); |
58 | element_to_bytes(key_buf, k); | 60 | element_to_bytes (key_buf, k); |
59 | 61 | ||
60 | GNUNET_memcpy(key->aes_key, key_buf, GNUNET_CRYPTO_AES_KEY_LENGTH); | 62 | GNUNET_memcpy (key->aes_key, key_buf, GNUNET_CRYPTO_AES_KEY_LENGTH); |
61 | GNUNET_assert(0 == | 63 | GNUNET_assert (0 == |
62 | gcry_cipher_open(handle, GCRY_CIPHER_AES256, | 64 | gcry_cipher_open (handle, GCRY_CIPHER_AES256, |
63 | GCRY_CIPHER_MODE_CFB, 0)); | 65 | GCRY_CIPHER_MODE_CFB, 0)); |
64 | rc = gcry_cipher_setkey(*handle, | 66 | rc = gcry_cipher_setkey (*handle, |
65 | key->aes_key, | 67 | key->aes_key, |
66 | sizeof(key->aes_key)); | 68 | sizeof(key->aes_key)); |
67 | GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY)); | 69 | GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY)); |
68 | memset(iv, 0, 16); //TODO make reasonable | 70 | memset (iv, 0, 16); // TODO make reasonable |
69 | rc = gcry_cipher_setiv(*handle, | 71 | rc = gcry_cipher_setiv (*handle, |
70 | iv, | 72 | iv, |
71 | 16); | 73 | 16); |
72 | GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY)); | 74 | GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY)); |
73 | 75 | ||
74 | free(key_buf); | 76 | free (key_buf); |
75 | return rc; | 77 | return rc; |
76 | } | 78 | } |
77 | 79 | ||
78 | static int | 80 | static int |
79 | aes_128_cbc_encrypt(char* pt, | 81 | aes_128_cbc_encrypt (char*pt, |
80 | int size, | 82 | int size, |
81 | element_t k, | 83 | element_t k, |
82 | char **ct) | 84 | char **ct) |
83 | { | 85 | { |
84 | gcry_cipher_hd_t handle; | 86 | gcry_cipher_hd_t handle; |
85 | struct GNUNET_CRYPTO_SymmetricSessionKey skey; | 87 | struct GNUNET_CRYPTO_SymmetricSessionKey skey; |
86 | unsigned char iv[16]; | 88 | unsigned char iv[16]; |
87 | char* buf; | 89 | char*buf; |
88 | int padding; | 90 | int padding; |
89 | int buf_size; | 91 | int buf_size; |
90 | uint8_t len[4]; | 92 | uint8_t len[4]; |
91 | 93 | ||
92 | init_aes(k, 1, &handle, &skey, iv); | 94 | init_aes (k, 1, &handle, &skey, iv); |
93 | 95 | ||
94 | /* TODO make less crufty */ | 96 | /* TODO make less crufty */ |
95 | 97 | ||
@@ -100,37 +102,38 @@ aes_128_cbc_encrypt(char* pt, | |||
100 | len[3] = (size & 0xff) >> 0; | 102 | len[3] = (size & 0xff) >> 0; |
101 | padding = 16 - ((4 + size) % 16); | 103 | padding = 16 - ((4 + size) % 16); |
102 | buf_size = 4 + size + padding; | 104 | buf_size = 4 + size + padding; |
103 | buf = GNUNET_malloc(buf_size); | 105 | buf = GNUNET_malloc (buf_size); |
104 | GNUNET_memcpy(buf, len, 4); | 106 | GNUNET_memcpy (buf, len, 4); |
105 | GNUNET_memcpy(buf + 4, pt, size); | 107 | GNUNET_memcpy (buf + 4, pt, size); |
106 | *ct = GNUNET_malloc(buf_size); | 108 | *ct = GNUNET_malloc (buf_size); |
107 | 109 | ||
108 | GNUNET_assert(0 == gcry_cipher_encrypt(handle, *ct, buf_size, buf, buf_size)); | 110 | GNUNET_assert (0 == gcry_cipher_encrypt (handle, *ct, buf_size, buf, |
109 | gcry_cipher_close(handle); | 111 | buf_size)); |
110 | //AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT); | 112 | gcry_cipher_close (handle); |
111 | GNUNET_free(buf); | 113 | // AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT); |
114 | GNUNET_free (buf); | ||
112 | return buf_size; | 115 | return buf_size; |
113 | } | 116 | } |
114 | 117 | ||
115 | static int | 118 | static int |
116 | aes_128_cbc_decrypt(char* ct, | 119 | aes_128_cbc_decrypt (char*ct, |
117 | int size, | 120 | int size, |
118 | element_t k, | 121 | element_t k, |
119 | char **pt) | 122 | char **pt) |
120 | { | 123 | { |
121 | struct GNUNET_CRYPTO_SymmetricSessionKey skey; | 124 | struct GNUNET_CRYPTO_SymmetricSessionKey skey; |
122 | gcry_cipher_hd_t handle; | 125 | gcry_cipher_hd_t handle; |
123 | unsigned char iv[16]; | 126 | unsigned char iv[16]; |
124 | char* tmp; | 127 | char*tmp; |
125 | uint32_t len; | 128 | uint32_t len; |
126 | 129 | ||
127 | init_aes(k, 1, &handle, &skey, iv); | 130 | init_aes (k, 1, &handle, &skey, iv); |
128 | 131 | ||
129 | tmp = GNUNET_malloc(size); | 132 | tmp = GNUNET_malloc (size); |
130 | 133 | ||
131 | //AES_cbc_encrypt(ct->data, pt->data, ct->len, &key, iv, AES_DECRYPT); | 134 | // AES_cbc_encrypt(ct->data, pt->data, ct->len, &key, iv, AES_DECRYPT); |
132 | GNUNET_assert(0 == gcry_cipher_decrypt(handle, tmp, size, ct, size)); | 135 | GNUNET_assert (0 == gcry_cipher_decrypt (handle, tmp, size, ct, size)); |
133 | gcry_cipher_close(handle); | 136 | gcry_cipher_close (handle); |
134 | /* TODO make less crufty */ | 137 | /* TODO make less crufty */ |
135 | 138 | ||
136 | /* get real length */ | 139 | /* get real length */ |
@@ -139,9 +142,9 @@ aes_128_cbc_decrypt(char* ct, | |||
139 | | ((tmp[0]) << 24) | ((tmp[1]) << 16) | 142 | | ((tmp[0]) << 24) | ((tmp[1]) << 16) |
140 | | ((tmp[2]) << 8) | ((tmp[3]) << 0); | 143 | | ((tmp[2]) << 8) | ((tmp[3]) << 0); |
141 | /* truncate any garbage from the padding */ | 144 | /* truncate any garbage from the padding */ |
142 | *pt = GNUNET_malloc(len); | 145 | *pt = GNUNET_malloc (len); |
143 | GNUNET_memcpy(*pt, tmp + 4, len); | 146 | GNUNET_memcpy (*pt, tmp + 4, len); |
144 | GNUNET_free(tmp); | 147 | GNUNET_free (tmp); |
145 | return len; | 148 | return len; |
146 | } | 149 | } |
147 | 150 | ||
@@ -152,14 +155,14 @@ aes_128_cbc_decrypt(char* ct, | |||
152 | * @return fresh private key; free using #GNUNET_ABE_cpabe_delete_master_key | 155 | * @return fresh private key; free using #GNUNET_ABE_cpabe_delete_master_key |
153 | */ | 156 | */ |
154 | struct GNUNET_ABE_AbeMasterKey* | 157 | struct GNUNET_ABE_AbeMasterKey* |
155 | GNUNET_ABE_cpabe_create_master_key(void) | 158 | GNUNET_ABE_cpabe_create_master_key (void) |
156 | { | 159 | { |
157 | struct GNUNET_ABE_AbeMasterKey* key; | 160 | struct GNUNET_ABE_AbeMasterKey*key; |
158 | 161 | ||
159 | key = GNUNET_new(struct GNUNET_ABE_AbeMasterKey); | 162 | key = GNUNET_new (struct GNUNET_ABE_AbeMasterKey); |
160 | gabe_setup(&key->pub, &key->msk); | 163 | gabe_setup (&key->pub, &key->msk); |
161 | GNUNET_assert(NULL != key->pub); | 164 | GNUNET_assert (NULL != key->pub); |
162 | GNUNET_assert(NULL != key->msk); | 165 | GNUNET_assert (NULL != key->msk); |
163 | return key; | 166 | return key; |
164 | } | 167 | } |
165 | 168 | ||
@@ -171,13 +174,13 @@ GNUNET_ABE_cpabe_create_master_key(void) | |||
171 | * @return fresh private key; free using #GNUNET_free | 174 | * @return fresh private key; free using #GNUNET_free |
172 | */ | 175 | */ |
173 | void | 176 | void |
174 | GNUNET_ABE_cpabe_delete_master_key(struct GNUNET_ABE_AbeMasterKey *key) | 177 | GNUNET_ABE_cpabe_delete_master_key (struct GNUNET_ABE_AbeMasterKey *key) |
175 | { | 178 | { |
176 | gabe_msk_free(key->msk); | 179 | gabe_msk_free (key->msk); |
177 | gabe_pub_free(key->pub); | 180 | gabe_pub_free (key->pub); |
178 | //GNUNET_free (key->msk); | 181 | // GNUNET_free (key->msk); |
179 | //gabe_msk_free (key->msk); //For some reason free of pub implicit? | 182 | // gabe_msk_free (key->msk); //For some reason free of pub implicit? |
180 | GNUNET_free(key); | 183 | GNUNET_free (key); |
181 | } | 184 | } |
182 | 185 | ||
183 | /** | 186 | /** |
@@ -189,19 +192,19 @@ GNUNET_ABE_cpabe_delete_master_key(struct GNUNET_ABE_AbeMasterKey *key) | |||
189 | * @return fresh private key; free using #GNUNET_ABE_cpabe_delete_key | 192 | * @return fresh private key; free using #GNUNET_ABE_cpabe_delete_key |
190 | */ | 193 | */ |
191 | struct GNUNET_ABE_AbeKey* | 194 | struct GNUNET_ABE_AbeKey* |
192 | GNUNET_ABE_cpabe_create_key(struct GNUNET_ABE_AbeMasterKey *key, | 195 | GNUNET_ABE_cpabe_create_key (struct GNUNET_ABE_AbeMasterKey *key, |
193 | char **attrs) | 196 | char **attrs) |
194 | { | 197 | { |
195 | struct GNUNET_ABE_AbeKey *prv_key; | 198 | struct GNUNET_ABE_AbeKey *prv_key; |
196 | int size; | 199 | int size; |
197 | char *tmp; | 200 | char *tmp; |
198 | 201 | ||
199 | prv_key = GNUNET_new(struct GNUNET_ABE_AbeKey); | 202 | prv_key = GNUNET_new (struct GNUNET_ABE_AbeKey); |
200 | prv_key->prv = gabe_keygen(key->pub, key->msk, attrs); | 203 | prv_key->prv = gabe_keygen (key->pub, key->msk, attrs); |
201 | size = gabe_pub_serialize(key->pub, &tmp); | 204 | size = gabe_pub_serialize (key->pub, &tmp); |
202 | prv_key->pub = gabe_pub_unserialize(tmp, size); | 205 | prv_key->pub = gabe_pub_unserialize (tmp, size); |
203 | GNUNET_free(tmp); | 206 | GNUNET_free (tmp); |
204 | GNUNET_assert(NULL != prv_key->prv); | 207 | GNUNET_assert (NULL != prv_key->prv); |
205 | return prv_key; | 208 | return prv_key; |
206 | } | 209 | } |
207 | 210 | ||
@@ -214,70 +217,70 @@ GNUNET_ABE_cpabe_create_key(struct GNUNET_ABE_AbeMasterKey *key, | |||
214 | * @return fresh private key; free using #GNUNET_free | 217 | * @return fresh private key; free using #GNUNET_free |
215 | */ | 218 | */ |
216 | void | 219 | void |
217 | GNUNET_ABE_cpabe_delete_key(struct GNUNET_ABE_AbeKey *key, | 220 | GNUNET_ABE_cpabe_delete_key (struct GNUNET_ABE_AbeKey *key, |
218 | int delete_pub) | 221 | int delete_pub) |
219 | { | 222 | { |
220 | //Memory management in gabe is buggy | 223 | // Memory management in gabe is buggy |
221 | gabe_prv_free(key->prv); | 224 | gabe_prv_free (key->prv); |
222 | if (GNUNET_YES == delete_pub) | 225 | if (GNUNET_YES == delete_pub) |
223 | gabe_pub_free(key->pub); | 226 | gabe_pub_free (key->pub); |
224 | GNUNET_free(key); | 227 | GNUNET_free (key); |
225 | } | 228 | } |
226 | 229 | ||
227 | static ssize_t | 230 | static ssize_t |
228 | write_cpabe(void **result, | 231 | write_cpabe (void **result, |
229 | uint32_t file_len, | 232 | uint32_t file_len, |
230 | char* cph_buf, | 233 | char*cph_buf, |
231 | int cph_buf_len, | 234 | int cph_buf_len, |
232 | char* aes_buf, | 235 | char*aes_buf, |
233 | int aes_buf_len) | 236 | int aes_buf_len) |
234 | { | 237 | { |
235 | char *ptr; | 238 | char *ptr; |
236 | uint32_t *len; | 239 | uint32_t *len; |
237 | 240 | ||
238 | *result = GNUNET_malloc(12 + cph_buf_len + aes_buf_len); | 241 | *result = GNUNET_malloc (12 + cph_buf_len + aes_buf_len); |
239 | ptr = *result; | 242 | ptr = *result; |
240 | len = (uint32_t*)ptr; | 243 | len = (uint32_t*) ptr; |
241 | *len = htonl(file_len); | 244 | *len = htonl (file_len); |
242 | ptr += 4; | 245 | ptr += 4; |
243 | len = (uint32_t*)ptr; | 246 | len = (uint32_t*) ptr; |
244 | *len = htonl(aes_buf_len); | 247 | *len = htonl (aes_buf_len); |
245 | ptr += 4; | 248 | ptr += 4; |
246 | GNUNET_memcpy(ptr, aes_buf, aes_buf_len); | 249 | GNUNET_memcpy (ptr, aes_buf, aes_buf_len); |
247 | ptr += aes_buf_len; | 250 | ptr += aes_buf_len; |
248 | len = (uint32_t*)ptr; | 251 | len = (uint32_t*) ptr; |
249 | *len = htonl(cph_buf_len); | 252 | *len = htonl (cph_buf_len); |
250 | ptr += 4; | 253 | ptr += 4; |
251 | GNUNET_memcpy(ptr, cph_buf, cph_buf_len); | 254 | GNUNET_memcpy (ptr, cph_buf, cph_buf_len); |
252 | return 12 + cph_buf_len + aes_buf_len; | 255 | return 12 + cph_buf_len + aes_buf_len; |
253 | } | 256 | } |
254 | 257 | ||
255 | static ssize_t | 258 | static ssize_t |
256 | read_cpabe(const void *data, | 259 | read_cpabe (const void *data, |
257 | char** cph_buf, | 260 | char**cph_buf, |
258 | int *cph_buf_len, | 261 | int *cph_buf_len, |
259 | char** aes_buf, | 262 | char**aes_buf, |
260 | int *aes_buf_len) | 263 | int *aes_buf_len) |
261 | { | 264 | { |
262 | int buf_len; | 265 | int buf_len; |
263 | char *ptr; | 266 | char *ptr; |
264 | uint32_t *len; | 267 | uint32_t *len; |
265 | 268 | ||
266 | ptr = (char*)data; | 269 | ptr = (char*) data; |
267 | len = (uint32_t*)ptr; | 270 | len = (uint32_t*) ptr; |
268 | buf_len = ntohl(*len); | 271 | buf_len = ntohl (*len); |
269 | ptr += 4; | 272 | ptr += 4; |
270 | len = (uint32_t*)ptr; | 273 | len = (uint32_t*) ptr; |
271 | *aes_buf_len = ntohl(*len); | 274 | *aes_buf_len = ntohl (*len); |
272 | ptr += 4; | 275 | ptr += 4; |
273 | *aes_buf = GNUNET_malloc(*aes_buf_len); | 276 | *aes_buf = GNUNET_malloc (*aes_buf_len); |
274 | GNUNET_memcpy(*aes_buf, ptr, *aes_buf_len); | 277 | GNUNET_memcpy (*aes_buf, ptr, *aes_buf_len); |
275 | ptr += *aes_buf_len; | 278 | ptr += *aes_buf_len; |
276 | len = (uint32_t*)ptr; | 279 | len = (uint32_t*) ptr; |
277 | *cph_buf_len = ntohl(*len); | 280 | *cph_buf_len = ntohl (*len); |
278 | ptr += 4; | 281 | ptr += 4; |
279 | *cph_buf = GNUNET_malloc(*cph_buf_len); | 282 | *cph_buf = GNUNET_malloc (*cph_buf_len); |
280 | GNUNET_memcpy(*cph_buf, ptr, *cph_buf_len); | 283 | GNUNET_memcpy (*cph_buf, ptr, *cph_buf_len); |
281 | 284 | ||
282 | return buf_len; | 285 | return buf_len; |
283 | } | 286 | } |
@@ -294,34 +297,35 @@ read_cpabe(const void *data, | |||
294 | * @return the size of the encrypted block, -1 for errors | 297 | * @return the size of the encrypted block, -1 for errors |
295 | */ | 298 | */ |
296 | ssize_t | 299 | ssize_t |
297 | GNUNET_ABE_cpabe_encrypt(const void *block, | 300 | GNUNET_ABE_cpabe_encrypt (const void *block, |
298 | size_t size, | 301 | size_t size, |
299 | const char *policy, | 302 | const char *policy, |
300 | const struct GNUNET_ABE_AbeMasterKey *key, | 303 | const struct GNUNET_ABE_AbeMasterKey *key, |
301 | void **result) | 304 | void **result) |
302 | { | 305 | { |
303 | gabe_cph_t* cph; | 306 | gabe_cph_t*cph; |
304 | char* plt; | 307 | char*plt; |
305 | char* cph_buf; | 308 | char*cph_buf; |
306 | char* aes_buf; | 309 | char*aes_buf; |
307 | element_t m; | 310 | element_t m; |
308 | int cph_buf_len; | 311 | int cph_buf_len; |
309 | int aes_buf_len; | 312 | int aes_buf_len; |
310 | ssize_t result_len; | 313 | ssize_t result_len; |
311 | 314 | ||
312 | if (!(cph = gabe_enc(key->pub, m, (char*)policy))) | 315 | if (! (cph = gabe_enc (key->pub, m, (char*) policy))) |
313 | return GNUNET_SYSERR; | 316 | return GNUNET_SYSERR; |
314 | cph_buf_len = gabe_cph_serialize(cph, | 317 | cph_buf_len = gabe_cph_serialize (cph, |
315 | &cph_buf); | 318 | &cph_buf); |
316 | gabe_cph_free(cph); | 319 | gabe_cph_free (cph); |
317 | GNUNET_free(cph); | 320 | GNUNET_free (cph); |
318 | plt = GNUNET_memdup(block, size); | 321 | plt = GNUNET_memdup (block, size); |
319 | aes_buf_len = aes_128_cbc_encrypt(plt, size, m, &aes_buf); | 322 | aes_buf_len = aes_128_cbc_encrypt (plt, size, m, &aes_buf); |
320 | GNUNET_free(plt); | 323 | GNUNET_free (plt); |
321 | element_clear(m); | 324 | element_clear (m); |
322 | result_len = write_cpabe(result, size, cph_buf, cph_buf_len, aes_buf, aes_buf_len); | 325 | result_len = write_cpabe (result, size, cph_buf, cph_buf_len, aes_buf, |
323 | GNUNET_free(cph_buf); | 326 | aes_buf_len); |
324 | GNUNET_free(aes_buf); | 327 | GNUNET_free (cph_buf); |
328 | GNUNET_free (aes_buf); | ||
325 | return result_len; | 329 | return result_len; |
326 | } | 330 | } |
327 | 331 | ||
@@ -336,41 +340,41 @@ GNUNET_ABE_cpabe_encrypt(const void *block, | |||
336 | * @return the size of the encrypted block, -1 for errors | 340 | * @return the size of the encrypted block, -1 for errors |
337 | */ | 341 | */ |
338 | ssize_t | 342 | ssize_t |
339 | GNUNET_ABE_cpabe_decrypt(const void *block, | 343 | GNUNET_ABE_cpabe_decrypt (const void *block, |
340 | size_t size, | 344 | size_t size, |
341 | const struct GNUNET_ABE_AbeKey *key, | 345 | const struct GNUNET_ABE_AbeKey *key, |
342 | void **result) | 346 | void **result) |
343 | { | 347 | { |
344 | char* aes_buf; | 348 | char*aes_buf; |
345 | char* cph_buf; | 349 | char*cph_buf; |
346 | gabe_cph_t* cph; | 350 | gabe_cph_t*cph; |
347 | element_t m; | 351 | element_t m; |
348 | int cph_buf_size; | 352 | int cph_buf_size; |
349 | int aes_buf_size; | 353 | int aes_buf_size; |
350 | int plt_len; | 354 | int plt_len; |
351 | 355 | ||
352 | read_cpabe(block, &cph_buf, &cph_buf_size, &aes_buf, &aes_buf_size); | 356 | read_cpabe (block, &cph_buf, &cph_buf_size, &aes_buf, &aes_buf_size); |
353 | cph = gabe_cph_unserialize(key->pub, cph_buf, cph_buf_size); | 357 | cph = gabe_cph_unserialize (key->pub, cph_buf, cph_buf_size); |
354 | if (!gabe_dec(key->pub, key->prv, cph, m)) | 358 | if (! gabe_dec (key->pub, key->prv, cph, m)) |
355 | { | 359 | { |
356 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 360 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
357 | "%s\n", gabe_error()); | 361 | "%s\n", gabe_error ()); |
358 | GNUNET_free(aes_buf); | 362 | GNUNET_free (aes_buf); |
359 | GNUNET_free(cph_buf); | 363 | GNUNET_free (cph_buf); |
360 | gabe_cph_free(cph); | 364 | gabe_cph_free (cph); |
361 | GNUNET_free(cph); | 365 | GNUNET_free (cph); |
362 | element_clear(m); | 366 | element_clear (m); |
363 | return GNUNET_SYSERR; | 367 | return GNUNET_SYSERR; |
364 | } | 368 | } |
365 | gabe_cph_free(cph); | 369 | gabe_cph_free (cph); |
366 | GNUNET_free(cph); | 370 | GNUNET_free (cph); |
367 | plt_len = aes_128_cbc_decrypt(aes_buf, aes_buf_size, m, (char**)result); | 371 | plt_len = aes_128_cbc_decrypt (aes_buf, aes_buf_size, m, (char**) result); |
368 | GNUNET_free(cph_buf); | 372 | GNUNET_free (cph_buf); |
369 | GNUNET_free(aes_buf); | 373 | GNUNET_free (aes_buf); |
370 | element_clear(m); | 374 | element_clear (m); |
371 | //freeing is buggy in gabe | 375 | // freeing is buggy in gabe |
372 | //gabe_prv_free (prv); | 376 | // gabe_prv_free (prv); |
373 | //gabe_pub_free (pub); | 377 | // gabe_pub_free (pub); |
374 | return plt_len; | 378 | return plt_len; |
375 | } | 379 | } |
376 | 380 | ||
@@ -383,8 +387,8 @@ GNUNET_ABE_cpabe_decrypt(const void *block, | |||
383 | * @return the size of the encrypted block, -1 for errors | 387 | * @return the size of the encrypted block, -1 for errors |
384 | */ | 388 | */ |
385 | ssize_t | 389 | ssize_t |
386 | GNUNET_ABE_cpabe_serialize_key(const struct GNUNET_ABE_AbeKey *key, | 390 | GNUNET_ABE_cpabe_serialize_key (const struct GNUNET_ABE_AbeKey *key, |
387 | void **result) | 391 | void **result) |
388 | { | 392 | { |
389 | ssize_t len; | 393 | ssize_t len; |
390 | char *pub; | 394 | char *pub; |
@@ -392,14 +396,14 @@ GNUNET_ABE_cpabe_serialize_key(const struct GNUNET_ABE_AbeKey *key, | |||
392 | int pub_len; | 396 | int pub_len; |
393 | int prv_len; | 397 | int prv_len; |
394 | 398 | ||
395 | pub_len = gabe_pub_serialize(key->pub, &pub); | 399 | pub_len = gabe_pub_serialize (key->pub, &pub); |
396 | prv_len = gabe_prv_serialize(key->prv, &prv); | 400 | prv_len = gabe_prv_serialize (key->prv, &prv); |
397 | 401 | ||
398 | len = pub_len + prv_len + 12; | 402 | len = pub_len + prv_len + 12; |
399 | write_cpabe(result, len, pub, pub_len, prv, prv_len); | 403 | write_cpabe (result, len, pub, pub_len, prv, prv_len); |
400 | 404 | ||
401 | GNUNET_free(pub); | 405 | GNUNET_free (pub); |
402 | GNUNET_free(prv); | 406 | GNUNET_free (prv); |
403 | 407 | ||
404 | return len; | 408 | return len; |
405 | } | 409 | } |
@@ -413,8 +417,8 @@ GNUNET_ABE_cpabe_serialize_key(const struct GNUNET_ABE_AbeKey *key, | |||
413 | * @return the ABE key. NULL of unsuccessful | 417 | * @return the ABE key. NULL of unsuccessful |
414 | */ | 418 | */ |
415 | struct GNUNET_ABE_AbeKey* | 419 | struct GNUNET_ABE_AbeKey* |
416 | GNUNET_ABE_cpabe_deserialize_key(const void *data, | 420 | GNUNET_ABE_cpabe_deserialize_key (const void *data, |
417 | size_t len) | 421 | size_t len) |
418 | { | 422 | { |
419 | struct GNUNET_ABE_AbeKey *key; | 423 | struct GNUNET_ABE_AbeKey *key; |
420 | char *pub; | 424 | char *pub; |
@@ -422,17 +426,17 @@ GNUNET_ABE_cpabe_deserialize_key(const void *data, | |||
422 | int prv_len; | 426 | int prv_len; |
423 | int pub_len; | 427 | int pub_len; |
424 | 428 | ||
425 | key = GNUNET_new(struct GNUNET_ABE_AbeKey); | 429 | key = GNUNET_new (struct GNUNET_ABE_AbeKey); |
426 | read_cpabe(data, | 430 | read_cpabe (data, |
427 | &pub, | 431 | &pub, |
428 | &pub_len, | 432 | &pub_len, |
429 | &prv, | 433 | &prv, |
430 | &prv_len); | 434 | &prv_len); |
431 | key->pub = gabe_pub_unserialize(pub, pub_len); | 435 | key->pub = gabe_pub_unserialize (pub, pub_len); |
432 | key->prv = gabe_prv_unserialize(key->pub, prv, prv_len); | 436 | key->prv = gabe_prv_unserialize (key->pub, prv, prv_len); |
433 | 437 | ||
434 | GNUNET_free(pub); | 438 | GNUNET_free (pub); |
435 | GNUNET_free(prv); | 439 | GNUNET_free (prv); |
436 | return key; | 440 | return key; |
437 | } | 441 | } |
438 | 442 | ||
@@ -445,8 +449,9 @@ GNUNET_ABE_cpabe_deserialize_key(const void *data, | |||
445 | * @return the size of the encrypted block, -1 for errors | 449 | * @return the size of the encrypted block, -1 for errors |
446 | */ | 450 | */ |
447 | ssize_t | 451 | ssize_t |
448 | GNUNET_ABE_cpabe_serialize_master_key(const struct GNUNET_ABE_AbeMasterKey *key, | 452 | GNUNET_ABE_cpabe_serialize_master_key (const struct |
449 | void **result) | 453 | GNUNET_ABE_AbeMasterKey *key, |
454 | void **result) | ||
450 | { | 455 | { |
451 | ssize_t len; | 456 | ssize_t len; |
452 | char *pub; | 457 | char *pub; |
@@ -454,14 +459,14 @@ GNUNET_ABE_cpabe_serialize_master_key(const struct GNUNET_ABE_AbeMasterKey *key, | |||
454 | int pub_len; | 459 | int pub_len; |
455 | int msk_len; | 460 | int msk_len; |
456 | 461 | ||
457 | pub_len = gabe_pub_serialize(key->pub, &pub); | 462 | pub_len = gabe_pub_serialize (key->pub, &pub); |
458 | msk_len = gabe_msk_serialize(key->msk, &msk); | 463 | msk_len = gabe_msk_serialize (key->msk, &msk); |
459 | 464 | ||
460 | len = pub_len + msk_len + 12; | 465 | len = pub_len + msk_len + 12; |
461 | write_cpabe(result, len, pub, pub_len, msk, msk_len); | 466 | write_cpabe (result, len, pub, pub_len, msk, msk_len); |
462 | 467 | ||
463 | GNUNET_free(pub); | 468 | GNUNET_free (pub); |
464 | GNUNET_free(msk); | 469 | GNUNET_free (msk); |
465 | 470 | ||
466 | return len; | 471 | return len; |
467 | } | 472 | } |
@@ -475,8 +480,8 @@ GNUNET_ABE_cpabe_serialize_master_key(const struct GNUNET_ABE_AbeMasterKey *key, | |||
475 | * @return the ABE key. NULL of unsuccessful | 480 | * @return the ABE key. NULL of unsuccessful |
476 | */ | 481 | */ |
477 | struct GNUNET_ABE_AbeMasterKey* | 482 | struct GNUNET_ABE_AbeMasterKey* |
478 | GNUNET_ABE_cpabe_deserialize_master_key(const void *data, | 483 | GNUNET_ABE_cpabe_deserialize_master_key (const void *data, |
479 | size_t len) | 484 | size_t len) |
480 | { | 485 | { |
481 | struct GNUNET_ABE_AbeMasterKey *key; | 486 | struct GNUNET_ABE_AbeMasterKey *key; |
482 | char *msk; | 487 | char *msk; |
@@ -484,17 +489,17 @@ GNUNET_ABE_cpabe_deserialize_master_key(const void *data, | |||
484 | int msk_len; | 489 | int msk_len; |
485 | int pub_len; | 490 | int pub_len; |
486 | 491 | ||
487 | key = GNUNET_new(struct GNUNET_ABE_AbeMasterKey); | 492 | key = GNUNET_new (struct GNUNET_ABE_AbeMasterKey); |
488 | read_cpabe(data, | 493 | read_cpabe (data, |
489 | &pub, | 494 | &pub, |
490 | &pub_len, | 495 | &pub_len, |
491 | &msk, | 496 | &msk, |
492 | &msk_len); | 497 | &msk_len); |
493 | key->pub = gabe_pub_unserialize(pub, pub_len); | 498 | key->pub = gabe_pub_unserialize (pub, pub_len); |
494 | key->msk = gabe_msk_unserialize(key->pub, msk, msk_len); | 499 | key->msk = gabe_msk_unserialize (key->pub, msk, msk_len); |
495 | 500 | ||
496 | GNUNET_free(pub); | 501 | GNUNET_free (pub); |
497 | GNUNET_free(msk); | 502 | GNUNET_free (msk); |
498 | 503 | ||
499 | return key; | 504 | return key; |
500 | } | 505 | } |
diff --git a/src/abe/test_cpabe.c b/src/abe/test_cpabe.c index 84b45fc8a..c1db72f96 100644 --- a/src/abe/test_cpabe.c +++ b/src/abe/test_cpabe.c | |||
@@ -30,7 +30,7 @@ | |||
30 | #define TESTSTRING "Hello World!" | 30 | #define TESTSTRING "Hello World!" |
31 | 31 | ||
32 | static int | 32 | static int |
33 | testAbecipher() | 33 | testAbecipher () |
34 | { | 34 | { |
35 | struct GNUNET_ABE_AbeMasterKey *msk; | 35 | struct GNUNET_ABE_AbeMasterKey *msk; |
36 | struct GNUNET_ABE_AbeKey *key; | 36 | struct GNUNET_ABE_AbeKey *key; |
@@ -39,49 +39,49 @@ testAbecipher() | |||
39 | int size; | 39 | int size; |
40 | char *res; | 40 | char *res; |
41 | 41 | ||
42 | msk = GNUNET_ABE_cpabe_create_master_key(); | 42 | msk = GNUNET_ABE_cpabe_create_master_key (); |
43 | size = GNUNET_ABE_cpabe_encrypt(TESTSTRING, strlen(TESTSTRING) + 1, | 43 | size = GNUNET_ABE_cpabe_encrypt (TESTSTRING, strlen (TESTSTRING) + 1, |
44 | "testattr", //Policy | 44 | "testattr", // Policy |
45 | msk, | 45 | msk, |
46 | (void*)&result); | 46 | (void*) &result); |
47 | GNUNET_assert(-1 != size); | 47 | GNUNET_assert (-1 != size); |
48 | attrs = GNUNET_malloc(2 * sizeof(char*)); | 48 | attrs = GNUNET_malloc (2 * sizeof(char*)); |
49 | attrs[0] = "testattr"; | 49 | attrs[0] = "testattr"; |
50 | attrs[1] = NULL; | 50 | attrs[1] = NULL; |
51 | key = GNUNET_ABE_cpabe_create_key(msk, | 51 | key = GNUNET_ABE_cpabe_create_key (msk, |
52 | attrs); | 52 | attrs); |
53 | 53 | ||
54 | size = GNUNET_ABE_cpabe_decrypt(result, size, | 54 | size = GNUNET_ABE_cpabe_decrypt (result, size, |
55 | key, | 55 | key, |
56 | (void*)&res); | 56 | (void*) &res); |
57 | if (strlen(TESTSTRING) + 1 != size) | 57 | if (strlen (TESTSTRING) + 1 != size) |
58 | { | 58 | { |
59 | printf("abeciphertest failed: decryptBlock returned %d\n", size); | 59 | printf ("abeciphertest failed: decryptBlock returned %d\n", size); |
60 | return 1; | 60 | return 1; |
61 | } | 61 | } |
62 | if (0 != strcmp(res, TESTSTRING)) | 62 | if (0 != strcmp (res, TESTSTRING)) |
63 | { | 63 | { |
64 | printf("abeciphertest failed: %s != %s\n", res, TESTSTRING); | 64 | printf ("abeciphertest failed: %s != %s\n", res, TESTSTRING); |
65 | return 1; | 65 | return 1; |
66 | } | 66 | } |
67 | else | 67 | else |
68 | return 0; | 68 | return 0; |
69 | } | 69 | } |
70 | 70 | ||
71 | 71 | ||
72 | int | 72 | int |
73 | main(int argc, char *argv[]) | 73 | main (int argc, char *argv[]) |
74 | { | 74 | { |
75 | int failureCount = 0; | 75 | int failureCount = 0; |
76 | 76 | ||
77 | GNUNET_log_setup("test-crypto-abe", "WARNING", NULL); | 77 | GNUNET_log_setup ("test-crypto-abe", "WARNING", NULL); |
78 | failureCount += testAbecipher(); | 78 | failureCount += testAbecipher (); |
79 | 79 | ||
80 | if (failureCount != 0) | 80 | if (failureCount != 0) |
81 | { | 81 | { |
82 | printf("%d TESTS FAILED!\n", failureCount); | 82 | printf ("%d TESTS FAILED!\n", failureCount); |
83 | return -1; | 83 | return -1; |
84 | } | 84 | } |
85 | return 0; | 85 | return 0; |
86 | } | 86 | } |
87 | 87 | ||