1 files changed, 213 insertions, 208 deletions

diff --git a/src/util/crypto_abe.c b/src/util/crypto_abe.c
index d702738de..1fe648e5a 100644
--- a/src/util/crypto_abe.c
+++ b/src/util/crypto_abe.c
@@ -32,65 +32,67 @@
 
 #include "gnunet_crypto_lib.h"
 
-struct GNUNET_CRYPTO_AbeMasterKey {
-  gabe_pub_t* pub;
-  gabe_msk_t* msk;
+struct GNUNET_CRYPTO_AbeMasterKey
+{
+  gabe_pub_t*pub;
+  gabe_msk_t*msk;
 };
 
-struct GNUNET_CRYPTO_AbeKey {
-  gabe_pub_t* pub;
-  gabe_prv_t* prv;
+struct GNUNET_CRYPTO_AbeKey
+{
+  gabe_pub_t*pub;
+  gabe_prv_t*prv;
 };
 
 static int
-init_aes(element_t k, int enc,
-         gcry_cipher_hd_t* handle,
-         struct GNUNET_CRYPTO_SymmetricSessionKey *key,
-         unsigned char* iv)
+init_aes (element_t k, int enc,
+          gcry_cipher_hd_t*handle,
+          struct GNUNET_CRYPTO_SymmetricSessionKey *key,
+          unsigned char*iv)
 {
   int rc;
   int key_len;
-  unsigned char* key_buf;
-
-  key_len = element_length_in_bytes(k) < 33 ? 3 : element_length_in_bytes(k);
-  key_buf = (unsigned char*)malloc(key_len);
-  element_to_bytes(key_buf, k);
-
-  GNUNET_memcpy(key->aes_key,
-                key_buf,
-                GNUNET_CRYPTO_AES_KEY_LENGTH);
-  GNUNET_assert(0 ==
-                gcry_cipher_open(handle, GCRY_CIPHER_AES256,
-                                 GCRY_CIPHER_MODE_CFB, 0));
-  rc = gcry_cipher_setkey(*handle,
-                          key->aes_key,
-                          sizeof(key->aes_key));
-  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
-  memset(iv, 0, 16);  //TODO make reasonable
-  rc = gcry_cipher_setiv(*handle,
-                         iv,
-                         16);
-  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
-
-  free(key_buf);
+  unsigned char*key_buf;
+
+  key_len = element_length_in_bytes (k) < 33 ? 3 : element_length_in_bytes (k);
+  key_buf = (unsigned char*) malloc (key_len);
+  element_to_bytes (key_buf, k);
+
+  GNUNET_memcpy (key->aes_key,
+                 key_buf,
+                 GNUNET_CRYPTO_AES_KEY_LENGTH);
+  GNUNET_assert (0 ==
+                 gcry_cipher_open (handle, GCRY_CIPHER_AES256,
+                                   GCRY_CIPHER_MODE_CFB, 0));
+  rc = gcry_cipher_setkey (*handle,
+                           key->aes_key,
+                           sizeof(key->aes_key));
+  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
+  memset (iv, 0, 16);  // TODO make reasonable
+  rc = gcry_cipher_setiv (*handle,
+                          iv,
+                          16);
+  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
+
+  free (key_buf);
   return rc;
 }
 
 static int
-aes_128_cbc_encrypt(char* pt,
-                    int size,
-                    element_t k,
-                    char **ct)
+aes_128_cbc_encrypt (char*pt,
+                     int size,
+                     element_t k,
+                     char **ct)
 {
   gcry_cipher_hd_t handle;
   struct GNUNET_CRYPTO_SymmetricSessionKey skey;
   unsigned char iv[16];
-  char* buf;
+  char*buf;
   int padding;
   int buf_size;
   uint8_t len[4];
 
-  init_aes(k, 1, &handle, &skey, iv);
+  init_aes (k, 1, &handle, &skey, iv);
 
   /* TODO make less crufty */
 
@@ -101,37 +103,38 @@ aes_128_cbc_encrypt(char* pt,
   len[3] = (size & 0xff) >> 0;
   padding = 16 - ((4 + size) % 16);
   buf_size = 4 + size + padding;
-  buf = GNUNET_malloc(buf_size);
-  GNUNET_memcpy(buf, len, 4);
-  GNUNET_memcpy(buf + 4, pt, size);
-  *ct = GNUNET_malloc(buf_size);
-
-  GNUNET_assert(0 == gcry_cipher_encrypt(handle, *ct, buf_size, buf, buf_size));
-  gcry_cipher_close(handle);
-  //AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT);
-  GNUNET_free(buf);
+  buf = GNUNET_malloc (buf_size);
+  GNUNET_memcpy (buf, len, 4);
+  GNUNET_memcpy (buf + 4, pt, size);
+  *ct = GNUNET_malloc (buf_size);
+
+  GNUNET_assert (0 == gcry_cipher_encrypt (handle, *ct, buf_size, buf,
+                                           buf_size));
+  gcry_cipher_close (handle);
+  // AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT);
+  GNUNET_free (buf);
   return buf_size;
 }
 
 static int
-aes_128_cbc_decrypt(char* ct,
-                    int size,
-                    element_t k,
-                    char **pt)
+aes_128_cbc_decrypt (char*ct,
+                     int size,
+                     element_t k,
+                     char **pt)
 {
   struct GNUNET_CRYPTO_SymmetricSessionKey skey;
   gcry_cipher_hd_t handle;
   unsigned char iv[16];
-  char* tmp;
+  char*tmp;
   uint32_t len;
 
-  init_aes(k, 1, &handle, &skey, iv);
+  init_aes (k, 1, &handle, &skey, iv);
 
-  tmp = GNUNET_malloc(size);
+  tmp = GNUNET_malloc (size);
 
-  //AES_cbc_encrypt(ct->data, pt->data, ct->len, &key, iv, AES_DECRYPT);
-  GNUNET_assert(0 == gcry_cipher_decrypt(handle, tmp, size, ct, size));
-  gcry_cipher_close(handle);
+  // AES_cbc_encrypt(ct->data, pt->data, ct->len, &key, iv, AES_DECRYPT);
+  GNUNET_assert (0 == gcry_cipher_decrypt (handle, tmp, size, ct, size));
+  gcry_cipher_close (handle);
   /* TODO make less crufty */
 
   /* get real length */
@@ -140,194 +143,195 @@ aes_128_cbc_decrypt(char* ct,
         | ((tmp[0]) << 24) | ((tmp[1]) << 16)
         | ((tmp[2]) << 8) | ((tmp[3]) << 0);
   /* truncate any garbage from the padding */
-  *pt = GNUNET_malloc(len);
-  GNUNET_memcpy(*pt, tmp + 4, len);
-  GNUNET_free(tmp);
+  *pt = GNUNET_malloc (len);
+  GNUNET_memcpy (*pt, tmp + 4, len);
+  GNUNET_free (tmp);
   return len;
 }
 
 struct GNUNET_CRYPTO_AbeMasterKey*
-GNUNET_CRYPTO_cpabe_create_master_key(void)
+GNUNET_CRYPTO_cpabe_create_master_key (void)
 {
-  struct GNUNET_CRYPTO_AbeMasterKey* key;
+  struct GNUNET_CRYPTO_AbeMasterKey*key;
 
-  key = GNUNET_new(struct GNUNET_CRYPTO_AbeMasterKey);
-  gabe_setup(&key->pub, &key->msk);
-  GNUNET_assert(NULL != key->pub);
-  GNUNET_assert(NULL != key->msk);
+  key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey);
+  gabe_setup (&key->pub, &key->msk);
+  GNUNET_assert (NULL != key->pub);
+  GNUNET_assert (NULL != key->msk);
   return key;
 }
 
 void
-GNUNET_CRYPTO_cpabe_delete_master_key(struct GNUNET_CRYPTO_AbeMasterKey *key)
+GNUNET_CRYPTO_cpabe_delete_master_key (struct GNUNET_CRYPTO_AbeMasterKey *key)
 {
-  gabe_msk_free(key->msk);
-  gabe_pub_free(key->pub);
-  //GNUNET_free (key->msk);
-  //gabe_msk_free (key->msk); //For some reason free of pub implicit?
-  GNUNET_free(key);
+  gabe_msk_free (key->msk);
+  gabe_pub_free (key->pub);
+  // GNUNET_free (key->msk);
+  // gabe_msk_free (key->msk); //For some reason free of pub implicit?
+  GNUNET_free (key);
 }
 
 struct GNUNET_CRYPTO_AbeKey*
-GNUNET_CRYPTO_cpabe_create_key(struct GNUNET_CRYPTO_AbeMasterKey *key,
-                               char **attrs)
+GNUNET_CRYPTO_cpabe_create_key (struct GNUNET_CRYPTO_AbeMasterKey *key,
+                                char **attrs)
 {
   struct GNUNET_CRYPTO_AbeKey *prv_key;
   int size;
   char *tmp;
 
-  prv_key = GNUNET_new(struct GNUNET_CRYPTO_AbeKey);
-  prv_key->prv = gabe_keygen(key->pub, key->msk, attrs);
-  size = gabe_pub_serialize(key->pub, &tmp);
-  prv_key->pub = gabe_pub_unserialize(tmp, size);
-  GNUNET_free(tmp);
-  GNUNET_assert(NULL != prv_key->prv);
+  prv_key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
+  prv_key->prv = gabe_keygen (key->pub, key->msk, attrs);
+  size = gabe_pub_serialize (key->pub, &tmp);
+  prv_key->pub = gabe_pub_unserialize (tmp, size);
+  GNUNET_free (tmp);
+  GNUNET_assert (NULL != prv_key->prv);
   return prv_key;
 }
 
 void
-GNUNET_CRYPTO_cpabe_delete_key(struct GNUNET_CRYPTO_AbeKey *key,
-                               int delete_pub)
+GNUNET_CRYPTO_cpabe_delete_key (struct GNUNET_CRYPTO_AbeKey *key,
+                                int delete_pub)
 {
-  //Memory management in gabe is buggy
-  gabe_prv_free(key->prv);
+  // Memory management in gabe is buggy
+  gabe_prv_free (key->prv);
   if (GNUNET_YES == delete_pub)
-    gabe_pub_free(key->pub);
-  GNUNET_free(key);
+    gabe_pub_free (key->pub);
+  GNUNET_free (key);
 }
 
 ssize_t
-write_cpabe(void **result,
-            uint32_t file_len,
-            char* cph_buf,
-            int cph_buf_len,
-            char* aes_buf,
-            int aes_buf_len)
+write_cpabe (void **result,
+             uint32_t file_len,
+             char*cph_buf,
+             int cph_buf_len,
+             char*aes_buf,
+             int aes_buf_len)
 {
   char *ptr;
   uint32_t *len;
 
-  *result = GNUNET_malloc(12 + cph_buf_len + aes_buf_len);
+  *result = GNUNET_malloc (12 + cph_buf_len + aes_buf_len);
   ptr = *result;
-  len = (uint32_t*)ptr;
-  *len = htonl(file_len);
+  len = (uint32_t*) ptr;
+  *len = htonl (file_len);
   ptr += 4;
-  len = (uint32_t*)ptr;
-  *len = htonl(aes_buf_len);
+  len = (uint32_t*) ptr;
+  *len = htonl (aes_buf_len);
   ptr += 4;
-  GNUNET_memcpy(ptr, aes_buf, aes_buf_len);
+  GNUNET_memcpy (ptr, aes_buf, aes_buf_len);
   ptr += aes_buf_len;
-  len = (uint32_t*)ptr;
-  *len = htonl(cph_buf_len);
+  len = (uint32_t*) ptr;
+  *len = htonl (cph_buf_len);
   ptr += 4;
-  GNUNET_memcpy(ptr, cph_buf, cph_buf_len);
+  GNUNET_memcpy (ptr, cph_buf, cph_buf_len);
   return 12 + cph_buf_len + aes_buf_len;
 }
 
 ssize_t
-read_cpabe(const void *data,
-           char** cph_buf,
-           int *cph_buf_len,
-           char** aes_buf,
-           int *aes_buf_len)
+read_cpabe (const void *data,
+            char**cph_buf,
+            int *cph_buf_len,
+            char**aes_buf,
+            int *aes_buf_len)
 {
   int buf_len;
   char *ptr;
   uint32_t *len;
 
-  ptr = (char*)data;
-  len = (uint32_t*)ptr;
-  buf_len = ntohl(*len);
+  ptr = (char*) data;
+  len = (uint32_t*) ptr;
+  buf_len = ntohl (*len);
   ptr += 4;
-  len = (uint32_t*)ptr;
-  *aes_buf_len = ntohl(*len);
+  len = (uint32_t*) ptr;
+  *aes_buf_len = ntohl (*len);
   ptr += 4;
-  *aes_buf = GNUNET_malloc(*aes_buf_len);
-  GNUNET_memcpy(*aes_buf, ptr, *aes_buf_len);
+  *aes_buf = GNUNET_malloc (*aes_buf_len);
+  GNUNET_memcpy (*aes_buf, ptr, *aes_buf_len);
   ptr += *aes_buf_len;
-  len = (uint32_t*)ptr;
-  *cph_buf_len = ntohl(*len);
+  len = (uint32_t*) ptr;
+  *cph_buf_len = ntohl (*len);
   ptr += 4;
-  *cph_buf = GNUNET_malloc(*cph_buf_len);
-  GNUNET_memcpy(*cph_buf, ptr, *cph_buf_len);
+  *cph_buf = GNUNET_malloc (*cph_buf_len);
+  GNUNET_memcpy (*cph_buf, ptr, *cph_buf_len);
 
   return buf_len;
 }
 
 ssize_t
-GNUNET_CRYPTO_cpabe_encrypt(const void *block,
-                            size_t size,
-                            const char *policy,
-                            const struct GNUNET_CRYPTO_AbeMasterKey *key,
-                            void **result)
+GNUNET_CRYPTO_cpabe_encrypt (const void *block,
+                             size_t size,
+                             const char *policy,
+                             const struct GNUNET_CRYPTO_AbeMasterKey *key,
+                             void **result)
 {
-  gabe_cph_t* cph;
-  char* plt;
-  char* cph_buf;
-  char* aes_buf;
+  gabe_cph_t*cph;
+  char*plt;
+  char*cph_buf;
+  char*aes_buf;
   element_t m;
   int cph_buf_len;
   int aes_buf_len;
   ssize_t result_len;
 
-  if (!(cph = gabe_enc(key->pub, m, (char*)policy)))
+  if (! (cph = gabe_enc (key->pub, m, (char*) policy)))
     return GNUNET_SYSERR;
-  cph_buf_len = gabe_cph_serialize(cph,
-                                   &cph_buf);
-  gabe_cph_free(cph);
-  GNUNET_free(cph);
-  plt = GNUNET_memdup(block, size);
-  aes_buf_len = aes_128_cbc_encrypt(plt, size, m, &aes_buf);
-  GNUNET_free(plt);
-  element_clear(m);
-  result_len = write_cpabe(result, size, cph_buf, cph_buf_len, aes_buf, aes_buf_len);
-  GNUNET_free(cph_buf);
-  GNUNET_free(aes_buf);
+  cph_buf_len = gabe_cph_serialize (cph,
+                                    &cph_buf);
+  gabe_cph_free (cph);
+  GNUNET_free (cph);
+  plt = GNUNET_memdup (block, size);
+  aes_buf_len = aes_128_cbc_encrypt (plt, size, m, &aes_buf);
+  GNUNET_free (plt);
+  element_clear (m);
+  result_len = write_cpabe (result, size, cph_buf, cph_buf_len, aes_buf,
+                            aes_buf_len);
+  GNUNET_free (cph_buf);
+  GNUNET_free (aes_buf);
   return result_len;
 }
 
 ssize_t
-GNUNET_CRYPTO_cpabe_decrypt(const void *block,
-                            size_t size,
-                            const struct GNUNET_CRYPTO_AbeKey *key,
-                            void **result)
+GNUNET_CRYPTO_cpabe_decrypt (const void *block,
+                             size_t size,
+                             const struct GNUNET_CRYPTO_AbeKey *key,
+                             void **result)
 {
-  char* aes_buf;
-  char* cph_buf;
-  gabe_cph_t* cph;
+  char*aes_buf;
+  char*cph_buf;
+  gabe_cph_t*cph;
   element_t m;
   int cph_buf_size;
   int aes_buf_size;
   int plt_len;
 
-  read_cpabe(block, &cph_buf, &cph_buf_size, &aes_buf, &aes_buf_size);
-  cph = gabe_cph_unserialize(key->pub, cph_buf, cph_buf_size);
-  if (!gabe_dec(key->pub, key->prv, cph, m))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "%s\n", gabe_error());
-      GNUNET_free(aes_buf);
-      GNUNET_free(cph_buf);
-      gabe_cph_free(cph);
-      GNUNET_free(cph);
-      element_clear(m);
-      return GNUNET_SYSERR;
-    }
-  gabe_cph_free(cph);
-  GNUNET_free(cph);
-  plt_len = aes_128_cbc_decrypt(aes_buf, aes_buf_size, m, (char**)result);
-  GNUNET_free(cph_buf);
-  GNUNET_free(aes_buf);
-  element_clear(m);
-  //freeing is buggy in gabe
-  //gabe_prv_free (prv);
-  //gabe_pub_free (pub);
+  read_cpabe (block, &cph_buf, &cph_buf_size, &aes_buf, &aes_buf_size);
+  cph = gabe_cph_unserialize (key->pub, cph_buf, cph_buf_size);
+  if (! gabe_dec (key->pub, key->prv, cph, m))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%s\n", gabe_error ());
+    GNUNET_free (aes_buf);
+    GNUNET_free (cph_buf);
+    gabe_cph_free (cph);
+    GNUNET_free (cph);
+    element_clear (m);
+    return GNUNET_SYSERR;
+  }
+  gabe_cph_free (cph);
+  GNUNET_free (cph);
+  plt_len = aes_128_cbc_decrypt (aes_buf, aes_buf_size, m, (char**) result);
+  GNUNET_free (cph_buf);
+  GNUNET_free (aes_buf);
+  element_clear (m);
+  // freeing is buggy in gabe
+  // gabe_prv_free (prv);
+  // gabe_pub_free (pub);
   return plt_len;
 }
 
 ssize_t
