GNUnet  0.10.x
crypto_abe.c
Go to the documentation of this file.
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 
29 #include "platform.h"
30 #include <pbc/pbc.h>
31 #include <gabe.h>
32 
33 #include "gnunet_crypto_lib.h"
34 
36 {
37  gabe_pub_t* pub;
38  gabe_msk_t* msk;
39 };
40 
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,
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,
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 static int
83  int size,
84  element_t k,
85  char **ct )
86 {
87  gcry_cipher_hd_t handle;
89  unsigned char iv[16];
90  char* buf;
91  int padding;
92  int buf_size;
93  uint8_t len[4];
94  init_aes(k, 1, &handle, &skey, iv);
95 
96  /* TODO make less crufty */
97 
98  /* stuff in real length (big endian) before padding */
99  len[0] = (size & 0xff000000)>>24;
100  len[1] = (size & 0xff0000)>>16;
101  len[2] = (size & 0xff00)>>8;
102  len[3] = (size & 0xff)>>0;
103  padding = 16 - ((4+size) % 16);
104  buf_size = 4 + size + padding;
105  buf = GNUNET_malloc (buf_size);
106  GNUNET_memcpy (buf, len, 4);
107  GNUNET_memcpy (buf+4, pt, size);
108  *ct = GNUNET_malloc (buf_size);
109 
110  GNUNET_assert (0 == gcry_cipher_encrypt (handle, *ct, buf_size, buf, buf_size));
111  gcry_cipher_close (handle);
112  //AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT);
113  GNUNET_free (buf);
114  return buf_size;
115 }
116 
117 static int
119  int size,
120  element_t k,
121  char **pt )
122 {
124  gcry_cipher_hd_t handle;
125  unsigned char iv[16];
126  char* tmp;
127  uint32_t len;
128 
129  init_aes(k, 1, &handle, &skey, iv);
130 
131  tmp = GNUNET_malloc (size);
132 
133  //AES_cbc_encrypt(ct->data, pt->data, ct->len, &key, iv, AES_DECRYPT);
134  GNUNET_assert (0 == gcry_cipher_decrypt (handle, tmp, size, ct, size));
135  gcry_cipher_close (handle);
136  /* TODO make less crufty */
137 
138  /* get real length */
139  len = 0;
140  len = len
141  | ((tmp[0])<<24) | ((tmp[1])<<16)
142  | ((tmp[2])<<8) | ((tmp[3])<<0);
143  /* truncate any garbage from the padding */
144  *pt = GNUNET_malloc (len);
145  GNUNET_memcpy (*pt, tmp+4, len);
146  GNUNET_free (tmp);
147  return len;
148 }
149 
152 {
154  key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey);
155  gabe_setup(&key->pub, &key->msk);
156  GNUNET_assert (NULL != key->pub);
157  GNUNET_assert (NULL != key->msk);
158  return key;
159 }
160 
161 void
163 {
164  gabe_msk_free (key->msk);
165  gabe_pub_free (key->pub);
166  //GNUNET_free (key->msk);
167  //gabe_msk_free (key->msk); //For some reason free of pub implicit?
168  GNUNET_free (key);
169 }
170 
171 struct GNUNET_CRYPTO_AbeKey*
173  char **attrs)
174 {
175  struct GNUNET_CRYPTO_AbeKey *prv_key;
176  int size;
177  char *tmp;
178 
179  prv_key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
180  prv_key->prv = gabe_keygen(key->pub, key->msk, attrs);
181  size = gabe_pub_serialize(key->pub, &tmp);
182  prv_key->pub = gabe_pub_unserialize(tmp, size);
183  GNUNET_free (tmp);
184  GNUNET_assert (NULL != prv_key->prv);
185  return prv_key;
186 }
187 
188 void
190  int delete_pub)
191 {
192  //Memory management in gabe is buggy
193  gabe_prv_free (key->prv);
194  if (GNUNET_YES == delete_pub)
195  gabe_pub_free (key->pub);
196  GNUNET_free (key);
197 }
198 
199 ssize_t
201  uint32_t file_len,
202  char* cph_buf,
203  int cph_buf_len,
204  char* aes_buf,
205  int aes_buf_len)
206 {
207  char *ptr;
208  uint32_t *len;
209 
210  *result = GNUNET_malloc (12 + cph_buf_len + aes_buf_len);
211  ptr = *result;
212  len = (uint32_t*) ptr;
213  *len = htonl (file_len);
214  ptr += 4;
215  len = (uint32_t*) ptr;
216  *len = htonl (aes_buf_len);
217  ptr += 4;
218  GNUNET_memcpy (ptr, aes_buf, aes_buf_len);
219  ptr += aes_buf_len;
220  len = (uint32_t*) ptr;
221  *len = htonl (cph_buf_len);
222  ptr += 4;
223  GNUNET_memcpy (ptr, cph_buf, cph_buf_len);
224  return 12 + cph_buf_len + aes_buf_len;
225 }
226 
227 ssize_t
228 read_cpabe (const void *data,
229  char** cph_buf,
230  int *cph_buf_len,
231  char** aes_buf,
232  int *aes_buf_len)
233 {
234  int buf_len;
235  char *ptr;
236  uint32_t *len;
237 
238  ptr = (char*)data;
239  len = (uint32_t*)ptr;
240  buf_len = ntohl (*len);
241  ptr += 4;
242  len = (uint32_t*)ptr;
243  *aes_buf_len = ntohl (*len);
244  ptr += 4;
245  *aes_buf = GNUNET_malloc (*aes_buf_len);
246  GNUNET_memcpy (*aes_buf, ptr, *aes_buf_len);
247  ptr += *aes_buf_len;
248  len = (uint32_t*)ptr;
249  *cph_buf_len = ntohl (*len);
250  ptr += 4;
251  *cph_buf = GNUNET_malloc (*cph_buf_len);
252  GNUNET_memcpy (*cph_buf, ptr, *cph_buf_len);
253 
254  return buf_len;
255 }
256 
257 ssize_t
258 GNUNET_CRYPTO_cpabe_encrypt (const void *block,
259  size_t size,
260  const char *policy,
261  const struct GNUNET_CRYPTO_AbeMasterKey *key,
262  void **result)
263 {
264  gabe_cph_t* cph;
265  char* plt;
266  char* cph_buf;
267  char* aes_buf;
268  element_t m;
269  int cph_buf_len;
270  int aes_buf_len;
271  ssize_t result_len;
272 
273  if( !(cph = gabe_enc(key->pub, m, (char*)policy)) )
274  return GNUNET_SYSERR;
275  cph_buf_len = gabe_cph_serialize(cph,
276  &cph_buf);
277  gabe_cph_free(cph);
278  GNUNET_free (cph);
279  plt = GNUNET_memdup (block, size);
280  aes_buf_len = aes_128_cbc_encrypt(plt, size, m, &aes_buf);
281  GNUNET_free (plt);
282  element_clear(m);
283  result_len = write_cpabe(result, size, cph_buf, cph_buf_len, aes_buf, aes_buf_len);
284  GNUNET_free(cph_buf);
285  GNUNET_free(aes_buf);
286  return result_len;
287 }
288 
289 ssize_t
290 GNUNET_CRYPTO_cpabe_decrypt (const void *block,
291  size_t size,
292  const struct GNUNET_CRYPTO_AbeKey *key,
293  void **result)
294 {
295  char* aes_buf;
296  char* cph_buf;
297  gabe_cph_t* cph;
298  element_t m;
299  int cph_buf_size;
300  int aes_buf_size;
301  int plt_len;
302 
303  read_cpabe(block, &cph_buf, &cph_buf_size, &aes_buf, &aes_buf_size);
304  cph = gabe_cph_unserialize(key->pub, cph_buf, cph_buf_size);
305  if( !gabe_dec(key->pub, key->prv, cph, m) ) {
307  "%s\n", gabe_error());
308  GNUNET_free (aes_buf);
309  GNUNET_free (cph_buf);
310  gabe_cph_free(cph);
311  GNUNET_free (cph);
312  element_clear (m);
313  return GNUNET_SYSERR;
314  }
315  gabe_cph_free(cph);
316  GNUNET_free (cph);
317  plt_len = aes_128_cbc_decrypt(aes_buf, aes_buf_size, m, (char**)result);
318  GNUNET_free (cph_buf);
319  GNUNET_free (aes_buf);
320  element_clear (m);
321  //freeing is buggy in gabe
322  //gabe_prv_free (prv);
323  //gabe_pub_free (pub);
324  return plt_len;
325 }
326 
327 ssize_t
329  void **result)
330 {
331  ssize_t len;
332  char *pub;
333  char *prv;
334  int pub_len;
335  int prv_len;
336 
337  pub_len = gabe_pub_serialize (key->pub, &pub);
338  prv_len = gabe_prv_serialize (key->prv, &prv);
339 
340  len = pub_len + prv_len + 12;
341  write_cpabe (result, len, pub, pub_len, prv, prv_len);
342 
343  GNUNET_free (pub);
344  GNUNET_free (prv);
345 
346  return len;
347 }
348 
349 struct GNUNET_CRYPTO_AbeKey*
351  size_t len)
352 {
353  struct GNUNET_CRYPTO_AbeKey *key;
354  char *pub;
355  char *prv;
356  int prv_len;
357  int pub_len;
358 
359  key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
360  read_cpabe (data,
361  &pub,
362  &pub_len,
363  &prv,
364  &prv_len);
365  key->pub = gabe_pub_unserialize (pub, pub_len);
366  key->prv = gabe_prv_unserialize (key->pub, prv, prv_len);
367 
368  GNUNET_free (pub);
369  GNUNET_free (prv);
370  return key;
371 }
372 
373 ssize_t
375  void **result)
376 {
377  ssize_t len;
378  char *pub;
379  char *msk;
380  int pub_len;
381  int msk_len;
382 
383  pub_len = gabe_pub_serialize (key->pub, &pub);
384  msk_len = gabe_msk_serialize (key->msk, &msk);
385 
386  len = pub_len + msk_len + 12;
387  write_cpabe (result, len, pub, pub_len, msk, msk_len);
388 
389  GNUNET_free (pub);
390  GNUNET_free (msk);
391 
392  return len;
393 }
394 
397  size_t len)
398 {
400  char *msk;
401  char *pub;
402  int msk_len;
403  int pub_len;
404 
405  key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey);
406  read_cpabe (data,
407  &pub,
408  &pub_len,
409  &msk,
410  &msk_len);
411  key->pub = gabe_pub_unserialize (pub, pub_len);
412  key->msk = gabe_msk_unserialize (key->pub, msk, msk_len);
413 
414  GNUNET_free (pub);
415  GNUNET_free (msk);
416 
417  return key;
418 }
void GNUNET_CRYPTO_cpabe_delete_key(struct GNUNET_CRYPTO_AbeKey *key, int delete_pub)
Definition: crypto_abe.c:189
ssize_t GNUNET_CRYPTO_cpabe_serialize_key(const struct GNUNET_CRYPTO_AbeKey *key, void **result)
Definition: crypto_abe.c:328
static int init_aes(element_t k, int enc, gcry_cipher_hd_t *handle, struct GNUNET_CRYPTO_SymmetricSessionKey *key, unsigned char *iv)
Definition: crypto_abe.c:48
struct GNUNET_CRYPTO_AbeMasterKey * GNUNET_CRYPTO_cpabe_create_master_key(void)
Definition: crypto_abe.c:151
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
ssize_t read_cpabe(const void *data, char **cph_buf, int *cph_buf_len, char **aes_buf, int *aes_buf_len)
Definition: crypto_abe.c:228
struct GNUNET_CRYPTO_AbeMasterKey * GNUNET_CRYPTO_cpabe_deserialize_master_key(const void *data, size_t len)
Definition: crypto_abe.c:396
static int aes_128_cbc_encrypt(char *pt, int size, element_t k, char **ct)
Definition: crypto_abe.c:82
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
struct GNUNET_CRYPTO_AbeKey * GNUNET_CRYPTO_cpabe_create_key(struct GNUNET_CRYPTO_AbeMasterKey *key, char **attrs)
Definition: crypto_abe.c:172
#define GNUNET_new(type)
Allocate a struct or union of the given type.
unsigned char aes_key[(256/8)]
Actual key for AES.
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:99
cryptographic primitives for GNUnet
static int aes_128_cbc_decrypt(char *ct, int size, element_t k, char **pt)
Definition: crypto_abe.c:118
gabe_pub_t * pub
Definition: crypto_abe.c:43
#define GNUNET_memcpy(dst, src, n)
ssize_t write_cpabe(void **result, uint32_t file_len, char *cph_buf, int cph_buf_len, char *aes_buf, int aes_buf_len)
Definition: crypto_abe.c:200
static char buf[2048]
ssize_t GNUNET_CRYPTO_cpabe_encrypt(const void *block, size_t size, const char *policy, const struct GNUNET_CRYPTO_AbeMasterKey *key, void **result)
Definition: crypto_abe.c:258
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static int result
Global testing status.
void GNUNET_CRYPTO_cpabe_delete_master_key(struct GNUNET_CRYPTO_AbeMasterKey *key)
Definition: crypto_abe.c:162
struct GNUNET_CRYPTO_AbeKey * GNUNET_CRYPTO_cpabe_deserialize_key(const void *data, size_t len)
Definition: crypto_abe.c:350
#define GNUNET_CRYPTO_AES_KEY_LENGTH
length of the sessionkey in bytes (256 BIT sessionkey)
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
static unsigned int size
Size of the "table".
Definition: peer.c:67
ssize_t GNUNET_CRYPTO_cpabe_decrypt(const void *block, size_t size, const struct GNUNET_CRYPTO_AbeKey *key, void **result)
Definition: crypto_abe.c:290
static OpusEncoder * enc
OPUS encoder.
#define GNUNET_log(kind,...)
ssize_t GNUNET_CRYPTO_cpabe_serialize_master_key(const struct GNUNET_CRYPTO_AbeMasterKey *key, void **result)
Definition: crypto_abe.c:374
gabe_prv_t * prv
Definition: crypto_abe.c:44
#define GNUNET_YES
Definition: gnunet_common.h:80
uint32_t data
The data value.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...