Fixed memory leaks in kty. Fixed test memory leaks in gl19

src/groupsig/kty04/crl.c

@@ -563,7 +563,7 @@ int kty04_crl_trapdoor_exists(crl_t *crl, trapdoor_t *trap) {
     return IERROR;
   }
 
-  if(bigz_set(entry->trapdoor, *(kty04_trapdoor_t *) trap->trap) == IERROR) {
+  if(bigz_set(entry->trapdoor, (kty04_trapdoor_t *)trap->trap) == IERROR) {
     return IERROR;
   }
 

src/groupsig/kty04/gml.c

@@ -320,7 +320,8 @@ int kty04_gml_entry_get_size(gml_entry_t *entry) {
   size = strlen(bytes);
 
   if (size >= INT_MAX) return -1;
-
+
+  mem_free(bytes);
   return (int) size;
 
 }
@@ -373,10 +374,13 @@ gml_entry_t* kty04_gml_entry_import(byte_t *bytes, uint32_t size) {
   sA = strtok(NULL, "\t");
   strapdoor = strtok(NULL, "\t");
 
+  identity_free(data->id); // from_string allocates memory
   data->id = identity_from_string(GROUPSIG_KTY04_CODE, sid);
   if ((bigz_set_str10(data->A, sA)) == IERROR) return NULL;
+  trapdoor_free(data->trapdoor); // from_string allocates memory
   data->trapdoor = trapdoor_from_string(GROUPSIG_KTY04_CODE, strapdoor);
 
+  mem_free(input);
   return entry;
 
 }
@@ -467,7 +471,7 @@ int kty04_gml_entry_cmp_trapdoors(gml_entry_t *entry1,
   d1 = (kty04_gml_entry_data_t *) entry1->data;
   d2 = (kty04_gml_entry_data_t *) entry2->data;
 
-  return bigz_cmp(*(kty04_trapdoor_t *) d1->trapdoor->trap,
-                  *(kty04_trapdoor_t *) d2->trapdoor->trap);
+  return bigz_cmp((kty04_trapdoor_t *)(d1->trapdoor)->trap,
+                  (kty04_trapdoor_t *)(d2->trapdoor)->trap);
 
 }

src/groupsig/kty04/grp_key.c

@@ -56,22 +56,22 @@ static int _grp_key_free_spheres(kty04_grp_key_t *key) {
     rc += sphere_free(key->lambda);
   }
 
-  if(key->M) {
-    rc += sphere_free(key->M);
-  }
-
-  if(key->gamma) {
-    rc += sphere_free(key->gamma);
-  }
-
   if(key->inner_lambda) {
     rc += sphere_free(key->inner_lambda);
   }
 
+  if(key->M) {
+    rc += sphere_free(key->M);
+  }
+
   if(key->inner_M) {
     rc += sphere_free(key->inner_M);
   }
 
+  if(key->gamma) {
+    rc += sphere_free(key->gamma);
+  }
+
   if(key->inner_gamma) {
     rc += sphere_free(key->inner_gamma);
   }
@@ -116,10 +116,10 @@ groupsig_key_t* kty04_grp_key_init() {
   if(!(kty04_key->h = bigz_init())) goto init_err;
   if(!(kty04_key->y = bigz_init())) goto init_err;
   kty04_key->lambda = NULL;
-  kty04_key->M = NULL;
-  kty04_key->gamma = NULL;
   kty04_key->inner_lambda = NULL;
+  kty04_key->M = NULL;
   kty04_key->inner_M = NULL;
+  kty04_key->gamma = NULL;
   kty04_key->inner_gamma = NULL;
 
   key->scheme = GROUPSIG_KTY04_CODE;
@@ -754,36 +754,43 @@ groupsig_key_t* kty04_grp_key_import(byte_t *source, uint32_t size) {
 
   /* Get n */
   len = source[ctr++];
+  bigz_free(kty04_key->n); // We need to manually free each bigz already allocated
   kty04_key->n = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get a */
   len = source[ctr++];
+  bigz_free(kty04_key->a);
   kty04_key->a = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get a0 */
   len = source[ctr++];
+  bigz_free(kty04_key->a0);
   kty04_key->a0 = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get b */
   len = source[ctr++];
+  bigz_free(kty04_key->b);
   kty04_key->b = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get g */
   len = source[ctr++];
+  bigz_free(kty04_key->g);
   kty04_key->g = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get h */
   len = source[ctr++];
+  bigz_free(kty04_key->h);
   kty04_key->h = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get y */
   len = source[ctr++];
+  bigz_free(kty04_key->y);
   kty04_key->y = bigz_import(&source[ctr], len);
   ctr += len;
 
@@ -813,11 +820,14 @@ groupsig_key_t* kty04_grp_key_import(byte_t *source, uint32_t size) {
 
   /* Get lambda center */
   len = source[ctr++];
+  // We need to free it because bigz_import allocates memory
+  bigz_free(kty04_key->lambda->center);
   kty04_key->lambda->center = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get lambda radius */
   len = source[ctr++];
+  bigz_free(kty04_key->lambda->radius);
   kty04_key->lambda->radius = bigz_import(&source[ctr], len);
   ctr += len;
 
@@ -826,11 +836,13 @@ groupsig_key_t* kty04_grp_key_import(byte_t *source, uint32_t size) {
 
   /* Get inner lambda center */
   len = source[ctr++];
+  bigz_free(kty04_key->inner_lambda->center);
   kty04_key->inner_lambda->center = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get inner lambda radius */
   len = source[ctr++];
+  bigz_free(kty04_key->inner_lambda->radius);
   kty04_key->inner_lambda->radius = bigz_import(&source[ctr], len);
   ctr += len;
 
@@ -839,11 +851,13 @@ groupsig_key_t* kty04_grp_key_import(byte_t *source, uint32_t size) {
 
   /* Get M center */
   len = source[ctr++];
+  bigz_free(kty04_key->M->center);
   kty04_key->M->center = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get M radius */
   len = source[ctr++];
+  bigz_free(kty04_key->M->radius);
   kty04_key->M->radius = bigz_import(&source[ctr], len);
   ctr += len;
 
@@ -852,11 +866,13 @@ groupsig_key_t* kty04_grp_key_import(byte_t *source, uint32_t size) {
 
   /* Get inner M center */
   len = source[ctr++];
+  bigz_free(kty04_key->inner_M->center);
   kty04_key->inner_M->center = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get inner M radius */
   len = source[ctr++];
+  bigz_free(kty04_key->inner_M->radius);
   kty04_key->inner_M->radius = bigz_import(&source[ctr], len);
   ctr += len;
 
@@ -865,11 +881,13 @@ groupsig_key_t* kty04_grp_key_import(byte_t *source, uint32_t size) {
 
   /* Get gamma center */
   len = source[ctr++];
+  bigz_free(kty04_key->gamma->center);
   kty04_key->gamma->center = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get gamma radius */
   len = source[ctr++];
+  bigz_free(kty04_key->gamma->radius);
   kty04_key->gamma->radius = bigz_import(&source[ctr], len);
   ctr += len;
 
@@ -878,11 +896,13 @@ groupsig_key_t* kty04_grp_key_import(byte_t *source, uint32_t size) {
 
   /* Get inner gamma center */
   len = source[ctr++];
+  bigz_free(kty04_key->inner_gamma->center);
   kty04_key->inner_gamma->center = bigz_import(&source[ctr], len);
   ctr += len;
 
-  /* Get gamma radius */
+  /* Get inner gamma radius */
   len = source[ctr++];
+  bigz_free(kty04_key->inner_gamma->radius);
   kty04_key->inner_gamma->radius = bigz_import(&source[ctr], len);
   ctr += len;
 

src/groupsig/kty04/join_mgr.c

@@ -142,7 +142,7 @@ int kty04_join_mgr(message_t **mout, gml_t *gml,
 
     kty04_gml_entry_data_t *data = entry->data;
 
-    if(bigz_set(*(kty04_trapdoor_t *) data->trapdoor->trap, mkey->x) == IERROR) GOTOENDRC(IERROR, kty04_join_mgr);
+    if(bigz_set((kty04_trapdoor_t *)(data->trapdoor)->trap, mkey->x) == IERROR) GOTOENDRC(IERROR, kty04_join_mgr);
 
     if(bigz_set(data->A, mkey->A) == IERROR) GOTOENDRC(IERROR, kty04_join_mgr);
 

src/groupsig/kty04/mgr_key.c

@@ -351,16 +351,19 @@ groupsig_key_t* kty04_mgr_key_import(byte_t *source, uint32_t size) {
 
   /* Get p */
   len = source[ctr++];
+  bigz_free(kty04_key->p);
   kty04_key->p = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get q */
   len = source[ctr++];
+  bigz_free(kty04_key->q);
   kty04_key->q = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get x */
   len = source[ctr++];
+  bigz_free(kty04_key->x);
   kty04_key->x = bigz_import(&source[ctr], len);
   ctr += len;
 

src/groupsig/kty04/reveal.c

@@ -42,15 +42,17 @@ int kty04_reveal(trapdoor_t *trap, crl_t *crl, gml_t *gml, uint64_t index) {
     return IERROR;
   }
 
-  trapdoor = *(bigz_t *) trap->trap;
+  trapdoor = (bigz_t) trap->trap;
 
   /* The tracing trapdoor for the i-th member is the x field of its member key */
-  if(!(gml_entry = ((gml_entry_t *) gml_get(gml, index)))) {
+  if(!(gml_entry = (gml_entry_t *)gml_get(gml, index))) {
     LOG_EINVAL(&logger, __FILE__, "kty04_reveal", __LINE__, LOGERROR);
     return IERROR;
   }
 
-  if(bigz_set(trapdoor, *(kty04_trapdoor_t *)((kty04_gml_entry_data_t *)gml_entry->data)->trapdoor->trap) == IERROR) {
+  kty04_gml_entry_data_t *gml_data = (kty04_gml_entry_data_t *)gml_entry->data;
+
+  if(bigz_set(trapdoor, (kty04_trapdoor_t)(gml_data->trapdoor)->trap) == IERROR) {
     LOG_EINVAL(&logger, __FILE__, "kty04_reveal", __LINE__, LOGERROR);
     return IERROR;
   }
@@ -65,7 +67,7 @@ int kty04_reveal(trapdoor_t *trap, crl_t *crl, gml_t *gml, uint64_t index) {
 
     bigz_set(crl_entry->trapdoor, trapdoor);
 
-    if(kty04_identity_copy(crl_entry->id, ((kty04_gml_entry_data_t *)gml_entry->data)->id) == IERROR) {
+    if(kty04_identity_copy(crl_entry->id, gml_data->id) == IERROR) {
       LOG_EINVAL(&logger, __FILE__, "kty04_reveal", __LINE__, LOGERROR);
       kty04_crl_entry_free(crl_entry);
       return IERROR;

src/groupsig/kty04/signature.c

@@ -500,19 +500,22 @@ groupsig_signature_t* kty04_signature_import(byte_t *source, uint32_t size) {
 
   /* Get c */
   len = source[ctr++];
+  bigz_free(kty04_signature->c); // avoid memory leak due to bigz_import re allocation
   kty04_signature->c = bigz_import(&source[ctr], len);
   ctr += len;
 
   /* Get A */
   for(i = 0; i < kty04_signature->m; i++) {
     len = source[ctr++];
+    bigz_free(kty04_signature->A[i]);
     kty04_signature->A[i] = bigz_import(&source[ctr], len);
     ctr += len;
   }
 
   /* Get sw */
   for(i = 0; i < kty04_signature->r; i++) {
     len = source[ctr++];
+    bigz_free(kty04_signature->sw[i]);
     kty04_signature->sw[i] = bigz_import(&source[ctr], len);
     ctr += len;
   }

src/groupsig/kty04/trapdoor.c

@@ -27,25 +27,22 @@
 trapdoor_t* kty04_trapdoor_init() {
 
   trapdoor_t *trap;
-  kty04_trapdoor_t *kty04_trap;
 
   if(!(trap = (trapdoor_t *) mem_malloc(sizeof(trapdoor_t)))) {
     LOG_ERRORCODE(&logger, __FILE__, "kty04_trapdoor_init", __LINE__, errno, LOGERROR);
     return NULL;
   }
 
-  if(!(kty04_trap = (kty04_trapdoor_t *) mem_malloc(sizeof(kty04_trapdoor_t)))) {
-    mem_free(trap); trap = NULL;
-    LOG_ERRORCODE(&logger, __FILE__, "kty04_trapdoor_init", __LINE__, errno, LOGERROR);
-    return NULL;
-  }
+  /* if(!(kty04_trap = (kty04_trapdoor_t *) mem_malloc(sizeof(kty04_trapdoor_t)))) { */
+  /*   mem_free(trap); trap = NULL; */
+  /*   LOG_ERRORCODE(&logger, __FILE__, "kty04_trapdoor_init", __LINE__, errno, LOGERROR); */
+  /*   return NULL; */
+  /* } */
 
   /* A KTY04 identity is the index pointing to an entry in the GML, we initialize
      it to UINT64_MAX */
-  *kty04_trap = bigz_init();
-
   trap->scheme = GROUPSIG_KTY04_CODE;
-  trap->trap = kty04_trap;
+  trap->trap = bigz_init();
 
   return trap;
 
@@ -65,8 +62,7 @@ int kty04_trapdoor_free(trapdoor_t *trap) {
   }
 
   /* Currently, it is just an uint64_t* */
-  bigz_free(*((kty04_trapdoor_t *) trap->trap));
-  mem_free((kty04_trapdoor_t *) trap->trap); trap->trap = NULL;
+  bigz_free(trap->trap);
   mem_free(trap);
 
   return IOK;
@@ -81,7 +77,7 @@ int kty04_trapdoor_copy(trapdoor_t *dst, trapdoor_t *src) {
     return IERROR;
   }
 
-  bigz_set(*((kty04_trapdoor_t *) dst->trap), *((kty04_trapdoor_t *) src->trap));
+  bigz_set(((kty04_trapdoor_t *)dst->trap), ((kty04_trapdoor_t *)src->trap));
 
   return IOK;
 
@@ -95,7 +91,7 @@ char* kty04_trapdoor_to_string(trapdoor_t *trap) {
   }
 
   /* Currently, the KTY04 trapdoors are bigz_t's */
-  return bigz_get_str10(*((kty04_trapdoor_t *)trap->trap));
+  return bigz_get_str10((kty04_trapdoor_t *)trap->trap);
 
 }
 
@@ -113,7 +109,7 @@ trapdoor_t* kty04_trapdoor_from_string(char *strap) {
   }
 
   /* Currently, KTY04 identities are bigz_t's */
-  if(bigz_set_str10(*(kty04_trapdoor_t *) trap->trap, strap) == IERROR) {
+  if(bigz_set_str10((kty04_trapdoor_t *)trap->trap, strap) == IERROR) {
     kty04_trapdoor_free(trap);
     return NULL;
   }

src/groupsig/kty04/verify.c

@@ -512,6 +512,7 @@ int kty04_verify(uint8_t *ok, groupsig_signature_t *sig, message_t *msg, groupsi
     if(errno) GOTOENDRC(IERROR, kty04_verify);
     fail = 1;
     *ok = !fail;
+    if (mdctx) EVP_MD_CTX_free(mdctx);
     bigz_free(c);
     return IOK;
   } else {