src/util/crypto_abe.c

   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
  22 /**
  23  * @file util/crypto_random.c
  24  * @brief functions to gather random numbers
  25  * @author Christian Grothoff
  26  */
  27
  28
  29 #include "platform.h"
  30 #include <pbc/pbc.h>
  31 #include <gabe.h>
  32
  33 #include "gnunet_crypto_lib.h"
  34
  35 struct GNUNET_CRYPTO_AbeMasterKey {
  36   gabe_pub_t* pub;
  37   gabe_msk_t* msk;
  38 };
  39
  40 struct GNUNET_CRYPTO_AbeKey {
  41   gabe_pub_t* pub;
  42   gabe_prv_t* prv;
  43 };
  44
  45 static int
  46 init_aes(element_t k, int enc,
  47          gcry_cipher_hd_t* handle,
  48          struct GNUNET_CRYPTO_SymmetricSessionKey *key,
  49          unsigned char* iv)
  50 {
  51   int rc;
  52   int key_len;
  53   unsigned char* key_buf;
  54
  55   key_len = element_length_in_bytes(k) < 33 ? 3 : element_length_in_bytes(k);
  56   key_buf = (unsigned char*)malloc(key_len);
  57   element_to_bytes(key_buf, k);
  58
  59   GNUNET_memcpy(key->aes_key,
  60                 key_buf,
  61                 GNUNET_CRYPTO_AES_KEY_LENGTH);
  62   GNUNET_assert(0 ==
  63                 gcry_cipher_open(handle, GCRY_CIPHER_AES256,
  64                                  GCRY_CIPHER_MODE_CFB, 0));
  65   rc = gcry_cipher_setkey(*handle,
  66                           key->aes_key,
  67                           sizeof(key->aes_key));
  68   GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
  69   memset(iv, 0, 16);  //TODO make reasonable
  70   rc = gcry_cipher_setiv(*handle,
  71                          iv,
  72                          16);
  73   GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
  74
  75   free(key_buf);
  76   return rc;
  77 }
  78
  79 static int
  80 aes_128_cbc_encrypt(char* pt,
  81                     int size,
  82                     element_t k,
  83                     char **ct)
  84 {
  85   gcry_cipher_hd_t handle;
  86   struct GNUNET_CRYPTO_SymmetricSessionKey skey;
  87   unsigned char iv[16];
  88   char* buf;
  89   int padding;
  90   int buf_size;
  91   uint8_t len[4];
  92
  93   init_aes(k, 1, &handle, &skey, iv);
  94
  95   /* TODO make less crufty */
  96
  97   /* stuff in real length (big endian) before padding */
  98   len[0] = (size & 0xff000000) >> 24;
  99   len[1] = (size & 0xff0000) >> 16;
 100   len[2] = (size & 0xff00) >> 8;
 101   len[3] = (size & 0xff) >> 0;
 102   padding = 16 - ((4 + size) % 16);
 103   buf_size = 4 + size + padding;
 104   buf = GNUNET_malloc(buf_size);
 105   GNUNET_memcpy(buf, len, 4);
 106   GNUNET_memcpy(buf + 4, pt, size);
 107   *ct = GNUNET_malloc(buf_size);
 108
 109   GNUNET_assert(0 == gcry_cipher_encrypt(handle, *ct, buf_size, buf, buf_size));
 110   gcry_cipher_close(handle);
 111   //AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT);
 112   GNUNET_free(buf);
 113   return buf_size;
 114 }
 115
 116 static int
 117 aes_128_cbc_decrypt(char* ct,
 118                     int size,
 119                     element_t k,
 120                     char **pt)
 121 {
 122   struct GNUNET_CRYPTO_SymmetricSessionKey skey;
 123   gcry_cipher_hd_t handle;
 124   unsigned char iv[16];
 125   char* tmp;
 126   uint32_t len;
 127
 128   init_aes(k, 1, &handle, &skey, iv);
 129
 130   tmp = GNUNET_malloc(size);
 131
 132   //AES_cbc_encrypt(ct->data, pt->data, ct->len, &key, iv, AES_DECRYPT);
 133   GNUNET_assert(0 == gcry_cipher_decrypt(handle, tmp, size, ct, size));
 134   gcry_cipher_close(handle);
 135   /* TODO make less crufty */
 136
 137   /* get real length */
 138   len = 0;
 139   len = len
 140         | ((tmp[0]) << 24) | ((tmp[1]) << 16)
 141         | ((tmp[2]) << 8) | ((tmp[3]) << 0);
 142   /* truncate any garbage from the padding */
 143   *pt = GNUNET_malloc(len);
 144   GNUNET_memcpy(*pt, tmp + 4, len);
 145   GNUNET_free(tmp);
 146   return len;
 147 }
 148
 149 struct GNUNET_CRYPTO_AbeMasterKey*
 150 GNUNET_CRYPTO_cpabe_create_master_key(void)
 151 {
 152   struct GNUNET_CRYPTO_AbeMasterKey* key;
 153
 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
 162 GNUNET_CRYPTO_cpabe_delete_master_key(struct GNUNET_CRYPTO_AbeMasterKey *key)
 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*
 172 GNUNET_CRYPTO_cpabe_create_key(struct GNUNET_CRYPTO_AbeMasterKey *key,
 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
 189 GNUNET_CRYPTO_cpabe_delete_key(struct GNUNET_CRYPTO_AbeKey *key,
 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
 200 write_cpabe(void **result,
 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))
 306     {
 307       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 308                  "%s\n", gabe_error());
 309       GNUNET_free(aes_buf);
 310       GNUNET_free(cph_buf);
 311       gabe_cph_free(cph);
 312       GNUNET_free(cph);
 313       element_clear(m);
 314       return GNUNET_SYSERR;
 315     }
 316   gabe_cph_free(cph);
 317   GNUNET_free(cph);
 318   plt_len = aes_128_cbc_decrypt(aes_buf, aes_buf_size, m, (char**)result);
 319   GNUNET_free(cph_buf);
 320   GNUNET_free(aes_buf);
 321   element_clear(m);
 322   //freeing is buggy in gabe
 323   //gabe_prv_free (prv);
 324   //gabe_pub_free (pub);
 325   return plt_len;
 326 }
 327
 328 ssize_t
 329 GNUNET_CRYPTO_cpabe_serialize_key(const struct GNUNET_CRYPTO_AbeKey *key,
 330                                   void **result)
 331 {
 332   ssize_t len;
 333   char *pub;
 334   char *prv;
 335   int pub_len;
 336   int prv_len;
 337
 338   pub_len = gabe_pub_serialize(key->pub, &pub);
 339   prv_len = gabe_prv_serialize(key->prv, &prv);
 340
 341   len = pub_len + prv_len + 12;
 342   write_cpabe(result, len, pub, pub_len, prv, prv_len);
 343
 344   GNUNET_free(pub);
 345   GNUNET_free(prv);
 346
 347   return len;
 348 }
 349
 350 struct GNUNET_CRYPTO_AbeKey*
 351 GNUNET_CRYPTO_cpabe_deserialize_key(const void *data,
 352                                     size_t len)
 353 {
 354   struct GNUNET_CRYPTO_AbeKey *key;
 355   char *pub;
 356   char *prv;
 357   int prv_len;
 358   int pub_len;
 359
 360   key = GNUNET_new(struct GNUNET_CRYPTO_AbeKey);
 361   read_cpabe(data,
 362              &pub,
 363              &pub_len,
 364              &prv,
 365              &prv_len);
 366   key->pub = gabe_pub_unserialize(pub, pub_len);
 367   key->prv = gabe_prv_unserialize(key->pub, prv, prv_len);
 368
 369   GNUNET_free(pub);
 370   GNUNET_free(prv);
 371   return key;
 372 }
 373
 374 ssize_t
 375 GNUNET_CRYPTO_cpabe_serialize_master_key(const struct GNUNET_CRYPTO_AbeMasterKey *key,
 376                                          void **result)
 377 {
 378   ssize_t len;
 379   char *pub;
 380   char *msk;
 381   int pub_len;
 382   int msk_len;
 383
 384   pub_len = gabe_pub_serialize(key->pub, &pub);
 385   msk_len = gabe_msk_serialize(key->msk, &msk);
 386
 387   len = pub_len + msk_len + 12;
 388   write_cpabe(result, len, pub, pub_len, msk, msk_len);
 389
 390   GNUNET_free(pub);
 391   GNUNET_free(msk);
 392
 393   return len;
 394 }
 395
 396 struct GNUNET_CRYPTO_AbeMasterKey*
 397 GNUNET_CRYPTO_cpabe_deserialize_master_key(const void *data,
 398                                            size_t len)
 399 {
 400   struct GNUNET_CRYPTO_AbeMasterKey *key;
 401   char *msk;
 402   char *pub;
 403   int msk_len;
 404   int pub_len;
 405
 406   key = GNUNET_new(struct GNUNET_CRYPTO_AbeMasterKey);
 407   read_cpabe(data,
 408              &pub,
 409              &pub_len,
 410              &msk,
 411              &msk_len);
 412   key->pub = gabe_pub_unserialize(pub, pub_len);
 413   key->msk = gabe_msk_unserialize(key->pub, msk, msk_len);
 414
 415   GNUNET_free(pub);
 416   GNUNET_free(msk);
 417
 418   return key;
 419 }