2 This file is part of GNUnet. Copyright (C) 2001-2014 Christian Grothoff
3 (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
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 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA.
23 * @file util/crypto_random.c
24 * @brief functions to gather random numbers
25 * @author Christian Grothoff
33 #include "gnunet_crypto_lib.h"
35 struct GNUNET_CRYPTO_AbeMasterKey
41 struct GNUNET_CRYPTO_AbeKey
48 init_aes( element_t k, int enc,
49 gcry_cipher_hd_t* handle,
50 struct GNUNET_CRYPTO_SymmetricSessionKey *key,
55 unsigned char* key_buf;
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);
61 memcpy (key->aes_key, key_buf, GNUNET_CRYPTO_AES_KEY_LENGTH);
63 gcry_cipher_open (handle, GCRY_CIPHER_AES256,
64 GCRY_CIPHER_MODE_CFB, 0));
65 rc = gcry_cipher_setkey (*handle,
67 sizeof (key->aes_key));
68 GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
69 memset (iv, 0, 16); //TODO make reasonable
70 rc = gcry_cipher_setiv (*handle,
73 GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
80 aes_128_cbc_encrypt( char* pt,
85 gcry_cipher_hd_t handle;
86 struct GNUNET_CRYPTO_SymmetricSessionKey skey;
92 init_aes(k, 1, &handle, &skey, iv);
94 /* TODO make less crufty */
96 /* stuff in real length (big endian) before padding */
97 len[0] = (size & 0xff000000)>>24;
98 len[1] = (size & 0xff0000)>>16;
99 len[2] = (size & 0xff00)>>8;
100 len[3] = (size & 0xff)>>0;
101 padding = 16 - ((4+size) % 16);
102 buf_size = 4 + size + padding;
103 buf = GNUNET_malloc (buf_size);
104 GNUNET_memcpy (buf, len, 4);
105 GNUNET_memcpy (buf+4, pt, size);
106 *ct = GNUNET_malloc (buf_size);
108 GNUNET_assert (0 == gcry_cipher_encrypt (handle, *ct, buf_size, buf, buf_size));
109 gcry_cipher_close (handle);
110 //AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT);
116 aes_128_cbc_decrypt( char* ct,
121 struct GNUNET_CRYPTO_SymmetricSessionKey skey;
122 gcry_cipher_hd_t handle;
123 unsigned char iv[16];
127 init_aes(k, 1, &handle, &skey, iv);
129 tmp = GNUNET_malloc (size);
131 //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));
133 gcry_cipher_close (handle);
134 /* TODO make less crufty */
136 /* get real length */
139 | ((tmp[0])<<24) | ((tmp[1])<<16)
140 | ((tmp[2])<<8) | ((tmp[3])<<0);
141 /* truncate any garbage from the padding */
142 *pt = GNUNET_malloc (len);
143 GNUNET_memcpy (*pt, tmp+4, len);
148 struct GNUNET_CRYPTO_AbeMasterKey*
149 GNUNET_CRYPTO_cpabe_create_master_key (void)
151 struct GNUNET_CRYPTO_AbeMasterKey* key;
152 key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey);
153 gabe_setup(&key->pub, &key->msk);
154 GNUNET_assert (NULL != key->pub);
155 GNUNET_assert (NULL != key->msk);
160 GNUNET_CRYPTO_cpabe_delete_master_key (struct GNUNET_CRYPTO_AbeMasterKey *key)
162 gabe_msk_free (key->msk);
163 gabe_pub_free (key->pub);
164 //GNUNET_free (key->msk);
165 //gabe_msk_free (key->msk); //For some reason free of pub implicit?
169 struct GNUNET_CRYPTO_AbeKey*
170 GNUNET_CRYPTO_cpabe_create_key (struct GNUNET_CRYPTO_AbeMasterKey *key,
173 struct GNUNET_CRYPTO_AbeKey *prv_key;
177 prv_key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
178 prv_key->prv = gabe_keygen(key->pub, key->msk, attrs);
179 size = gabe_pub_serialize(key->pub, &tmp);
180 prv_key->pub = gabe_pub_unserialize(tmp, size);
182 GNUNET_assert (NULL != prv_key->prv);
187 GNUNET_CRYPTO_cpabe_delete_key (struct GNUNET_CRYPTO_AbeKey *key,
190 //Memory management in gabe is buggy
191 gabe_prv_free (key->prv);
192 if (GNUNET_YES == delete_pub)
193 gabe_pub_free (key->pub);
198 write_cpabe (void **result,
208 *result = GNUNET_malloc (12 + cph_buf_len + aes_buf_len);
210 len = (uint32_t*) ptr;
211 *len = htonl (file_len);
213 len = (uint32_t*) ptr;
214 *len = htonl (aes_buf_len);
216 memcpy (ptr, aes_buf, aes_buf_len);
218 len = (uint32_t*) ptr;
219 *len = htonl (cph_buf_len);
221 memcpy (ptr, cph_buf, cph_buf_len);
222 return 12 + cph_buf_len + aes_buf_len;
226 read_cpabe (const void *data,
237 len = (uint32_t*)ptr;
238 buf_len = ntohl (*len);
240 len = (uint32_t*)ptr;
241 *aes_buf_len = ntohl (*len);
243 *aes_buf = GNUNET_malloc (*aes_buf_len);
244 memcpy(*aes_buf, ptr, *aes_buf_len);
246 len = (uint32_t*)ptr;
247 *cph_buf_len = ntohl (*len);
249 *cph_buf = GNUNET_malloc (*cph_buf_len);
250 memcpy(*cph_buf, ptr, *cph_buf_len);
256 GNUNET_CRYPTO_cpabe_encrypt (const void *block,
259 const struct GNUNET_CRYPTO_AbeMasterKey *key,
271 if( !(cph = gabe_enc(key->pub, m, (char*)policy)) )
272 return GNUNET_SYSERR;
273 cph_buf_len = gabe_cph_serialize(cph,
277 plt = GNUNET_memdup (block, size);
278 aes_buf_len = aes_128_cbc_encrypt(plt, size, m, &aes_buf);
281 result_len = write_cpabe(result, size, cph_buf, cph_buf_len, aes_buf, aes_buf_len);
282 GNUNET_free(cph_buf);
283 GNUNET_free(aes_buf);
288 GNUNET_CRYPTO_cpabe_decrypt (const void *block,
290 const struct GNUNET_CRYPTO_AbeKey *key,
301 read_cpabe(block, &cph_buf, &cph_buf_size, &aes_buf, &aes_buf_size);
302 cph = gabe_cph_unserialize(key->pub, cph_buf, cph_buf_size);
303 if( !gabe_dec(key->pub, key->prv, cph, m) ) {
304 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
305 "%s\n", gabe_error());
306 GNUNET_free (aes_buf);
307 GNUNET_free (cph_buf);
311 return GNUNET_SYSERR;
315 plt_len = aes_128_cbc_decrypt(aes_buf, aes_buf_size, m, (char**)result);
316 GNUNET_free (cph_buf);
317 GNUNET_free (aes_buf);
319 //freeing is buggy in gabe
320 //gabe_prv_free (prv);
321 //gabe_pub_free (pub);
326 GNUNET_CRYPTO_cpabe_serialize_key (const struct GNUNET_CRYPTO_AbeKey *key,
335 pub_len = gabe_pub_serialize (key->pub, &pub);
336 prv_len = gabe_prv_serialize (key->prv, &prv);
338 len = pub_len + prv_len + 12;
339 write_cpabe (result, len, pub, pub_len, prv, prv_len);
347 struct GNUNET_CRYPTO_AbeKey*
348 GNUNET_CRYPTO_cpabe_deserialize_key (const void *data,
351 struct GNUNET_CRYPTO_AbeKey *key;
357 key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
363 key->pub = gabe_pub_unserialize (pub, pub_len);
364 key->prv = gabe_prv_unserialize (key->pub, prv, prv_len);
372 GNUNET_CRYPTO_cpabe_serialize_master_key (const struct GNUNET_CRYPTO_AbeMasterKey *key,
381 pub_len = gabe_pub_serialize (key->pub, &pub);
382 msk_len = gabe_msk_serialize (key->msk, &msk);
384 len = pub_len + msk_len + 12;
385 write_cpabe (result, len, pub, pub_len, msk, msk_len);
393 struct GNUNET_CRYPTO_AbeMasterKey*
394 GNUNET_CRYPTO_cpabe_deserialize_master_key (const void *data,
397 struct GNUNET_CRYPTO_AbeMasterKey *key;
403 key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey);
409 key->pub = gabe_pub_unserialize (pub, pub_len);
410 key->msk = gabe_msk_unserialize (key->pub, msk, msk_len);