Implement the use of heap manipulator implementions

- Make use of the functions given through CRYPTO_set_mem_functions().
- CRYPTO_free(), CRYPTO_clear_free() and CRYPTO_secure_free() now receive
  __FILE__ and __LINE__.
- The API for CRYPTO_set_mem_functions() and CRYPTO_get_mem_functions()
  is slightly changed, the implementation for free() now takes a couple
  of extra arguments, taking __FILE__ and __LINE__.
- The CRYPTO_ memory functions will *always* receive __FILE__ and __LINE__
  from the corresponding OPENSSL_ macros, regardless of if crypto-mdebug
  has been enabled or not.  The reason is that if someone swaps out the
  malloc(), realloc() and free() implementations, we can't know if they
  will use them or not.

Reviewed-by: Rich Salz <rsalz@openssl.org>

1 files changed, 31 insertions, 34 deletions

diff --git a/crypto/mem.c b/crypto/mem.c
index 1e34904dab..46f00176ab 100644
--- a/crypto/mem.c
+++ b/crypto/mem.c
@@ -66,11 +66,11 @@
  */
 static int allow_customize = 1;
 
-static void *(*malloc_wrapper)(size_t, const char *, int)
+static void *(*malloc_impl)(size_t, const char *, int)
     = CRYPTO_malloc;
-static void *(*realloc_wrapper)(void *, size_t, const char *, int)
+static void *(*realloc_impl)(void *, size_t, const char *, int)
     = CRYPTO_realloc;
-static void (*free_wrapper)(void *)
+static void (*free_impl)(void *, const char *, int)
     = CRYPTO_free;
 
 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
@@ -82,16 +82,16 @@ static int call_malloc_debug = 0;
 int CRYPTO_set_mem_functions(
         void *(*m)(size_t, const char *, int),
         void *(*r)(void *, size_t, const char *, int),
-        void (*f)(void *))
+        void (*f)(void *, const char *, int))
 {
     if (!allow_customize)
         return 0;
     if (m)
-        malloc_wrapper = m;
+        malloc_impl = m;
     if (r)
-        realloc_wrapper = r;
+        realloc_impl = r;
     if (f)
-        free_wrapper = f;
+        free_impl = f;
     return 1;
 }
 
@@ -106,20 +106,23 @@ int CRYPTO_set_mem_debug(int flag)
 void CRYPTO_get_mem_functions(
         void *(**m)(size_t, const char *, int),
         void *(**r)(void *, size_t, const char *, int),
-        void (**f)(void *))
+        void (**f)(void *, const char *, int))
 {
     if (m != NULL)
-        *m = malloc_wrapper;
+        *m = malloc_impl;
     if (r != NULL)
-        *r = realloc_wrapper;
+        *r = realloc_impl;
     if (f != NULL)
-        *f = free_wrapper;
+        *f = free_impl;
 }
 
 void *CRYPTO_malloc(size_t num, const char *file, int line)
 {
     void *ret = NULL;
 
+    if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
+        return malloc_impl(num, file, line);
+
     if (num <= 0)
         return NULL;
 
@@ -164,11 +167,14 @@ void *CRYPTO_zalloc(size_t num, const char *file, int line)
 
 void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)
 {
+    if (realloc_impl != NULL && realloc_impl != &CRYPTO_realloc)
+        return realloc_impl(str, num, file, line);
+
     if (str == NULL)
         return CRYPTO_malloc(num, file, line);
 
     if (num == 0) {
-        CRYPTO_free(str);
+        CRYPTO_free(str, file, line);
         return NULL;
     }
 
@@ -198,7 +204,7 @@ void *CRYPTO_clear_realloc(void *str, size_t old_len, size_t num,
         return CRYPTO_malloc(num, file, line);
 
     if (num == 0) {
-        CRYPTO_clear_free(str, old_len);
+        CRYPTO_clear_free(str, old_len, file, line);
         return NULL;
     }
 
@@ -208,35 +214,26 @@ void *CRYPTO_clear_realloc(void *str, size_t old_len, size_t num,
         return str;
     }
 
-    /* Allocate new memory.  Call malloc and do a copy, so that we can
-     * cleanse the old buffer. */
-#ifndef OPENSSL_NO_CRYPTO_MDEBUG
-    if (call_malloc_debug) {
-        CRYPTO_mem_debug_realloc(str, NULL, num, 0, file, line);
-        ret = malloc(num);
-        CRYPTO_mem_debug_realloc(str, ret, num, 1, file, line);
-    } else {
-        ret = malloc(num);
-    }
-#else
-    (void)file;
-    (void)line;
-    ret = malloc(num);
-#endif
+    ret = CRYPTO_malloc(num, file, line);
 
     if (ret)
         memcpy(ret, str, old_len);
-    CRYPTO_clear_free(str, old_len);
+    CRYPTO_clear_free(str, old_len, file, line);
     return ret;
 }
 
-void CRYPTO_free(void *str)
+void CRYPTO_free(void *str, const char *file, int line)
 {
+    if (free_impl != NULL && free_impl != &CRYPTO_free) {
+        free_impl(str, file, line);
+        return;
+    }
+
 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
     if (call_malloc_debug) {
-        CRYPTO_mem_debug_free(str, 0);
+        CRYPTO_mem_debug_free(str, 0, file, line);
         free(str);
-        CRYPTO_mem_debug_free(str, 1);
+        CRYPTO_mem_debug_free(str, 1, file, line);
     } else {
         free(str);
     }
@@ -245,11 +242,11 @@ void CRYPTO_free(void *str)
 #endif
 }
 
-void CRYPTO_clear_free(void *str, size_t num)
+void CRYPTO_clear_free(void *str, size_t num, const char *file, int line)
 {
     if (str == NULL)
         return;
     if (num)
         OPENSSL_cleanse(str, num);
-    CRYPTO_free(str);
+    CRYPTO_free(str, file, line);
 }