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);
151 struct GNUNET_CRYPTO_AbeKey*
152 GNUNET_CRYPTO_cpabe_create_key (struct GNUNET_CRYPTO_AbeMasterKey *key,
155 struct GNUNET_CRYPTO_AbeKey *prv_key;
162 pub = bswabe_pub_unserialize(key->pub, 0);
163 msk = bswabe_msk_unserialize(pub, key->msk, 0);
164 prv = bswabe_keygen(pub, msk, attrs);
165 prv_key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
166 prv_key->prv = bswabe_prv_serialize(prv);
167 pub_data = g_strndup ((gchar*)key->pub->data,
170 prv_key->pub = g_byte_array_new_take ((guint8*)pub_data, len);
171 GNUNET_assert (NULL != prv_key->prv);
176 write_cpabe (void **result, GByteArray* cph_buf,
177 int file_len, GByteArray* aes_buf)
182 size = aes_buf->len + cph_buf->len + 12;
183 *result = GNUNET_malloc (size);
185 for(i=3; i >= 0; i--) {
186 *ptr = (file_len & 0xff<<(i*8))>>(i*8);
189 for(i=3; i >= 0; i--) {
190 *ptr = (aes_buf->len & 0xff<<(i*8))>>(i*8);
193 memcpy (ptr, aes_buf->data, aes_buf->len);
195 for(i=3; i >= 0; i--) {
196 *ptr = (cph_buf->len & 0xff<<(i*8))>>(i*8);
199 memcpy (ptr, cph_buf->data, cph_buf->len);
204 read_cpabe (const void *data, GByteArray** cph_buf, GByteArray** aes_buf)
211 *cph_buf = g_byte_array_new();
212 *aes_buf = g_byte_array_new();
216 for(i=3; i >= 0; i--) {
217 buf_len |= *ptr<<(i*8);
222 for(i=3; i >= 0; i--) {
223 tmp_len |= *ptr<<(i*8);
226 g_byte_array_set_size(*aes_buf, tmp_len);
227 memcpy((*aes_buf)->data, ptr, tmp_len);
230 for(i=3; i >= 0; i--) {
231 tmp_len |= *ptr<<(i*8);
234 g_byte_array_set_size(*cph_buf, tmp_len);
235 memcpy((*cph_buf)->data, ptr, tmp_len);
241 GNUNET_CRYPTO_cpabe_encrypt (const void *block,
244 const struct GNUNET_CRYPTO_AbeMasterKey *key,
256 pub = bswabe_pub_unserialize(key->pub, 0);
257 if( !(cph = bswabe_enc(pub, m, policy)) )
258 return GNUNET_SYSERR;
259 cph_buf = bswabe_cph_serialize(cph);
260 bswabe_cph_free(cph);
261 data = g_memdup (block, size);
262 plt = g_byte_array_new_take (data, size);
263 payload_len = plt->len;
264 aes_buf = aes_128_cbc_encrypt(plt, m);
265 g_byte_array_free(plt, 1);
267 result_len = write_cpabe(result, cph_buf, payload_len, aes_buf);
268 g_byte_array_free(cph_buf, 1);
269 g_byte_array_free(aes_buf, 1);
274 GNUNET_CRYPTO_cpabe_decrypt (const void *block,
276 const struct GNUNET_CRYPTO_AbeKey *key,
288 pub = bswabe_pub_unserialize(key->pub, 0);
289 prv = bswabe_prv_unserialize(pub, key->prv, 0);
290 pt_size = read_cpabe(block, &cph_buf, &aes_buf);
291 cph = bswabe_cph_unserialize(pub, cph_buf, 0);
292 if( !bswabe_dec(pub, prv, cph, m) ) {
293 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
294 "%s\n", bswabe_error());
295 return GNUNET_SYSERR;
297 bswabe_cph_free(cph);
298 plt = aes_128_cbc_decrypt(aes_buf, m);
299 g_byte_array_set_size(plt, size);
300 g_byte_array_free(aes_buf, 1);
301 *result = GNUNET_malloc (plt->len);
302 GNUNET_memcpy (*result, plt->data, plt->len);
308 GNUNET_CRYPTO_cpabe_serialize_key (const struct GNUNET_CRYPTO_AbeKey *key,
313 len = key->pub->len + key->prv->len + 12;
314 write_cpabe (result, key->pub, len, key->prv);
319 struct GNUNET_CRYPTO_AbeKey*
320 GNUNET_CRYPTO_cpabe_deserialize_key (const void *data,
323 struct GNUNET_CRYPTO_AbeKey *key;
325 key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
326 read_cpabe (data, &key->pub, &key->prv);
332 GNUNET_CRYPTO_cpabe_serialize_master_key (const struct GNUNET_CRYPTO_AbeMasterKey *key,
337 len = key->pub->len + key->msk->len + 12;
338 write_cpabe (result, key->pub, len, key->msk);
343 struct GNUNET_CRYPTO_AbeMasterKey*
344 GNUNET_CRYPTO_cpabe_deserialize_master_key (const void *data,
347 struct GNUNET_CRYPTO_AbeMasterKey *key;
349 key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey);
350 read_cpabe (data, &key->pub, &key->msk);