56 unsigned char*key_buf;
58 key_len = element_length_in_bytes (k) < 33 ? 3 : element_length_in_bytes (k);
59 key_buf = (
unsigned char *) malloc (key_len);
60 element_to_bytes (key_buf, k);
64 gcry_cipher_open (handle, GCRY_CIPHER_AES256,
65 GCRY_CIPHER_MODE_CFB, 0));
66 rc = gcry_cipher_setkey (*handle,
71 rc = gcry_cipher_setiv (*handle,
100 len[0] = (size & 0xff000000) >> 24;
101 len[1] = (size & 0xff0000) >> 16;
102 len[2] = (size & 0xff00) >> 8;
103 len[3] = (size & 0xff) >> 0;
104 padding = 16 - ((4 +
size) % 16);
105 buf_size = 4 + size + padding;
111 GNUNET_assert (0 == gcry_cipher_encrypt (handle, *ct, buf_size, buf,
113 gcry_cipher_close (handle);
128 unsigned char iv[16];
132 init_aes (k, 1, &handle, &skey, iv);
137 GNUNET_assert (0 == gcry_cipher_decrypt (handle, tmp, size, ct, size));
138 gcry_cipher_close (handle);
144 | ((tmp[0]) << 24) | ((tmp[1]) << 16)
145 | ((tmp[2]) << 8) | ((tmp[3]) << 0);
166 gabe_setup (&key->
pub, &key->
msk);
183 gabe_msk_free (key->
msk);
184 gabe_pub_free (key->
pub);
208 prv_key->
prv = gabe_keygen (key->
pub, key->
msk, attrs);
209 size = gabe_pub_serialize (key->
pub, &tmp);
210 prv_key->
pub = gabe_pub_unserialize (tmp, size);
230 gabe_prv_free (key->
prv);
232 gabe_pub_free (key->
pub);
250 len = (uint32_t *) ptr;
251 *len = htonl (file_len);
253 len = (uint32_t *) ptr;
254 *len = htonl (aes_buf_len);
258 len = (uint32_t *) ptr;
259 *len = htonl (cph_buf_len);
262 return 12 + cph_buf_len + aes_buf_len;
278 len = (uint32_t *) ptr;
279 buf_len = ntohl (*len);
281 len = (uint32_t *) ptr;
282 *aes_buf_len = ntohl (*len);
287 len = (uint32_t *) ptr;
288 *cph_buf_len = ntohl (*len);
324 if (! (cph = gabe_enc (key->
pub, m, (
char *) policy)))
326 cph_buf_len = gabe_cph_serialize (cph,
334 result_len =
write_cpabe (result, size, cph_buf, cph_buf_len, aes_buf,
366 read_cpabe (block, &cph_buf, &cph_buf_size, &aes_buf, &aes_buf_size);
367 cph = gabe_cph_unserialize (key->
pub, cph_buf, cph_buf_size);
368 if (! gabe_dec (key->
pub, key->
prv, cph, m))
371 "%s\n", gabe_error ());
410 pub_len = gabe_pub_serialize (key->
pub, &pub);
411 prv_len = gabe_prv_serialize (key->
prv, &prv);
413 len = pub_len + prv_len + 12;
414 write_cpabe (result, len, pub, pub_len, prv, prv_len);
447 key->
pub = gabe_pub_unserialize (pub, pub_len);
448 key->
prv = gabe_prv_unserialize (key->
pub, prv, prv_len);
475 pub_len = gabe_pub_serialize (key->
pub, &pub);
476 msk_len = gabe_msk_serialize (key->
msk, &msk);
478 len = pub_len + msk_len + 12;
479 write_cpabe (result, len, pub, pub_len, msk, msk_len);
512 key->
pub = gabe_pub_unserialize (pub, pub_len);
513 key->
msk = gabe_msk_unserialize (key->
pub, msk, msk_len);
static int aes_128_cbc_decrypt(char *ct, int size, element_t k, char **pt)
static int init_aes(element_t k, int enc, gcry_cipher_hd_t *handle, struct GNUNET_CRYPTO_SymmetricSessionKey *key, unsigned char *iv)
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
ssize_t GNUNET_ABE_cpabe_serialize_master_key(const struct GNUNET_ABE_AbeMasterKey *key, void **result)
Serialize an ABE master key.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
#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.
cryptographic primitives for GNUnet
ssize_t GNUNET_ABE_cpabe_decrypt(const void *block, size_t size, const struct GNUNET_ABE_AbeKey *key, void **result)
Decrypt a block using the ABE key.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static int result
Global testing status.
ssize_t GNUNET_ABE_cpabe_encrypt(const void *block, size_t size, const char *policy, const struct GNUNET_ABE_AbeMasterKey *key, void **result)
Encrypt a block using sessionkey.
struct GNUNET_ABE_AbeMasterKey * GNUNET_ABE_cpabe_create_master_key(void)
Create a new CP-ABE master key.
#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.
ssize_t GNUNET_ABE_cpabe_serialize_key(const struct GNUNET_ABE_AbeKey *key, void **result)
Serialize an ABE key.
static unsigned int size
Size of the "table".
static ssize_t write_cpabe(void **result, uint32_t file_len, char *cph_buf, int cph_buf_len, char *aes_buf, int aes_buf_len)
struct GNUNET_ABE_AbeMasterKey * GNUNET_ABE_cpabe_deserialize_master_key(const void *data, size_t len)
Deserialize an ABE master key.
void GNUNET_ABE_cpabe_delete_master_key(struct GNUNET_ABE_AbeMasterKey *key)
Delete a CP-ABE master key.
static int aes_128_cbc_encrypt(char *pt, int size, element_t k, char **ct)
struct GNUNET_ABE_AbeKey * GNUNET_ABE_cpabe_deserialize_key(const void *data, size_t len)
Deserialize a serialized ABE key.
static OpusEncoder * enc
OPUS encoder.
#define GNUNET_log(kind,...)
static ssize_t read_cpabe(const void *data, char **cph_buf, int *cph_buf_len, char **aes_buf, int *aes_buf_len)
uint32_t data
The data value.
Attribute-Based Encryption primitives for GNUnet.
void GNUNET_ABE_cpabe_delete_key(struct GNUNET_ABE_AbeKey *key, int delete_pub)
Delete a CP-ABE key.
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_ABE_AbeKey * GNUNET_ABE_cpabe_create_key(struct GNUNET_ABE_AbeMasterKey *key, char **attrs)
Create a new CP-ABE key.
#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...