diff --git a/src/groupsig/kty04/crl.c b/src/groupsig/kty04/crl.c
index 027aa7e..88d8925 100644
--- a/src/groupsig/kty04/crl.c
+++ b/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;
   }
 
diff --git a/src/groupsig/kty04/gml.c b/src/groupsig/kty04/gml.c
index 1a649b6..d75aa7d 100644
--- a/src/groupsig/kty04/gml.c
+++ b/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);
 
 }
diff --git a/src/groupsig/kty04/grp_key.c b/src/groupsig/kty04/grp_key.c
index 1482b89..d69ff32 100644
--- a/src/groupsig/kty04/grp_key.c
+++ b/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;
 
diff --git a/src/groupsig/kty04/join_mgr.c b/src/groupsig/kty04/join_mgr.c
index 98d398e..f9f7351 100644
--- a/src/groupsig/kty04/join_mgr.c
+++ b/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);
 
diff --git a/src/groupsig/kty04/mgr_key.c b/src/groupsig/kty04/mgr_key.c
index 1a1dbe4..bb26cdd 100644
--- a/src/groupsig/kty04/mgr_key.c
+++ b/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;
 
diff --git a/src/groupsig/kty04/reveal.c b/src/groupsig/kty04/reveal.c
index 4229840..3be1e8a 100644
--- a/src/groupsig/kty04/reveal.c
+++ b/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;
diff --git a/src/groupsig/kty04/signature.c b/src/groupsig/kty04/signature.c
index a4050f7..d157f1e 100644
--- a/src/groupsig/kty04/signature.c
+++ b/src/groupsig/kty04/signature.c
@@ -500,12 +500,14 @@ 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;
   }
@@ -513,6 +515,7 @@ groupsig_signature_t* kty04_signature_import(byte_t *source, uint32_t size) {
   /* 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;
   }
diff --git a/src/groupsig/kty04/trapdoor.c b/src/groupsig/kty04/trapdoor.c
index e94b813..3edd9c8 100644
--- a/src/groupsig/kty04/trapdoor.c
+++ b/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;
   }
diff --git a/src/groupsig/kty04/verify.c b/src/groupsig/kty04/verify.c
index c5e0f65..b18c1e2 100644
--- a/src/groupsig/kty04/verify.c
+++ b/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 {
diff --git a/src/math/nt.c b/src/math/nt.c
index 1889335..f22f09e 100644
--- a/src/math/nt.c
+++ b/src/math/nt.c
@@ -1693,20 +1693,10 @@ int nt_get_safe_prime(uint64_t k, bigz_t p/* , bigz_t *a */) {
     return IERROR;
   }
 
-  do {
-    if (!BN_generate_prime_ex(candidate, k, 1, NULL, NULL, NULL)) { // hardcoded 1 to generate safe prime
-      bigz_free(candidate);
-      return IERROR;
-    }
-    printf_bn("candidate: ", candidate);
-    /* printf("candidate bits: %d\n", BN_num_bytes(candidate) * 8); */
-    /* printf("is prime? %d\n", BN_is_prime_ex(candidate, 10, NULL, NULL)); */
-  } while(!bigz_probab_prime_p(candidate, PRIMALITY_TEST_SEC));  // redundant? the openssl safe prime is already checked
-
-  /* if (!BN_generate_prime_ex(candidate, k, 1, NULL, NULL, NULL)) { */
-  /*   bigz_free(candidate); */
-  /*   return IERROR; */
-  /* } */
+  if (!BN_generate_prime_ex(candidate, k, 1, NULL, NULL, NULL)) {
+    bigz_free(candidate);
+    return IERROR;
+  }
 
   /* if(!(q = bigz_init())) { */
   /*   bigz_free(candidate); */
