diff options
Diffstat (limited to 'src/util/crypto_abe.c')
-rw-r--r-- | src/util/crypto_abe.c | 438 |
1 files changed, 0 insertions, 438 deletions
diff --git a/src/util/crypto_abe.c b/src/util/crypto_abe.c deleted file mode 100644 index c089b29db..000000000 --- a/src/util/crypto_abe.c +++ /dev/null | |||
@@ -1,438 +0,0 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. Copyright (C) 2001-2014 Christian Grothoff | ||
3 | (and other contributing authors) | ||
4 | |||
5 | GNUnet is free software: you can redistribute it and/or modify it | ||
6 | under the terms of the GNU Affero General Public License as published | ||
7 | by the Free Software Foundation, either version 3 of the License, | ||
8 | or (at your option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Affero General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Affero General Public License | ||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
17 | |||
18 | SPDX-License-Identifier: AGPL3.0-or-later | ||
19 | |||
20 | */ | ||
21 | |||
22 | /** | ||
23 | * @file util/crypto_random.c | ||
24 | * @brief functions to gather random numbers | ||
25 | * @author Christian Grothoff | ||
26 | */ | ||
27 | |||
28 | |||
29 | #include "platform.h" | ||
30 | #include <pbc/pbc.h> | ||
31 | #include <gabe.h> | ||
32 | |||
33 | #include "gnunet_crypto_lib.h" | ||
34 | |||
35 | struct GNUNET_CRYPTO_AbeMasterKey | ||
36 | { | ||
37 | gabe_pub_t*pub; | ||
38 | gabe_msk_t*msk; | ||
39 | }; | ||
40 | |||
41 | struct GNUNET_CRYPTO_AbeKey | ||
42 | { | ||
43 | gabe_pub_t*pub; | ||
44 | gabe_prv_t*prv; | ||
45 | }; | ||
46 | |||
47 | static int | ||
48 | init_aes (element_t k, int enc, | ||
49 | gcry_cipher_hd_t*handle, | ||
50 | struct GNUNET_CRYPTO_SymmetricSessionKey *key, | ||
51 | unsigned char*iv) | ||
52 | { | ||
53 | int rc; | ||
54 | int key_len; | ||
55 | unsigned char*key_buf; | ||
56 | |||
57 | key_len = element_length_in_bytes (k) < 33 ? 3 : element_length_in_bytes (k); | ||
58 | key_buf = (unsigned char *) malloc (key_len); | ||
59 | element_to_bytes (key_buf, k); | ||
60 | |||
61 | GNUNET_memcpy (key->aes_key, | ||
62 | key_buf, | ||
63 | GNUNET_CRYPTO_AES_KEY_LENGTH); | ||
64 | GNUNET_assert (0 == | ||
65 | gcry_cipher_open (handle, GCRY_CIPHER_AES256, | ||
66 | GCRY_CIPHER_MODE_CFB, 0)); | ||
67 | rc = gcry_cipher_setkey (*handle, | ||
68 | key->aes_key, | ||
69 | sizeof(key->aes_key)); | ||
70 | GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY)); | ||
71 | memset (iv, 0, 16); // TODO make reasonable | ||
72 | rc = gcry_cipher_setiv (*handle, | ||
73 | iv, | ||
74 | 16); | ||
75 | GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY)); | ||
76 | |||
77 | free (key_buf); | ||
78 | return rc; | ||
79 | } | ||
80 | |||
81 | |||
82 | static int | ||
83 | aes_128_cbc_encrypt (char*pt, | ||
84 | int size, | ||
85 | element_t k, | ||
86 | char **ct) | ||
87 | { | ||
88 | gcry_cipher_hd_t handle; | ||
89 | struct GNUNET_CRYPTO_SymmetricSessionKey skey; | ||
90 | unsigned char iv[16]; | ||
91 | char*buf; | ||
92 | int padding; | ||
93 | int buf_size; | ||
94 | uint8_t len[4]; | ||
95 | |||
96 | init_aes (k, 1, &handle, &skey, iv); | ||
97 | |||
98 | /* TODO make less crufty */ | ||
99 | |||
100 | /* stuff in real length (big endian) before padding */ | ||
101 | len[0] = (size & 0xff000000) >> 24; | ||
102 | len[1] = (size & 0xff0000) >> 16; | ||
103 | len[2] = (size & 0xff00) >> 8; | ||
104 | len[3] = (size & 0xff) >> 0; | ||
105 | padding = 16 - ((4 + size) % 16); | ||
106 | buf_size = 4 + size + padding; | ||
107 | buf = GNUNET_malloc (buf_size); | ||
108 | GNUNET_memcpy (buf, len, 4); | ||
109 | GNUNET_memcpy (buf + 4, pt, size); | ||
110 | *ct = GNUNET_malloc (buf_size); | ||
111 | |||
112 | GNUNET_assert (0 == gcry_cipher_encrypt (handle, *ct, buf_size, buf, | ||
113 | buf_size)); | ||
114 | gcry_cipher_close (handle); | ||
115 | // AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT); | ||
116 | GNUNET_free (buf); | ||
117 | return buf_size; | ||
118 | } | ||
119 | |||
120 | |||
121 | static int | ||
122 | aes_128_cbc_decrypt (char*ct, | ||
123 | int size, | ||
124 | element_t k, | ||
125 | char **pt) | ||
126 | { | ||
127 | struct GNUNET_CRYPTO_SymmetricSessionKey skey; | ||
128 | gcry_cipher_hd_t handle; | ||
129 | unsigned char iv[16]; | ||
130 | char*tmp; | ||
131 | uint32_t len; | ||
132 | |||
133 | init_aes (k, 1, &handle, &skey, iv); | ||
134 | |||
135 | tmp = GNUNET_malloc (size); | ||
136 | |||
137 | // AES_cbc_encrypt(ct->data, pt->data, ct->len, &key, iv, AES_DECRYPT); | ||
138 | GNUNET_assert (0 == gcry_cipher_decrypt (handle, tmp, size, ct, size)); | ||
139 | gcry_cipher_close (handle); | ||
140 | /* TODO make less crufty */ | ||
141 | |||
142 | /* get real length */ | ||
143 | len = 0; | ||
144 | len = len | ||
145 | | ((tmp[0]) << 24) | ((tmp[1]) << 16) | ||
146 | | ((tmp[2]) << 8) | ((tmp[3]) << 0); | ||
147 | /* truncate any garbage from the padding */ | ||
148 | *pt = GNUNET_malloc (len); | ||
149 | GNUNET_memcpy (*pt, tmp + 4, len); | ||
150 | GNUNET_free (tmp); | ||
151 | return len; | ||
152 | } | ||
153 | |||
154 | |||
155 | struct GNUNET_CRYPTO_AbeMasterKey* | ||
156 | GNUNET_CRYPTO_cpabe_create_master_key (void) | ||
157 | { | ||
158 | struct GNUNET_CRYPTO_AbeMasterKey*key; | ||
159 | |||
160 | key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey); | ||
161 | gabe_setup (&key->pub, &key->msk); | ||
162 | GNUNET_assert (NULL != key->pub); | ||
163 | GNUNET_assert (NULL != key->msk); | ||
164 | return key; | ||
165 | } | ||
166 | |||
167 | |||
168 | void | ||
169 | GNUNET_CRYPTO_cpabe_delete_master_key (struct GNUNET_CRYPTO_AbeMasterKey *key) | ||
170 | { | ||
171 | gabe_msk_free (key->msk); | ||
172 | gabe_pub_free (key->pub); | ||
173 | // GNUNET_free (key->msk); | ||
174 | // gabe_msk_free (key->msk); //For some reason free of pub implicit? | ||
175 | GNUNET_free (key); | ||
176 | } | ||
177 | |||
178 | |||
179 | struct GNUNET_CRYPTO_AbeKey* | ||
180 | GNUNET_CRYPTO_cpabe_create_key (struct GNUNET_CRYPTO_AbeMasterKey *key, | ||
181 | char **attrs) | ||
182 | { | ||
183 | struct GNUNET_CRYPTO_AbeKey *prv_key; | ||
184 | int size; | ||
185 | char *tmp; | ||
186 | |||
187 | prv_key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey); | ||
188 | prv_key->prv = gabe_keygen (key->pub, key->msk, attrs); | ||
189 | size = gabe_pub_serialize (key->pub, &tmp); | ||
190 | prv_key->pub = gabe_pub_unserialize (tmp, size); | ||
191 | GNUNET_free (tmp); | ||
192 | GNUNET_assert (NULL != prv_key->prv); | ||
193 | return prv_key; | ||
194 | } | ||
195 | |||
196 | |||
197 | void | ||
198 | GNUNET_CRYPTO_cpabe_delete_key (struct GNUNET_CRYPTO_AbeKey *key, | ||
199 | int delete_pub) | ||
200 | { | ||
201 | // Memory management in gabe is buggy | ||
202 | gabe_prv_free (key->prv); | ||
203 | if (GNUNET_YES == delete_pub) | ||
204 | gabe_pub_free (key->pub); | ||
205 | GNUNET_free (key); | ||
206 | } | ||
207 | |||
208 | |||
209 | ssize_t | ||
210 | write_cpabe (void **result, | ||
211 | uint32_t file_len, | ||
212 | char*cph_buf, | ||
213 | int cph_buf_len, | ||
214 | char*aes_buf, | ||
215 | int aes_buf_len) | ||
216 | { | ||
217 | char *ptr; | ||
218 | uint32_t *len; | ||
219 | |||
220 | *result = GNUNET_malloc (12 + cph_buf_len + aes_buf_len); | ||
221 | ptr = *result; | ||
222 | len = (uint32_t *) ptr; | ||
223 | *len = htonl (file_len); | ||
224 | ptr += 4; | ||
225 | len = (uint32_t *) ptr; | ||
226 | *len = htonl (aes_buf_len); | ||
227 | ptr += 4; | ||
228 | GNUNET_memcpy (ptr, aes_buf, aes_buf_len); | ||
229 | ptr += aes_buf_len; | ||
230 | len = (uint32_t *) ptr; | ||
231 | *len = htonl (cph_buf_len); | ||
232 | ptr += 4; | ||
233 | GNUNET_memcpy (ptr, cph_buf, cph_buf_len); | ||
234 | return 12 + cph_buf_len + aes_buf_len; | ||
235 | } | ||
236 | |||
237 | |||
238 | ssize_t | ||
239 | read_cpabe (const void *data, | ||
240 | char**cph_buf, | ||
241 | int *cph_buf_len, | ||
242 | char**aes_buf, | ||
243 | int *aes_buf_len) | ||
244 | { | ||
245 | int buf_len; | ||
246 | char *ptr; | ||
247 | uint32_t *len; | ||
248 | |||
249 | ptr = (char *) data; | ||
250 | len = (uint32_t *) ptr; | ||
251 | buf_len = ntohl (*len); | ||
252 | ptr += 4; | ||
253 | len = (uint32_t *) ptr; | ||
254 | *aes_buf_len = ntohl (*len); | ||
255 | ptr += 4; | ||
256 | *aes_buf = GNUNET_malloc (*aes_buf_len); | ||
257 | GNUNET_memcpy (*aes_buf, ptr, *aes_buf_len); | ||
258 | ptr += *aes_buf_len; | ||
259 | len = (uint32_t *) ptr; | ||
260 | *cph_buf_len = ntohl (*len); | ||
261 | ptr += 4; | ||
262 | *cph_buf = GNUNET_malloc (*cph_buf_len); | ||
263 | GNUNET_memcpy (*cph_buf, ptr, *cph_buf_len); | ||
264 | |||
265 | return buf_len; | ||
266 | } | ||
267 | |||
268 | |||
269 | ssize_t | ||
270 | GNUNET_CRYPTO_cpabe_encrypt (const void *block, | ||
271 | size_t size, | ||
272 | const char *policy, | ||
273 | const struct GNUNET_CRYPTO_AbeMasterKey *key, | ||
274 | void **result) | ||
275 | { | ||
276 | gabe_cph_t*cph; | ||
277 | char*plt; | ||
278 | char*cph_buf; | ||
279 | char*aes_buf; | ||
280 | element_t m; | ||
281 | int cph_buf_len; | ||
282 | int aes_buf_len; | ||
283 | ssize_t result_len; | ||
284 | |||
285 | if (! (cph = gabe_enc (key->pub, m, (char *) policy))) | ||
286 | return GNUNET_SYSERR; | ||
287 | cph_buf_len = gabe_cph_serialize (cph, | ||
288 | &cph_buf); | ||
289 | gabe_cph_free (cph); | ||
290 | GNUNET_free (cph); | ||
291 | plt = GNUNET_memdup (block, size); | ||
292 | aes_buf_len = aes_128_cbc_encrypt (plt, size, m, &aes_buf); | ||
293 | GNUNET_free (plt); | ||
294 | element_clear (m); | ||
295 | result_len = write_cpabe (result, size, cph_buf, cph_buf_len, aes_buf, | ||
296 | aes_buf_len); | ||
297 | GNUNET_free (cph_buf); | ||
298 | GNUNET_free (aes_buf); | ||
299 | return result_len; | ||
300 | } | ||
301 | |||
302 | |||
303 | ssize_t | ||
304 | GNUNET_CRYPTO_cpabe_decrypt (const void *block, | ||
305 | size_t size, | ||
306 | const struct GNUNET_CRYPTO_AbeKey *key, | ||
307 | void **result) | ||
308 | { | ||
309 | char*aes_buf; | ||
310 | char*cph_buf; | ||
311 | gabe_cph_t*cph; | ||
312 | element_t m; | ||
313 | int cph_buf_size; | ||
314 | int aes_buf_size; | ||
315 | int plt_len; | ||
316 | |||
317 | read_cpabe (block, &cph_buf, &cph_buf_size, &aes_buf, &aes_buf_size); | ||
318 | cph = gabe_cph_unserialize (key->pub, cph_buf, cph_buf_size); | ||
319 | if (! gabe_dec (key->pub, key->prv, cph, m)) | ||
320 | { | ||
321 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
322 | "%s\n", gabe_error ()); | ||
323 | GNUNET_free (aes_buf); | ||
324 | GNUNET_free (cph_buf); | ||
325 | gabe_cph_free (cph); | ||
326 | GNUNET_free (cph); | ||
327 | element_clear (m); | ||
328 | return GNUNET_SYSERR; | ||
329 | } | ||
330 | gabe_cph_free (cph); | ||
331 | GNUNET_free (cph); | ||
332 | plt_len = aes_128_cbc_decrypt (aes_buf, aes_buf_size, m, (char **) result); | ||
333 | GNUNET_free (cph_buf); | ||
334 | GNUNET_free (aes_buf); | ||
335 | element_clear (m); | ||
336 | // freeing is buggy in gabe | ||
337 | // gabe_prv_free (prv); | ||
338 | // gabe_pub_free (pub); | ||
339 | return plt_len; | ||
340 | } | ||
341 | |||
342 | |||
343 | ssize_t | ||
344 | GNUNET_CRYPTO_cpabe_serialize_key (const struct GNUNET_CRYPTO_AbeKey *key, | ||
345 | void **result) | ||
346 | { | ||
347 | ssize_t len; | ||
348 | char *pub; | ||
349 | char *prv; | ||
350 | int pub_len; | ||
351 | int prv_len; | ||
352 | |||
353 | pub_len = gabe_pub_serialize (key->pub, &pub); | ||
354 | prv_len = gabe_prv_serialize (key->prv, &prv); | ||
355 | |||
356 | len = pub_len + prv_len + 12; | ||
357 | write_cpabe (result, len, pub, pub_len, prv, prv_len); | ||
358 | |||
359 | GNUNET_free (pub); | ||
360 | GNUNET_free (prv); | ||
361 | |||
362 | return len; | ||
363 | } | ||
364 | |||
365 | |||
366 | struct GNUNET_CRYPTO_AbeKey* | ||
367 | GNUNET_CRYPTO_cpabe_deserialize_key (const void *data, | ||
368 | size_t len) | ||
369 | { | ||
370 | struct GNUNET_CRYPTO_AbeKey *key; | ||
371 | char *pub; | ||
372 | char *prv; | ||
373 | int prv_len; | ||
374 | int pub_len; | ||
375 | |||
376 | key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey); | ||
377 | read_cpabe (data, | ||
378 | &pub, | ||
379 | &pub_len, | ||
380 | &prv, | ||
381 | &prv_len); | ||
382 | key->pub = gabe_pub_unserialize (pub, pub_len); | ||
383 | key->prv = gabe_prv_unserialize (key->pub, prv, prv_len); | ||
384 | |||
385 | GNUNET_free (pub); | ||
386 | GNUNET_free (prv); | ||
387 | return key; | ||
388 | } | ||
389 | |||
390 | |||
391 | ssize_t | ||
392 | GNUNET_CRYPTO_cpabe_serialize_master_key (const struct | ||
393 | GNUNET_CRYPTO_AbeMasterKey *key, | ||
394 | void **result) | ||
395 | { | ||
396 | ssize_t len; | ||
397 | char *pub; | ||
398 | char *msk; | ||
399 | int pub_len; | ||
400 | int msk_len; | ||
401 | |||
402 | pub_len = gabe_pub_serialize (key->pub, &pub); | ||
403 | msk_len = gabe_msk_serialize (key->msk, &msk); | ||
404 | |||
405 | len = pub_len + msk_len + 12; | ||
406 | write_cpabe (result, len, pub, pub_len, msk, msk_len); | ||
407 | |||
408 | GNUNET_free (pub); | ||
409 | GNUNET_free (msk); | ||
410 | |||
411 | return len; | ||
412 | } | ||
413 | |||
414 | |||
415 | struct GNUNET_CRYPTO_AbeMasterKey* | ||
416 | GNUNET_CRYPTO_cpabe_deserialize_master_key (const void *data, | ||
417 | size_t len) | ||
418 | { | ||
419 | struct GNUNET_CRYPTO_AbeMasterKey *key; | ||
420 | char *msk; | ||
421 | char *pub; | ||
422 | int msk_len; | ||
423 | int pub_len; | ||
424 | |||
425 | key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey); | ||
426 | read_cpabe (data, | ||
427 | &pub, | ||
428 | &pub_len, | ||
429 | &msk, | ||
430 | &msk_len); | ||
431 | key->pub = gabe_pub_unserialize (pub, pub_len); | ||
432 | key->msk = gabe_msk_unserialize (key->pub, msk, msk_len); | ||
433 | |||
434 | GNUNET_free (pub); | ||
435 | GNUNET_free (msk); | ||
436 | |||
437 | return key; | ||
438 | } | ||