-GNUNET_CRYPTO_cpabe_serialize_key(const struct GNUNET_CRYPTO_AbeKey *key,
-                                  void **result)
+GNUNET_CRYPTO_cpabe_serialize_key (const struct GNUNET_CRYPTO_AbeKey *key,
+                                   void **result)
 {
   ssize_t len;
   char *pub;
@@ -335,21 +339,21 @@ GNUNET_CRYPTO_cpabe_serialize_key(const struct GNUNET_CRYPTO_AbeKey *key,
   int pub_len;
   int prv_len;
 
-  pub_len = gabe_pub_serialize(key->pub, &pub);
-  prv_len = gabe_prv_serialize(key->prv, &prv);
+  pub_len = gabe_pub_serialize (key->pub, &pub);
+  prv_len = gabe_prv_serialize (key->prv, &prv);
 
   len = pub_len + prv_len + 12;
-  write_cpabe(result, len, pub, pub_len, prv, prv_len);
+  write_cpabe (result, len, pub, pub_len, prv, prv_len);
 
-  GNUNET_free(pub);
-  GNUNET_free(prv);
+  GNUNET_free (pub);
+  GNUNET_free (prv);
 
   return len;
 }
 
 struct GNUNET_CRYPTO_AbeKey*
-GNUNET_CRYPTO_cpabe_deserialize_key(const void *data,
-                                    size_t len)
+GNUNET_CRYPTO_cpabe_deserialize_key (const void *data,
+                                     size_t len)
 {
   struct GNUNET_CRYPTO_AbeKey *key;
   char *pub;
@@ -357,23 +361,24 @@ GNUNET_CRYPTO_cpabe_deserialize_key(const void *data,
   int prv_len;
   int pub_len;
 
-  key = GNUNET_new(struct GNUNET_CRYPTO_AbeKey);
-  read_cpabe(data,
-             &pub,
-             &pub_len,
-             &prv,
-             &prv_len);
-  key->pub = gabe_pub_unserialize(pub, pub_len);
-  key->prv = gabe_prv_unserialize(key->pub, prv, prv_len);
-
-  GNUNET_free(pub);
-  GNUNET_free(prv);
+  key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey);
+  read_cpabe (data,
+              &pub,
+              &pub_len,
+              &prv,
+              &prv_len);
+  key->pub = gabe_pub_unserialize (pub, pub_len);
+  key->prv = gabe_prv_unserialize (key->pub, prv, prv_len);
+
+  GNUNET_free (pub);
+  GNUNET_free (prv);
   return key;
 }
 
 ssize_t
-GNUNET_CRYPTO_cpabe_serialize_master_key(const struct GNUNET_CRYPTO_AbeMasterKey *key,
-                                         void **result)
+GNUNET_CRYPTO_cpabe_serialize_master_key (const struct
+                                          GNUNET_CRYPTO_AbeMasterKey *key,
+                                          void **result)
 {
   ssize_t len;
   char *pub;
@@ -381,21 +386,21 @@ GNUNET_CRYPTO_cpabe_serialize_master_key(const struct GNUNET_CRYPTO_AbeMasterKey
   int pub_len;
   int msk_len;
 
-  pub_len = gabe_pub_serialize(key->pub, &pub);
-  msk_len = gabe_msk_serialize(key->msk, &msk);
+  pub_len = gabe_pub_serialize (key->pub, &pub);
+  msk_len = gabe_msk_serialize (key->msk, &msk);
 
   len = pub_len + msk_len + 12;
-  write_cpabe(result, len, pub, pub_len, msk, msk_len);
+  write_cpabe (result, len, pub, pub_len, msk, msk_len);
 
-  GNUNET_free(pub);
-  GNUNET_free(msk);
+  GNUNET_free (pub);
+  GNUNET_free (msk);
 
   return len;
 }
 
 struct GNUNET_CRYPTO_AbeMasterKey*
-GNUNET_CRYPTO_cpabe_deserialize_master_key(const void *data,
-                                           size_t len)
+GNUNET_CRYPTO_cpabe_deserialize_master_key (const void *data,
+                                            size_t len)
 {
   struct GNUNET_CRYPTO_AbeMasterKey *key;
   char *msk;
@@ -403,17 +408,17 @@ GNUNET_CRYPTO_cpabe_deserialize_master_key(const void *data,
   int msk_len;
   int pub_len;
 
-  key = GNUNET_new(struct GNUNET_CRYPTO_AbeMasterKey);
-  read_cpabe(data,
-             &pub,
-             &pub_len,
-             &msk,
-             &msk_len);
-  key->pub = gabe_pub_unserialize(pub, pub_len);
-  key->msk = gabe_msk_unserialize(key->pub, msk, msk_len);
-
-  GNUNET_free(pub);
-  GNUNET_free(msk);
+  key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey);
+  read_cpabe (data,
+              &pub,
+              &pub_len,
+              &msk,
+              &msk_len);
+  key->pub = gabe_pub_unserialize (pub, pub_len);
+  key->msk = gabe_msk_unserialize (key->pub, msk, msk_len);
+
+  GNUNET_free (pub);
+  GNUNET_free (msk);
 
   return key;
 }