From fa9b7b930e3e59f5b30de0e8a6755bfaafdd5c49 Mon Sep 17 00:00:00 2001 From: Eugene Syromiatnikov Date: Thu, 17 Jul 2025 03:32:02 +0200 Subject: [PATCH] Add array memory allocation routines MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Such routines allow alleviating the need to perform explicit integer overflow check during allocation size calculation and generally make the allocations more semantic (as they signify that a collection of NUM items, each occupying SIZE bytes is being allocated), which paves the road for additional correctness checks in the future. Signed-off-by: Eugene Syromiatnikov Reviewed-by: Saša Nedvědický Reviewed-by: Matt Caswell Reviewed-by: Paul Dale Reviewed-by: Neil Horman (Merged from https://github.com/openssl/openssl/pull/28059) --- crypto/array_alloc.c | 94 ++++++++++++++++++++++++++++++ crypto/build.info | 2 +- doc/man3/OPENSSL_malloc.pod | 52 ++++++++++++++--- doc/man3/OPENSSL_secure_malloc.pod | 34 +++++++++-- include/internal/mem_alloc_utils.h | 37 +++++++++++- include/openssl/crypto.h.in | 31 ++++++++++ util/libcrypto.num | 7 +++ util/other.syms | 7 +++ 8 files changed, 249 insertions(+), 15 deletions(-) create mode 100644 crypto/array_alloc.c diff --git a/crypto/array_alloc.c b/crypto/array_alloc.c new file mode 100644 index 00000000000..8c02163088d --- /dev/null +++ b/crypto/array_alloc.c @@ -0,0 +1,94 @@ +/* + * Copyright 2025 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +/* + * This file provides implementation of various array allocation routines that + * perform integer overflow checking for size calculation. + */ + +#include "internal/mem_alloc_utils.h" +#include + +void *CRYPTO_malloc_array(size_t num, size_t size, const char *file, int line) +{ + size_t bytes; + + if (ossl_unlikely(!ossl_size_mul(num, size, &bytes, file, line))) + return NULL; + + return CRYPTO_malloc(bytes, file, line); +} + +void *CRYPTO_calloc(size_t num, size_t size, const char *file, int line) +{ + size_t bytes; + + if (ossl_unlikely(!ossl_size_mul(num, size, &bytes, file, line))) + return NULL; + + return CRYPTO_zalloc(bytes, file, line); +} + +void *CRYPTO_aligned_alloc_array(size_t num, size_t size, size_t align, + void **freeptr, const char *file, int line) +{ + size_t bytes; + + if (ossl_unlikely(!ossl_size_mul(num, size, &bytes, file, line))) { + *freeptr = NULL; + + return NULL; + } + + return CRYPTO_aligned_alloc(bytes, align, freeptr, file, line); +} + +void *CRYPTO_realloc_array(void *addr, size_t num, size_t size, + const char *file, int line) +{ + size_t bytes; + + if (ossl_unlikely(!ossl_size_mul(num, size, &bytes, file, line))) + return NULL; + + return CRYPTO_realloc(addr, bytes, file, line); +} + +void *CRYPTO_clear_realloc_array(void *addr, size_t old_num, size_t num, + size_t size, const char *file, int line) +{ + size_t old_bytes, bytes = 0; + + if (ossl_unlikely(!ossl_size_mul(old_num, size, &old_bytes, file, line) + || !ossl_size_mul(num, size, &bytes, file, line))) + return NULL; + + return CRYPTO_clear_realloc(addr, old_bytes, bytes, file, line); +} + +void *CRYPTO_secure_malloc_array(size_t num, size_t size, + const char *file, int line) +{ + size_t bytes; + + if (ossl_unlikely(!ossl_size_mul(num, size, &bytes, file, line))) + return NULL; + + return CRYPTO_secure_malloc(bytes, file, line); +} + +void *CRYPTO_secure_calloc(size_t num, size_t size, const char *file, int line) +{ + size_t bytes; + + if (ossl_unlikely(!ossl_size_mul(num, size, &bytes, file, line))) + return NULL; + + return CRYPTO_secure_zalloc(bytes, file, line); +} diff --git a/crypto/build.info b/crypto/build.info index b187955a1f2..3cdc4dc2199 100644 --- a/crypto/build.info +++ b/crypto/build.info @@ -100,7 +100,7 @@ $UTIL_COMMON=\ threads_pthread.c threads_win.c threads_none.c threads_common.c \ initthread.c context.c sparse_array.c asn1_dsa.c packet.c \ param_build.c param_build_set.c der_writer.c threads_lib.c \ - params_dup.c time.c + params_dup.c time.c array_alloc.c SOURCE[../libcrypto]=$UTIL_COMMON \ mem.c mem_sec.c \ diff --git a/doc/man3/OPENSSL_malloc.pod b/doc/man3/OPENSSL_malloc.pod index fd97b9aa962..5f6c9d3c8bf 100644 --- a/doc/man3/OPENSSL_malloc.pod +++ b/doc/man3/OPENSSL_malloc.pod @@ -4,14 +4,19 @@ OPENSSL_malloc_init, OPENSSL_malloc, OPENSSL_aligned_alloc, OPENSSL_zalloc, OPENSSL_realloc, -OPENSSL_free, OPENSSL_clear_realloc, OPENSSL_clear_free, OPENSSL_cleanse, -CRYPTO_malloc, CRYPTO_aligned_alloc, CRYPTO_zalloc, CRYPTO_realloc, CRYPTO_free, +OPENSSL_malloc_array, OPENSSL_aligned_alloc_array, OPENSSL_calloc, +OPENSSL_realloc_array, OPENSSL_free, +OPENSSL_clear_realloc, OPENSSL_clear_realloc_array, +OPENSSL_clear_free, OPENSSL_cleanse, +CRYPTO_malloc, CRYPTO_aligned_alloc, CRYPTO_zalloc, +CRYPTO_malloc_array, CRYPTO_aligned_alloc_array, CRYPTO_calloc, +CRYPTO_realloc, CRYPTO_realloc_array, CRYPTO_free, OPENSSL_strdup, OPENSSL_strndup, OPENSSL_memdup, OPENSSL_strlcpy, OPENSSL_strlcat, OPENSSL_strtoul, CRYPTO_strdup, CRYPTO_strndup, OPENSSL_mem_debug_push, OPENSSL_mem_debug_pop, CRYPTO_mem_debug_push, CRYPTO_mem_debug_pop, -CRYPTO_clear_realloc, CRYPTO_clear_free, +CRYPTO_clear_realloc, CRYPTO_clear_realloc_array, CRYPTO_clear_free, CRYPTO_malloc_fn, CRYPTO_realloc_fn, CRYPTO_free_fn, CRYPTO_get_mem_functions, CRYPTO_set_mem_functions, CRYPTO_get_alloc_counts, @@ -32,6 +37,11 @@ OPENSSL_MALLOC_SEED void *OPENSSL_aligned_alloc(size_t num, size_t alignment, void **freeptr); void *OPENSSL_zalloc(size_t num); void *OPENSSL_realloc(void *addr, size_t num); + void *OPENSSL_malloc_array(size_t num, size_t size); + void *OPENSSL_aligned_alloc_array(size_t num, size_t size, size_t alignment, + void **freeptr); + void *OPENSSL_calloc(size_t num, size_t size); + void *OPENSSL_realloc_array(void *addr, size_t num, size_t size); void OPENSSL_free(void *addr); char *OPENSSL_strdup(const char *str); char *OPENSSL_strndup(const char *str, size_t s); @@ -40,20 +50,30 @@ OPENSSL_MALLOC_SEED int OPENSSL_strtoul(char *src, char **endptr, int base, unsigned long *num); void *OPENSSL_memdup(void *data, size_t s); void *OPENSSL_clear_realloc(void *p, size_t old_len, size_t num); + void *OPENSSL_clear_realloc_array(void *p, size_t old_len, size_t num, + size_t size); void OPENSSL_clear_free(void *str, size_t num); void OPENSSL_cleanse(void *ptr, size_t len); void *CRYPTO_malloc(size_t num, const char *file, int line); - void *CRYPTO_aligned_alloc(size_t num, size_t align, void **freeptr, + void *CRYPTO_aligned_alloc(size_t num, size_t align, void **freeptr, const char *file, int line); void *CRYPTO_zalloc(size_t num, const char *file, int line); void *CRYPTO_realloc(void *p, size_t num, const char *file, int line); - void CRYPTO_free(void *str, const char *, int); + void *CRYPTO_malloc_array(size_t num, size_t size, const char *file, int line); + void *CRYPTO_aligned_alloc_array(size_t num, size_t size, size_t align, + void **freeptr, const char *file, int line); + void *CRYPTO_calloc(size_t num, size_t size, const char *file, int line); + void *CRYPTO_realloc_array(void *p, size_t num, size_t size, + const char *file, int line); + void CRYPTO_free(void *str, const char *file, int line); char *CRYPTO_strdup(const char *p, const char *file, int line); char *CRYPTO_strndup(const char *p, size_t num, const char *file, int line); void *CRYPTO_clear_realloc(void *p, size_t old_len, size_t num, const char *file, int line); - void CRYPTO_clear_free(void *str, size_t num, const char *, int); + void *CRYPTO_clear_realloc_array(void *p, size_t old_len, size_t num, + size_t size, const char *file, int line); + void CRYPTO_clear_free(void *str, size_t num, const char *file, int line); typedef void *(*CRYPTO_malloc_fn)(size_t num, const char *file, int line); typedef void *(*CRYPTO_realloc_fn)(void *addr, size_t num, const char *file, @@ -122,6 +142,15 @@ The old buffer is filled with zero's by calling OPENSSL_cleanse() before ultimately calling OPENSSL_free(). If the argument to OPENSSL_free() is NULL, nothing is done. +OPENSSL_malloc_array(), OPENSSL_calloc(), OPENSSL_aligned_alloc_array(), +OPENSSL_realloc_array(), and OPENSSL_clear_realloc_array() are variants +of OPENSSL_malloc(), OPENSSL_zalloc(), OPENSSL_aligned_alloc(), +OPENSSL_realloc(), and OPENSSL_clear_realloc(), respectively, that accept +an additional parameter, B, which enables memory allocation +operations for an array of B members B bytes each; +these functions return an error if multiplication of B and B +leads to an integer overflow, thus preventing allocations of an incorrect size. + OPENSSL_cleanse() fills B of size B with a string of 0's. Use OPENSSL_cleanse() with care if the memory is a mapping of a file. If the storage controller uses write compression, then it's possible @@ -203,9 +232,12 @@ CRYPTO_free(), CRYPTO_clear_free() and CRYPTO_get_mem_functions() return no value. OPENSSL_malloc(), OPENSSL_aligned_alloc(), OPENSSL_zalloc(), OPENSSL_realloc(), -OPENSSL_clear_realloc(), +OPENSSL_malloc_array(), OPENSSL_aligned_alloc_array(), OPENSSL_calloc(), +OPENSSL_realloc_array(), +OPENSSL_clear_realloc(), OPENSSL_clear_realloc_array(), CRYPTO_malloc(), CRYPTO_zalloc(), CRYPTO_realloc(), -CRYPTO_clear_realloc(), +CRYPTO_malloc_array(), CRYPTO_calloc(), CRYPTO_realloc_array(), +CRYPTO_clear_realloc(), CRYPTO_clear_realloc_array(), OPENSSL_strdup(), and OPENSSL_strndup() return a pointer to allocated memory or NULL on error. @@ -259,6 +291,10 @@ The memory-leak checking has been deprecated in OpenSSL 3.0 in favor of clang's memory and leak sanitizer. OPENSSL_aligned_alloc(), CRYPTO_aligned_alloc(), OPENSSL_strtoul() were added in OpenSSL 3.4. +OPENSSL_malloc_array(), OPENSSL_calloc(), OPENSSL_aligned_alloc_array(), +OPENSSL_realloc_array(), OPENSSL_clear_realloc_array(), CRYPTO_malloc_array(), +CRYPTO_calloc(), CRYPTO_aligned_alloc_array(), CRYPTO_realloc_array(), +CRYPTO_clear_realloc_array() were added in OpenSSL 3.6. =head1 COPYRIGHT diff --git a/doc/man3/OPENSSL_secure_malloc.pod b/doc/man3/OPENSSL_secure_malloc.pod index dbc7073aac1..f887da4c114 100644 --- a/doc/man3/OPENSSL_secure_malloc.pod +++ b/doc/man3/OPENSSL_secure_malloc.pod @@ -4,8 +4,9 @@ CRYPTO_secure_malloc_init, CRYPTO_secure_malloc_initialized, CRYPTO_secure_malloc_done, OPENSSL_secure_malloc, CRYPTO_secure_malloc, -OPENSSL_secure_zalloc, CRYPTO_secure_zalloc, OPENSSL_secure_free, -CRYPTO_secure_free, OPENSSL_secure_clear_free, +OPENSSL_secure_zalloc, CRYPTO_secure_zalloc, OPENSSL_secure_malloc_array, +CRYPTO_secure_malloc_array, OPENSSL_secure_calloc, CRYPTO_secure_calloc, +OPENSSL_secure_free, CRYPTO_secure_free, OPENSSL_secure_clear_free, CRYPTO_secure_clear_free, OPENSSL_secure_actual_size, CRYPTO_secure_allocated, CRYPTO_secure_used - secure heap storage @@ -26,6 +27,14 @@ CRYPTO_secure_used - secure heap storage void *OPENSSL_secure_zalloc(size_t num); void *CRYPTO_secure_zalloc(size_t num, const char *file, int line); + void *OPENSSL_secure_malloc_array(size_t num, size_t size); + void *CRYPTO_secure_malloc_array(size_t num, size_t size, + const char *file, int line); + + void *OPENSSL_secure_calloc(size_t num, size_t size); + void *CRYPTO_secure_calloc(size_t num, size_t size, + const char *file, int line); + void OPENSSL_secure_free(void* ptr); void CRYPTO_secure_free(void *ptr, const char *, int); @@ -80,6 +89,15 @@ OPENSSL_secure_zalloc() and CRYPTO_secure_zalloc() are like OPENSSL_secure_malloc() and CRYPTO_secure_malloc(), respectively, except that they call memset() to zero the memory before returning. +OPENSSL_secure_malloc_array(), CRYPTO_secure_malloc_array(), +OPENSSL_secure_calloc(), and CRYPTO_secure_calloc() are variants +of OPENSSL_secure_malloc(), CRYPTO_secure_malloc(), +OPENSSL_secure_zalloc(), and CRYPTO_secure_zalloc(), respectively, that accept +an additional parameter, B, which enables memory allocation +operations for an array of B members B bytes each; +these functions return an error if multiplication of B and B +leads to an integer overflow, thus preventing allocations of an incorrect size. + OPENSSL_secure_free() releases the memory at C back to the heap. It must be called with a value previously obtained from OPENSSL_secure_malloc(). @@ -116,9 +134,11 @@ CRYPTO_secure_malloc_initialized() returns 1 if the secure heap is available (that is, if CRYPTO_secure_malloc_init() has been called, but CRYPTO_secure_malloc_done() has not been called or failed) or 0 if not. -OPENSSL_secure_malloc() and OPENSSL_secure_zalloc() return a pointer into -the secure heap of the requested size, or C if memory could not be -allocated. +OPENSSL_secure_malloc(), CRYPTO_secure_malloc(), OPENSSL_secure_zalloc(), +CRYPTO_secure_zalloc(), OPENSSL_secure_malloc_array(), +CRYPTO_secure_malloc_array(), OPENSSL_secure_calloc(), and CRYPTO_secure_calloc() +return a pointer into the secure heap of the requested size, +or C if memory could not be allocated. CRYPTO_secure_allocated() returns 1 if the pointer is in the secure heap, or 0 if not. @@ -138,6 +158,10 @@ The OPENSSL_secure_clear_free() function was added in OpenSSL 1.1.0g. The second argument to CRYPTO_secure_malloc_init() was changed from an B to a B in OpenSSL 3.0. +The OPENSSL_secure_malloc_array(), CRYPTO_secure_malloc_array(), +OPENSSL_secure_calloc(), and CRYPTO_secure_calloc() functions were added +in OpenSSL 3.6. + =head1 COPYRIGHT Copyright 2015-2025 The OpenSSL Project Authors. All Rights Reserved. diff --git a/include/internal/mem_alloc_utils.h b/include/internal/mem_alloc_utils.h index b63977ee533..7b259481ef3 100644 --- a/include/internal/mem_alloc_utils.h +++ b/include/internal/mem_alloc_utils.h @@ -14,11 +14,18 @@ #ifndef OSSL_INTERNAL_CHECK_SIZE_OVERFLOW_H # define OSSL_INTERNAL_CHECK_SIZE_OVERFLOW_H +# include +# include +# include + # include "internal/common.h" +# include "internal/safe_math.h" # include # include +OSSL_SAFE_MATH_UNSIGNED(size_t, size_t) + /* * A helper routine to report memory allocation errors. * Similar to the ERR_raise() macro, but accepts explicit file/line arguments, @@ -41,10 +48,38 @@ ossl_report_alloc_err_ex(const char * const file, const int line, } /* Report a memory allocation failure. */ -static inline void +static ossl_inline ossl_unused void ossl_report_alloc_err(const char * const file, const int line) { ossl_report_alloc_err_ex(file, line, ERR_R_MALLOC_FAILURE); } +/* Report an integer overflow during allocation size calculation. */ +static ossl_inline ossl_unused void +ossl_report_alloc_err_of(const char * const file, const int line) +{ + ossl_report_alloc_err_ex(file, line, CRYPTO_R_INTEGER_OVERFLOW); +} + +/* + * Check the result of num and size multiplication for overflow + * and set error if it is the case; return true if there was no overflow, + * false if there was. + */ +static ossl_inline ossl_unused bool +ossl_size_mul(const size_t num, const size_t size, size_t *bytes, + const char * const file, const int line) +{ + int err = 0; + *bytes = safe_mul_size_t(num, size, &err); + + if (ossl_unlikely(err != 0)) { + ossl_report_alloc_err_of(file, line); + + return false; + } + + return true; +} + #endif /* OSSL_INTERNAL_CHECK_SIZE_OVERFLOW_H */ diff --git a/include/openssl/crypto.h.in b/include/openssl/crypto.h.in index 9992fc409d5..57b2f3a1dc5 100644 --- a/include/openssl/crypto.h.in +++ b/include/openssl/crypto.h.in @@ -103,13 +103,25 @@ int CRYPTO_atomic_store(uint64_t *dst, uint64_t val, CRYPTO_RWLOCK *lock); CRYPTO_malloc(num, OPENSSL_FILE, OPENSSL_LINE) # define OPENSSL_zalloc(num) \ CRYPTO_zalloc(num, OPENSSL_FILE, OPENSSL_LINE) +# define OPENSSL_malloc_array(num, size) \ + CRYPTO_malloc_array(num, size, OPENSSL_FILE, OPENSSL_LINE) +# define OPENSSL_calloc(num, size) \ + CRYPTO_calloc(num, size, OPENSSL_FILE, OPENSSL_LINE) # define OPENSSL_aligned_alloc(num, alignment, freeptr) \ CRYPTO_aligned_alloc(num, alignment, freeptr, \ OPENSSL_FILE, OPENSSL_LINE) +# define OPENSSL_aligned_alloc_array(num, size, alignment, freeptr) \ + CRYPTO_aligned_alloc_array(num, size, alignment, freeptr, \ + OPENSSL_FILE, OPENSSL_LINE) # define OPENSSL_realloc(addr, num) \ CRYPTO_realloc(addr, num, OPENSSL_FILE, OPENSSL_LINE) # define OPENSSL_clear_realloc(addr, old_num, num) \ CRYPTO_clear_realloc(addr, old_num, num, OPENSSL_FILE, OPENSSL_LINE) +# define OPENSSL_realloc_array(addr, num, size) \ + CRYPTO_realloc_array(addr, num, size, OPENSSL_FILE, OPENSSL_LINE) +# define OPENSSL_clear_realloc_array(addr, old_num, num, size) \ + CRYPTO_clear_realloc_array(addr, old_num, num, size, \ + OPENSSL_FILE, OPENSSL_LINE) # define OPENSSL_clear_free(addr, num) \ CRYPTO_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE) # define OPENSSL_free(addr) \ @@ -124,6 +136,10 @@ int CRYPTO_atomic_store(uint64_t *dst, uint64_t val, CRYPTO_RWLOCK *lock); CRYPTO_secure_malloc(num, OPENSSL_FILE, OPENSSL_LINE) # define OPENSSL_secure_zalloc(num) \ CRYPTO_secure_zalloc(num, OPENSSL_FILE, OPENSSL_LINE) +# define OPENSSL_secure_malloc_array(num, size) \ + CRYPTO_secure_malloc_array(num, size, OPENSSL_FILE, OPENSSL_LINE) +# define OPENSSL_secure_calloc(num, size) \ + CRYPTO_secure_calloc(num, size, OPENSSL_FILE, OPENSSL_LINE) # define OPENSSL_secure_free(addr) \ CRYPTO_secure_free(addr, OPENSSL_FILE, OPENSSL_LINE) # define OPENSSL_secure_clear_free(addr, num) \ @@ -332,9 +348,16 @@ void CRYPTO_get_mem_functions(CRYPTO_malloc_fn *malloc_fn, OSSL_CRYPTO_ALLOC void *CRYPTO_malloc(size_t num, const char *file, int line); OSSL_CRYPTO_ALLOC void *CRYPTO_zalloc(size_t num, const char *file, int line); +OSSL_CRYPTO_ALLOC void *CRYPTO_malloc_array(size_t num, size_t size, + const char *file, int line); +OSSL_CRYPTO_ALLOC void *CRYPTO_calloc(size_t num, size_t size, + const char *file, int line); OSSL_CRYPTO_ALLOC void *CRYPTO_aligned_alloc(size_t num, size_t align, void **freeptr, const char *file, int line); +OSSL_CRYPTO_ALLOC void *CRYPTO_aligned_alloc_array(size_t num, size_t size, + size_t align, void **freeptr, + const char *file, int line); OSSL_CRYPTO_ALLOC void *CRYPTO_memdup(const void *str, size_t siz, const char *file, int line); OSSL_CRYPTO_ALLOC char *CRYPTO_strdup(const char *str, const char *file, int line); OSSL_CRYPTO_ALLOC char *CRYPTO_strndup(const char *str, size_t s, const char *file, int line); @@ -343,11 +366,19 @@ void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line); void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line); void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num, const char *file, int line); +void *CRYPTO_realloc_array(void *addr, size_t num, size_t size, + const char *file, int line); +void *CRYPTO_clear_realloc_array(void *addr, size_t old_num, size_t num, + size_t size, const char *file, int line); int CRYPTO_secure_malloc_init(size_t sz, size_t minsize); int CRYPTO_secure_malloc_done(void); OSSL_CRYPTO_ALLOC void *CRYPTO_secure_malloc(size_t num, const char *file, int line); OSSL_CRYPTO_ALLOC void *CRYPTO_secure_zalloc(size_t num, const char *file, int line); +OSSL_CRYPTO_ALLOC void *CRYPTO_secure_malloc_array(size_t num, size_t size, + const char *file, int line); +OSSL_CRYPTO_ALLOC void *CRYPTO_secure_calloc(size_t num, size_t size, + const char *file, int line); void CRYPTO_secure_free(void *ptr, const char *file, int line); void CRYPTO_secure_clear_free(void *ptr, size_t num, const char *file, int line); diff --git a/util/libcrypto.num b/util/libcrypto.num index d1667ee2a67..99e6407ad45 100644 --- a/util/libcrypto.num +++ b/util/libcrypto.num @@ -5936,3 +5936,10 @@ CMS_RecipientInfo_kemri_set0_pkey ? 3_6_0 EXIST::FUNCTION:CMS CMS_RecipientInfo_kemri_get0_ctx ? 3_6_0 EXIST::FUNCTION:CMS CMS_RecipientInfo_kemri_get0_kdf_alg ? 3_6_0 EXIST::FUNCTION:CMS CMS_RecipientInfo_kemri_set_ukm ? 3_6_0 EXIST::FUNCTION:CMS +CRYPTO_malloc_array ? 3_6_0 EXIST::FUNCTION: +CRYPTO_calloc ? 3_6_0 EXIST::FUNCTION: +CRYPTO_aligned_alloc_array ? 3_6_0 EXIST::FUNCTION: +CRYPTO_realloc_array ? 3_6_0 EXIST::FUNCTION: +CRYPTO_clear_realloc_array ? 3_6_0 EXIST::FUNCTION: +CRYPTO_secure_malloc_array ? 3_6_0 EXIST::FUNCTION: +CRYPTO_secure_calloc ? 3_6_0 EXIST::FUNCTION: diff --git a/util/other.syms b/util/other.syms index e74cd099c75..80488efa10b 100644 --- a/util/other.syms +++ b/util/other.syms @@ -430,21 +430,28 @@ OPENSSL_VERSION_BUILD_METADATA define OPENSSL_VERSION_PRE_RELEASE_STR define OPENSSL_VERSION_BUILD_METADATA_STR define OPENSSL_VERSION_TEXT define +OPENSSL_calloc define OPENSSL_clear_free define OPENSSL_clear_realloc define +OPENSSL_clear_realloc_array define OPENSSL_free define OPENSSL_malloc define +OPENSSL_malloc_array define OPENSSL_aligned_alloc define +OPENSSL_aligned_alloc_array define OPENSSL_malloc_init define OPENSSL_mem_debug_pop define deprecated 3.0.0 OPENSSL_mem_debug_push define deprecated 3.0.0 OPENSSL_memdup define OPENSSL_no_config define deprecated 1.1.0 OPENSSL_realloc define +OPENSSL_realloc_array define OPENSSL_secure_actual_size define OPENSSL_secure_clear_free define OPENSSL_secure_free define +OPENSSL_secure_calloc define OPENSSL_secure_malloc define +OPENSSL_secure_malloc_array define OPENSSL_secure_zalloc define OPENSSL_strdup define OPENSSL_strndup define -- 2.47.3