diff --git a/src/shim/bigz.c b/src/shim/bigz.c
index f606165..2a5e2b9 100644
--- a/src/shim/bigz.c
+++ b/src/shim/bigz.c
@@ -582,11 +582,13 @@ int bigz_probab_prime_p(bigz_t n, int reps) {
 void print_bn(bigz_t num) {
   char *ptr = BN_bn2dec(num);
   printf("BN: %s\n", ptr);
+  free(ptr);
 }
 
 void printf_bn(char *text, bigz_t num) {
   char *ptr = BN_bn2dec(num);
   printf("%s%s\n", text, ptr);
+  free(ptr);
 }
 
 int bigz_nextprime(bigz_t rop, bigz_t lower) {
diff --git a/src/test/basic/benchmark.c b/src/test/basic/benchmark.c
index d223954..0c3e31c 100644
--- a/src/test/basic/benchmark.c
+++ b/src/test/basic/benchmark.c
@@ -90,6 +90,7 @@ void analyze_registration(groupsig_t *gsig, groupsig_key_t *gkey,
     groupsig_join_mem(&msg2, _mkey, 0, msg, gkey);
     END_T;
     save_phase('m', phase, start_t, end_t, idx);
+    groupsig_mem_key_free(_mkey);  // the key is already exported in msg2
 
     START_T;
     groupsig_join_mgr(&msg, gml, mgkey, 1, msg2, gkey);
diff --git a/src/test/basic/test.c b/src/test/basic/test.c
index d03fb86..5cfc3df 100644
--- a/src/test/basic/test.c
+++ b/src/test/basic/test.c
@@ -104,12 +104,12 @@ void test_init(char *prefix, char *scheme, groupsig_t **gsig, groupsig_key_t **g
   }
 
   groupsig_grp_key_free(_gkey);
-  mem_free(_gkey_b);
+  free(_gkey_b);
   groupsig_mgr_key_free(_mgkey1);
-  mem_free(_mgkey1_b);
+  free(_mgkey1_b);
   if (multi) {
     groupsig_mgr_key_free(_mgkey2);
-    mem_free(_mgkey2_b);
+    free(_mgkey2_b);
   }
 }
 
@@ -132,6 +132,7 @@ void test_registration(char *_prefix, int _prefix_idx, groupsig_t *gsig, groupsi
   if (start == 1 && seq == 1) { // kty04
     rc = groupsig_join_mem(&msg2, _mkey, 0, msg1, gkey);
     check_rc(prefix, "join_mem", rc);
+    groupsig_mem_key_free(_mkey);  // the key is already exported in msg2
 
     rc = groupsig_join_mgr(&msg1, gml, mgkey, 1, msg2, gkey);
     check_rc(prefix, "join_mgr", rc);
@@ -174,23 +175,21 @@ void test_registration(char *_prefix, int _prefix_idx, groupsig_t *gsig, groupsi
   if (msg2)
     message_free(msg2);
   groupsig_mem_key_free(_mkey);
-  mem_free(_mkey_b);
+  free(_mkey_b);
 }
 
-void test_gml(char *_prefix, int _prefix_idx, groupsig_key_t *gkey, gml_t **gml) {
+void test_gml(char *prefix, groupsig_key_t *gkey, gml_t **gml) {
   gml_t *_gml = *gml;
   byte_t *_gml_b = NULL;
   uint32_t _gml_sz;
-  char prefix[20];
-  snprintf(prefix, 20, "%s%d", _prefix, _prefix_idx);
 
   int rc = gml_export(&_gml_b, &_gml_sz, _gml);
   check_rc(prefix, "gml_export", rc);
+  gml_free(_gml);
 
   *gml = gml_import(gkey->scheme, _gml_b, _gml_sz);
   check_ptr(prefix, "gml_import", *gml);
-  gml_free(_gml);
-  mem_free(_gml_b);
+  free(_gml_b);
 }
 
 
@@ -237,7 +236,7 @@ void test_signing(char *scheme, char *prefix, groupsig_key_t *gkey, groupsig_key
   message_free(msg1);
   message_free(msg2);
   groupsig_signature_free(_sig1);
-  mem_free(_sig_b);
+  free(_sig_b);
   groupsig_signature_free(sig1);
 }
 
@@ -511,15 +510,19 @@ void test_group4(char *prefix, groupsig_key_t *gkey, groupsig_key_t *mgkey,
   identity_t *nym2 = identity_init(gkey->scheme);
   check_ptr(prefix, "identity_init2", nym2);
 
-  rc = groupsig_unblind(nym1, sig1, csigs[0], gkey, bkey, msg1);
+  message_t *msg3 = message_init();
+  rc = groupsig_unblind(nym1, sig1, csigs[0], gkey, bkey, msg3);
   check_rc(prefix, "unblind1", rc);
-  rc = groupsig_unblind(nym2, sig2, csigs[1], gkey, bkey, msg2);
+  message_t *msg4 = message_init();
+  rc = groupsig_unblind(nym2, sig2, csigs[1], gkey, bkey, msg4);
   check_rc(prefix, "unblind2", rc);
 
   uint8_t ret = identity_cmp(nym1, nym2);
   check_ret(prefix, "identity_cmp1", ret, 0);
 
   // Test2: two signatures, one from another user: error
+  message_free(msg3);
+  message_free(msg4);
   groupsig_blindsig_free(csigs[0]);
   groupsig_blindsig_free(csigs[1]);
   identity_free(nym1);
@@ -540,9 +543,11 @@ void test_group4(char *prefix, groupsig_key_t *gkey, groupsig_key_t *mgkey,
   nym2 = identity_init(gkey->scheme);
   check_ptr(prefix, "identity_init4", nym2);
 
-  rc = groupsig_unblind(nym1, sig1, csigs[0], gkey, bkey, msg1);
+  msg3 = message_init();
+  rc = groupsig_unblind(nym1, sig1, csigs[0], gkey, bkey, msg3);
   check_rc(prefix, "unblind3", rc);
-  rc = groupsig_unblind(nym2, sig3, csigs[1], gkey, bkey, msg1);
+  msg4 = message_init();
+  rc = groupsig_unblind(nym2, sig3, csigs[1], gkey, bkey, msg4);
   check_rc(prefix, "unblind4", rc);
 
   ret = 255;
@@ -550,6 +555,8 @@ void test_group4(char *prefix, groupsig_key_t *gkey, groupsig_key_t *mgkey,
   check_ret(prefix, "identity_cmp2", ret, 1);
 
   // Test3: non transitivity of conversion
+  message_free(msg3);
+  message_free(msg4);
   groupsig_blindsig_free(csigs[0]);
   groupsig_blindsig_free(csigs[1]);
   identity_free(nym1);
@@ -572,9 +579,11 @@ void test_group4(char *prefix, groupsig_key_t *gkey, groupsig_key_t *mgkey,
   nym2 = identity_init(gkey->scheme);
   check_ptr(prefix, "identity_init6", nym2);
 
-  rc = groupsig_unblind(nym1, sig1, csigs[0], gkey, bkey, msg1);
+  msg3 = message_init();
+  rc = groupsig_unblind(nym1, sig1, csigs[0], gkey, bkey, msg3);
   check_rc(prefix, "unblind5", rc);
-  rc = groupsig_unblind(nym2, sig3, csigs[1], gkey, bkey, msg1);
+  msg4 = message_init();
+  rc = groupsig_unblind(nym2, sig3, csigs[1], gkey, bkey, msg4);
   check_rc(prefix, "unblind6", rc);
 
   ret = 255;
@@ -583,6 +592,8 @@ void test_group4(char *prefix, groupsig_key_t *gkey, groupsig_key_t *mgkey,
 
   message_free(msg1);
   message_free(msg2);
+  message_free(msg3);
+  message_free(msg4);
   groupsig_signature_free(sig1);
   groupsig_signature_free(sig2);
   groupsig_signature_free(sig3);
@@ -875,14 +886,14 @@ void test_libgroupsig(char *scheme) {
   } while (n2 == n1);
   do {
     n3 = rand() % MEMBERS;
-  } while (n3 == n2);
+  } while (n3 == n2 || n3 == n1);
 
   printf("# Testing registration...\n");
   for (int i = 0; i < MEMBERS; i++) {
     test_registration("registration", i, gsig, gkey, mgkey1, gml, &mkeys[i]);
-    if (gsig->desc->has_gml) {
-      test_gml("registration", i, gkey, &gml);
-    }
+  }
+  if (gsig->desc->has_gml) {
+    test_gml("registration", gkey, &gml);
   }
 
   printf("\n# Testing sign, verify...\n");