Corrected several memory leaks reported by Sam. In some cases switched

to C99 to avoid having complex code.

diff --git a/lib/auth_cert.c b/lib/auth_cert.c
index 37e2d53ab75a8941b4462d14131ce45d8bd86266..b964c459dfb18a3803d713011614484e50a60929 100644 (file)
--- a/lib/auth_cert.c
+++ b/lib/auth_cert.c
@@ -71,6 +71,11 @@ _gnutls_copy_certificate_auth_info (cert_auth_info_t info,
    */
   int ret, i, j;
 
+  if (info->raw_certificate_list != NULL)
+    {
+      gnutls_free( info->raw_certificate_list);
+    }
+
   if (ncerts == 0)
     {
       info->raw_certificate_list = NULL;

diff --git a/lib/gnutls_constate.c b/lib/gnutls_constate.c
index 12e17198808831e5cd11599432a1679462840780..946e59ad8a756faa86ad1c9fb7917d406e8a46bf 100644 (file)
--- a/lib/gnutls_constate.c
+++ b/lib/gnutls_constate.c
@@ -58,10 +58,6 @@ static int
 _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
                  int key_size, int export_flag)
 {
-
-/* FIXME: This function is too long
- */
-  opaque *key_block;
   opaque rnd[2 * GNUTLS_RANDOM_SIZE];
   opaque rrnd[2 * GNUTLS_RANDOM_SIZE];
   int pos, ret;
@@ -81,12 +77,8 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
   if (export_flag == 0)
     block_size += 2 * IV_size;
 
-  key_block = gnutls_secure_malloc (block_size);
-  if (key_block == NULL)
-    {
-      gnutls_assert ();
-      return GNUTLS_E_MEMORY_ERROR;
-    }
+  /* avoid using malloc */
+  opaque key_block[block_size];
 
   memcpy (rnd, session->security_parameters.server_random,
          GNUTLS_RANDOM_SIZE);
@@ -116,7 +108,6 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
   if (ret < 0)
     {
       gnutls_assert ();
-      gnutls_free (key_block);
       return ret;
     }
 
@@ -127,11 +118,18 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
   pos = 0;
   if (hash_size > 0)
     {
+    
+      if (session->cipher_specs.client_write_mac_secret.data != NULL)
+        _gnutls_free_datum(&session->cipher_specs.client_write_mac_secret);
+
+      if (session->cipher_specs.server_write_mac_secret.data != NULL)
+        _gnutls_free_datum(&session->cipher_specs.server_write_mac_secret);
+
       if (_gnutls_sset_datum
          (&session->cipher_specs.client_write_mac_secret,
           &key_block[pos], hash_size) < 0)
        {
-         gnutls_free (key_block);
+         gnutls_assert();
          return GNUTLS_E_MEMORY_ERROR;
        }
       pos += hash_size;
@@ -140,7 +138,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
          (&session->cipher_specs.server_write_mac_secret,
           &key_block[pos], hash_size) < 0)
        {
-         gnutls_free (key_block);
+         gnutls_assert();
          return GNUTLS_E_MEMORY_ERROR;
        }
       pos += hash_size;
@@ -148,9 +146,10 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
 
   if (key_size > 0)
     {
+      opaque key1[EXPORT_FINAL_KEY_SIZE];
+      opaque key2[EXPORT_FINAL_KEY_SIZE];
       opaque *client_write_key, *server_write_key;
       int client_write_key_size, server_write_key_size;
-      int free_keys = 0;
 
       if (export_flag == 0)
        {
@@ -167,24 +166,8 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
        }
       else
        {                       /* export */
-         free_keys = 1;
-
-         client_write_key = gnutls_secure_malloc (EXPORT_FINAL_KEY_SIZE);
-         if (client_write_key == NULL)
-           {
-             gnutls_assert ();
-             gnutls_free (key_block);
-             return GNUTLS_E_MEMORY_ERROR;
-           }
-
-         server_write_key = gnutls_secure_malloc (EXPORT_FINAL_KEY_SIZE);
-         if (server_write_key == NULL)
-           {
-             gnutls_assert ();
-             gnutls_free (key_block);
-             gnutls_free (client_write_key);
-             return GNUTLS_E_MEMORY_ERROR;
-           }
+         client_write_key = key1;
+         server_write_key = key2;
 
          /* generate the final keys */
 
@@ -211,9 +194,6 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
          if (ret < 0)
            {
              gnutls_assert ();
-             gnutls_free (key_block);
-             gnutls_free (server_write_key);
-             gnutls_free (client_write_key);
              return ret;
            }
 
@@ -240,9 +220,6 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
          if (ret < 0)
            {
              gnutls_assert ();
-             gnutls_free (key_block);
-             gnutls_free (server_write_key);
-             gnutls_free (client_write_key);
              return ret;
            }
 
@@ -250,13 +227,14 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
          pos += key_size;
        }
 
+      if (session->cipher_specs.client_write_key.data != NULL)
+        _gnutls_free_datum(&session->cipher_specs.client_write_key);
+
       if (_gnutls_sset_datum
          (&session->cipher_specs.client_write_key,
           client_write_key, client_write_key_size) < 0)
        {
-         gnutls_free (key_block);
-         gnutls_free (server_write_key);
-         gnutls_free (client_write_key);
+         gnutls_assert();
          return GNUTLS_E_MEMORY_ERROR;
        }
       _gnutls_hard_log ("INT: CLIENT WRITE KEY [%d]: %s\n",
@@ -265,13 +243,14 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
                                         client_write_key_size, buf,
                                         sizeof (buf)));
 
+      if (session->cipher_specs.server_write_key.data != NULL)
+        _gnutls_free_datum(&session->cipher_specs.server_write_key);
+
       if (_gnutls_sset_datum
          (&session->cipher_specs.server_write_key,
           server_write_key, server_write_key_size) < 0)
        {
-         gnutls_free (key_block);
-         gnutls_free (server_write_key);
-         gnutls_free (client_write_key);
+         gnutls_assert();
          return GNUTLS_E_MEMORY_ERROR;
        }
 
@@ -281,11 +260,6 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
                                         server_write_key_size, buf,
                                         sizeof (buf)));
 
