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
31 #include <openssl/aes.h>
32 #include <openssl/sha.h>
36 #include "gnunet_crypto_lib.h"
38 struct GNUNET_CRYPTO_AbeMasterKey
45 struct GNUNET_CRYPTO_AbeKey
52 init_aes( element_t k, int enc, AES_KEY* key, unsigned char* iv )
55 unsigned char* key_buf;
57 key_len = element_length_in_bytes(k) < 17 ? 17 : element_length_in_bytes(k);
58 key_buf = (unsigned char*) malloc(key_len);
59 element_to_bytes(key_buf, k);
62 AES_set_encrypt_key(key_buf + 1, 128, key);
64 AES_set_decrypt_key(key_buf + 1, 128, key);
71 aes_128_cbc_encrypt( GByteArray* pt, element_t k )
79 init_aes(k, 1, &key, iv);
81 /* TODO make less crufty */
83 /* stuff in real length (big endian) before padding */
84 len[0] = (pt->len & 0xff000000)>>24;
85 len[1] = (pt->len & 0xff0000)>>16;
86 len[2] = (pt->len & 0xff00)>>8;
87 len[3] = (pt->len & 0xff)>>0;
88 g_byte_array_prepend(pt, len, 4);
90 /* pad out to multiple of 128 bit (16 byte) blocks */
93 g_byte_array_append(pt, &zero, 1);
95 ct = g_byte_array_new();
96 g_byte_array_set_size(ct, pt->len);
98 AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT);
104 aes_128_cbc_decrypt( GByteArray* ct, element_t k )
107 unsigned char iv[16];
111 init_aes(k, 0, &key, iv);
113 pt = g_byte_array_new();
114 g_byte_array_set_size(pt, ct->len);
116 AES_cbc_encrypt(ct->data, pt->data, ct->len, &key, iv, AES_DECRYPT);
118 /* TODO make less crufty */
120 /* get real length */
123 | ((pt->data[0])<<24) | ((pt->data[1])<<16)
124 | ((pt->data[2])<<8) | ((pt->data[3])<<0);
125 g_byte_array_remove_index(pt, 0);
126 g_byte_array_remove_index(pt, 0);
127 g_byte_array_remove_index(pt, 0);
128 g_byte_array_remove_index(pt, 0);
130 /* truncate any garbage from the padding */
131 g_byte_array_set_size(pt, len);
136 struct GNUNET_CRYPTO_AbeMasterKey*
137 GNUNET_CRYPTO_cpabe_create_master_key (void)
139 struct GNUNET_CRYPTO_AbeMasterKey* key;
142 bswabe_setup(&pub, &msk);
143 key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey);
144 key->pub = bswabe_pub_serialize(pub);
145 key->msk = bswabe_msk_serialize(msk);
146 GNUNET_assert (NULL != key->pub);
147 GNUNET_assert (NULL != key->msk);
148 bswabe_pub_free (pub);
149 bswabe_msk_free (msk);
154 GNUNET_CRYPTO_cpabe_delete_master_key (struct GNUNET_CRYPTO_AbeMasterKey *key)
156 g_byte_array_unref (key->msk);
157 g_byte_array_unref (key->pub);
161 struct GNUNET_CRYPTO_AbeKey*
162 GNUNET_CRYPTO_cpabe_create_key (struct GNUNET_CRYPTO_AbeMasterKey *key,
165 struct GNUNET_CRYPTO_AbeKey *prv_key;
171 pub = bswabe_pub_unserialize(key->pub, 0);
172 msk = bswabe_msk_unserialize(pub, key->msk, 0);
173 prv = bswabe_keygen(pub, msk, attrs);
174 prv_key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
175 prv_key->prv = bswabe_prv_serialize(prv);
177 printf ("Keylen %lu\n", len);
178 prv_key->pub = bswabe_pub_serialize (pub);
179 GNUNET_assert (NULL != prv_key->prv);
180 bswabe_prv_free (prv);
181 bswabe_pub_free (pub);
182 bswabe_msk_free (msk);
187 GNUNET_CRYPTO_cpabe_delete_key (struct GNUNET_CRYPTO_AbeKey *key)
189 g_byte_array_unref (key->prv);
190 g_byte_array_unref (key->pub);
195 write_cpabe (void **result, GByteArray* cph_buf,
196 uint32_t file_len, GByteArray* aes_buf)
201 *result = GNUNET_malloc (12 + cph_buf->len + aes_buf->len);
203 len = (uint32_t*) ptr;
204 *len = htonl (file_len);
206 len = (uint32_t*) ptr;
207 *len = htonl (aes_buf->len);
209 memcpy (ptr, aes_buf->data, aes_buf->len);
211 len = (uint32_t*) ptr;
212 *len = htonl (cph_buf->len);
214 memcpy (ptr, cph_buf->data, cph_buf->len);
215 return 12 + cph_buf->len + aes_buf->len;
219 read_cpabe (const void *data, GByteArray** cph_buf, GByteArray** aes_buf)
226 *cph_buf = g_byte_array_new();
227 *aes_buf = g_byte_array_new();
229 len = (uint32_t*)ptr;
230 buf_len = ntohl (*len);
232 len = (uint32_t*)ptr;
233 tmp_len = ntohl (*len);
235 g_byte_array_set_size(*aes_buf, tmp_len);
236 memcpy((*aes_buf)->data, ptr, tmp_len);
238 len = (uint32_t*)ptr;
239 tmp_len = ntohl (*len);
241 g_byte_array_set_size(*cph_buf, tmp_len);
242 memcpy((*cph_buf)->data, ptr, tmp_len);
248 GNUNET_CRYPTO_cpabe_encrypt (const void *block,
251 const struct GNUNET_CRYPTO_AbeMasterKey *key,
264 pub = bswabe_pub_unserialize(key->pub, 0);
265 if( !(cph = bswabe_enc(pub, m, policy)) )
266 return GNUNET_SYSERR;
267 cph_buf = bswabe_cph_serialize(cph);
268 bswabe_cph_free(cph);
269 data = g_memdup (block, size);
270 plt = g_byte_array_new_take (data, size);
271 payload_len = plt->len;
272 aes_buf = aes_128_cbc_encrypt(plt, m);
273 g_byte_array_free(plt, 1);
275 result_len = write_cpabe(result, cph_buf, payload_len, aes_buf);
276 g_byte_array_free(cph_buf, 1);
277 g_byte_array_free(aes_buf, 1);
278 bswabe_pub_free (pub);
283 GNUNET_CRYPTO_cpabe_decrypt (const void *block,
285 const struct GNUNET_CRYPTO_AbeKey *key,
297 pub = bswabe_pub_unserialize(key->pub, 0);
298 prv = bswabe_prv_unserialize(pub, key->prv, 0);
299 pt_size = read_cpabe(block, &cph_buf, &aes_buf);
300 cph = bswabe_cph_unserialize(pub, cph_buf, 0);
301 if( !bswabe_dec(pub, prv, cph, m) ) {
302 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
303 "%s\n", bswabe_error());
304 return GNUNET_SYSERR;
306 bswabe_cph_free(cph);
307 plt = aes_128_cbc_decrypt(aes_buf, m);
308 g_byte_array_set_size(plt, size);
309 g_byte_array_free(aes_buf, 1);
310 *result = GNUNET_malloc (plt->len);
311 GNUNET_memcpy (*result, plt->data, plt->len);
312 bswabe_prv_free (prv);
313 bswabe_pub_free (pub);
318 GNUNET_CRYPTO_cpabe_serialize_key (const struct GNUNET_CRYPTO_AbeKey *key,
323 len = key->pub->len + key->prv->len + 12;
324 write_cpabe (result, key->pub, len, key->prv);
329 struct GNUNET_CRYPTO_AbeKey*
330 GNUNET_CRYPTO_cpabe_deserialize_key (const void *data,
333 struct GNUNET_CRYPTO_AbeKey *key;
335 key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
336 read_cpabe (data, &key->pub, &key->prv);
342 GNUNET_CRYPTO_cpabe_serialize_master_key (const struct GNUNET_CRYPTO_AbeMasterKey *key,
347 len = key->pub->len + key->msk->len + 12;
348 write_cpabe (result, key->pub, len, key->msk);
353 struct GNUNET_CRYPTO_AbeMasterKey*
354 GNUNET_CRYPTO_cpabe_deserialize_master_key (const void *data,
357 struct GNUNET_CRYPTO_AbeMasterKey *key;
359 key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey);
360 read_cpabe (data, &key->pub, &key->msk);