-      if (free_keys != 0)
-       {
-         gnutls_free (server_write_key);
-         gnutls_free (client_write_key);
-       }
     }
 
 
@@ -293,20 +267,26 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
    */
   if (IV_size > 0 && export_flag == 0)
     {
+      if (session->cipher_specs.client_write_IV.data != NULL)
+        _gnutls_free_datum(&session->cipher_specs.client_write_IV);
+
       if (_gnutls_sset_datum
          (&session->cipher_specs.client_write_IV, &key_block[pos],
           IV_size) < 0)
        {
-         gnutls_free (key_block);
+         gnutls_assert();
          return GNUTLS_E_MEMORY_ERROR;
        }
       pos += IV_size;
 
+      if (session->cipher_specs.server_write_IV.data != NULL)
+        _gnutls_free_datum(&session->cipher_specs.server_write_IV);
+
       if (_gnutls_sset_datum
          (&session->cipher_specs.server_write_IV, &key_block[pos],
           IV_size) < 0)
        {
-         gnutls_free (key_block);
+         gnutls_assert();
          return GNUTLS_E_MEMORY_ERROR;
        }
       pos += IV_size;
@@ -314,13 +294,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
     }
   else if (IV_size > 0 && export_flag != 0)
     {
-      opaque *iv_block = gnutls_malloc (IV_size * 2);
-      if (iv_block == NULL)
-       {
-         gnutls_assert ();
-         gnutls_free (key_block);
-         return GNUTLS_E_MEMORY_ERROR;
-       }
+      opaque iv_block[IV_size * 2];
 
       if (session->security_parameters.version == GNUTLS_SSL3)
        {                       /* SSL 3 */
@@ -331,8 +305,6 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
          if (ret < 0)
            {
              gnutls_assert ();
-             gnutls_free (key_block);
-             gnutls_free (iv_block);
              return ret;
            }
 
@@ -351,33 +323,31 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
       if (ret < 0)
        {
          gnutls_assert ();
-         gnutls_free (iv_block);
-         gnutls_free (key_block);
          return ret;
        }
 
+      if (session->cipher_specs.client_write_IV.data != NULL)
+        _gnutls_free_datum(&session->cipher_specs.client_write_IV);
+
       if (_gnutls_sset_datum
          (&session->cipher_specs.client_write_IV, iv_block, IV_size) < 0)
        {
-         gnutls_free (iv_block);
-         gnutls_free (key_block);
+         gnutls_assert();
          return GNUTLS_E_MEMORY_ERROR;
        }
 
+      if (session->cipher_specs.server_write_IV.data != NULL)
+        _gnutls_free_datum(&session->cipher_specs.server_write_IV);
+
       if (_gnutls_sset_datum
          (&session->cipher_specs.server_write_IV,
           &iv_block[IV_size], IV_size) < 0)
        {
-         gnutls_free (iv_block);
-         gnutls_free (key_block);
+         gnutls_assert();
          return GNUTLS_E_MEMORY_ERROR;
        }
-
-      gnutls_free (iv_block);
     }
 
-  gnutls_free (key_block);
-
   session->cipher_specs.generated_keys = 1;
 
   return 0;

diff --git a/lib/gnutls_mpi.c b/lib/gnutls_mpi.c
index d31437856b7eb60f09b0f69a905640d246aee0a5..90763e1679a8c5aba55e710c0f7e1f2eb962730e 100644 (file)
--- a/lib/gnutls_mpi.c
+++ b/lib/gnutls_mpi.c
@@ -43,17 +43,10 @@ bigint_t
 _gnutls_mpi_randomize (bigint_t r, unsigned int bits,
                       gnutls_rnd_level_t level)
 {
-  opaque *buf = NULL;
   int size = 1 + (bits / 8), ret;
   int rem, i;
   bigint_t tmp;
-
-  buf = gnutls_malloc (size);
-  if (buf == NULL)
-    {
-      gnutls_assert ();
-      return NULL;
-    }
+  opaque buf[size];
 
   ret = _gnutls_rnd (level, buf, size);
   if (ret < 0)
@@ -92,7 +85,6 @@ _gnutls_mpi_randomize (bigint_t r, unsigned int bits,
   return tmp;
 
 cleanup:
-  gnutls_free (buf);
   return NULL;
 }
 

diff --git a/lib/pk-libgcrypt.c b/lib/pk-libgcrypt.c
index ce1dd70bb8d884dcba283bfdb714081bcc42ec8d..ac0c0f9f75fa1ecc4b5715c0bff435f746203ce1 100644 (file)
--- a/lib/pk-libgcrypt.c
+++ b/lib/pk-libgcrypt.c
@@ -330,6 +330,8 @@ _wrap_gcry_pk_sign (gnutls_pk_algorithm_t algo, gnutls_datum_t * signature,
   rc = gcry_pk_sign (&s_sig, s_hash, s_key);
   gcry_sexp_release (s_hash);
   gcry_sexp_release (s_key);
+  s_hash = NULL;
+  s_key = NULL;
 
   if (rc != 0)
     {
@@ -352,6 +354,7 @@ _wrap_gcry_pk_sign (gnutls_pk_algorithm_t algo, gnutls_datum_t * signature,
 
       res[0] = gcry_sexp_nth_mpi (list, 1, 0);
       gcry_sexp_release (list);
+      list = NULL;
 
       list = gcry_sexp_find_token (s_sig, "s", 0);
       if (list == NULL)
@@ -363,6 +366,7 @@ _wrap_gcry_pk_sign (gnutls_pk_algorithm_t algo, gnutls_datum_t * signature,
 
       res[1] = gcry_sexp_nth_mpi (list, 1, 0);
       gcry_sexp_release (list);
+      list = NULL;
 
       ret = _gnutls_encode_ber_rs (signature, res[0], res[1]);
 
@@ -379,6 +383,7 @@ _wrap_gcry_pk_sign (gnutls_pk_algorithm_t algo, gnutls_datum_t * signature,
 
       res[0] = gcry_sexp_nth_mpi (list, 1, 0);
       gcry_sexp_release (list);
+      list = NULL;
 
       ret = _gnutls_mpi_dprint (res[0], signature);
     }
@@ -389,9 +394,7 @@ _wrap_gcry_pk_sign (gnutls_pk_algorithm_t algo, gnutls_datum_t * signature,
       goto cleanup;
     }
 
-  gcry_sexp_release (s_sig);
-
-  return 0;
+  ret = 0;
 
 cleanup:
   _gnutls_mpi_release (&hash);

diff --git a/lib/x509/common.c b/lib/x509/common.c
index b399e7244a12512fe47b31c6d45d1b1d5ad89b52..9396b70e132633766119da1cc027e36e356d1c94 100644 (file)
--- a/lib/x509/common.c
+++ b/lib/x509/common.c
@@ -1064,22 +1064,22 @@ _gnutls_x509_write_value (ASN1_TYPE c, const char *root,
   int result;
   int asize;
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
-  gnutls_datum_t val;
+  gnutls_datum_t val = { NULL, 0 };
 
   asize = data->size + 16;
 
-  val.data = gnutls_malloc (asize);
-  if (val.data == NULL)
-    {
-      gnutls_assert ();
-      result = GNUTLS_E_MEMORY_ERROR;
-      goto cleanup;
-    }
-
   if (str)
     {
       /* Convert it to OCTET STRING
        */
+      val.data = gnutls_malloc (asize);
+      if (val.data == NULL)
+        {
+          gnutls_assert ();
+          result = GNUTLS_E_MEMORY_ERROR;
+          goto cleanup;
+        }
+
       if ((result = asn1_create_element
           (_gnutls_get_pkix (), "PKIX1.pkcs-7-Data", &c2)) != ASN1_SUCCESS)
        {

diff --git a/lib/x509/dn.c b/lib/x509/dn.c
index b4e179b68b732b37e0bfd0a65545cd823775b9a0..911f7e659095e4eec78dac4cdbb804cd890ce7f3 100644 (file)
--- a/lib/x509/dn.c
+++ b/lib/x509/dn.c
@@ -697,8 +697,8 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
       if (result != ASN1_SUCCESS)
        {
          gnutls_assert ();
-         asn1_delete_structure (&c2);
-         return _gnutls_asn2err (result);
+         result = _gnutls_asn2err (result);
+         goto error;
        }
 
       _gnutls_str_cpy (tmp, sizeof (tmp), string_type);
@@ -708,8 +708,8 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      asn1_delete_structure (&c2);
-      return _gnutls_asn2err (result);
+      result = _gnutls_asn2err (result);
+      goto error;
     }
 
 
@@ -727,7 +727,8 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
       if (result != ASN1_SUCCESS)
        {
          gnutls_assert ();
-         return _gnutls_asn2err (result);
+         result = _gnutls_asn2err (result);
+         goto error;
        }
 
       _gnutls_str_cat (tmp, sizeof (tmp), ".?LAST");
@@ -738,7 +739,8 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
   if (result < 0)
     {
       gnutls_assert ();
-      return result;
+      result = _gnutls_asn2err (result);
+      goto error;
     }
 
   /* write the type
@@ -750,10 +752,15 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      result = _gnutls_asn2err (result);
+      goto error;
     }
 
-  return 0;
+  result = 0;
+
+error:
+  asn1_delete_structure (&c2);
+  return result;
 }
 
 /* This will write the AttributeTypeAndValue field. The data must be already DER encoded.