/* crypto/mem.c */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * * This package is an SSL implementation written * by Eric Young (eay@cryptsoft.com). * The implementation was written so as to conform with Netscapes SSL. * * This library is free for commercial and non-commercial use as long as * the following conditions are aheared to. The following conditions * apply to all code found in this distribution, be it the RC4, RSA, * lhash, DES, etc., code; not just the SSL code. The SSL documentation * included with this distribution is covered by the same copyright terms * except that the holder is Tim Hudson (tjh@cryptsoft.com). * * Copyright remains Eric Young's, and as such any Copyright notices in * the code are not to be removed. * If this package is used in a product, Eric Young should be given attribution * as the author of the parts of the library used. * This can be in the form of a textual message at program startup or * in documentation (online or textual) provided with the package. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * "This product includes cryptographic software written by * Eric Young (eay@cryptsoft.com)" * The word 'cryptographic' can be left out if the rouines from the library * being used are not cryptographic related :-). * 4. If you include any Windows specific code (or a derivative thereof) from * the apps directory (application code) you must include an acknowledgement: * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" * * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * The licence and distribution terms for any publically available version or * derivative of this code cannot be changed. i.e. this code cannot simply be * copied and put under another distribution licence * [including the GNU Public Licence.] */ #include #include #include #include "cryptlib.h" /* AnV - malloc + realloc + free fix */ #include #include #include #include #include #include #include #include #define CPOOL_HEAD_SIGNATURE SIGNATURE_32('C','p','h','d') typedef struct { LIST_ENTRY List; UINT32 Signature; UINT64 Size; CHAR8 Data[1]; } CPOOL_HEAD; static LIST_ENTRY MemPoolHead = INITIALIZE_LIST_HEAD_VARIABLE(MemPoolHead); void * uefimalloc(size_t Size) { CPOOL_HEAD *Head; void *RetVal; EFI_STATUS Status; UINTN NodeSize; if( Size == 0) { errno = EINVAL; // Make errno diffenent, just in case of a lingering ENOMEM. return NULL; } NodeSize = (UINTN)(Size + sizeof(CPOOL_HEAD)); Status = gBS->AllocatePool( EfiLoaderData, NodeSize, (void**)&Head); if( Status != EFI_SUCCESS) { RetVal = NULL; errno = ENOMEM; } else { assert(Head != NULL); // Fill out the pool header Head->Signature = CPOOL_HEAD_SIGNATURE; Head->Size = NodeSize; // Add this node to the list (void)InsertTailList(&MemPoolHead, (LIST_ENTRY *)Head); // Return a pointer to the data RetVal = (void*)Head->Data; } return RetVal; } void uefifree(void *Ptr) { CPOOL_HEAD *Head; Head = BASE_CR(Ptr, CPOOL_HEAD, Data); assert(Head != NULL); if(Ptr != NULL) { if (Head->Signature == CPOOL_HEAD_SIGNATURE) { (void) RemoveEntryList((LIST_ENTRY *)Head); // Remove this node from the malloc pool (void) gBS->FreePool (Head); // Now free the associated memory } else { errno = 14; } } DEBUG((DEBUG_POOL, "free Done\n")); } void * uefirealloc(void *Ptr, size_t ReqSize) { void *RetVal = NULL; CPOOL_HEAD *Head = NULL; size_t OldSize = 0; size_t NewSize; size_t NumCpy; // Find out the size of the OLD memory region if( Ptr != NULL) { Head = BASE_CR (Ptr, CPOOL_HEAD, Data); assert(Head != NULL); if (Head->Signature != CPOOL_HEAD_SIGNATURE) { errno = 14; DEBUG((DEBUG_ERROR, "ERROR realloc(0x%p): Signature is 0x%8X, expected 0x%8X\n", Ptr, Head->Signature, CPOOL_HEAD_SIGNATURE)); return NULL; } OldSize = (size_t)Head->Size; } // At this point, Ptr is either NULL or a valid pointer to an allocated space NewSize = (size_t)(ReqSize + (sizeof(CPOOL_HEAD))); if( ReqSize > 0) { RetVal = AllocateZeroPool(NewSize); // Get the NEW memory region if( Ptr != NULL) { // If there is an OLD region... if( RetVal != NULL) { // and the NEW region was successfully allocated NumCpy = OldSize; if( OldSize > NewSize) { NumCpy = NewSize; } (VOID)CopyMem( RetVal, Ptr, NumCpy); // Copy old data to the new region. FreePool( Ptr); // and reclaim the old region. } else { errno = ENOMEM; } } } else { FreePool( Ptr); // Reclaim the old region. } return RetVal; } #undef realloc #define realloc uefirealloc #undef malloc #define malloc uefimalloc #undef free #define free uefifree static int allow_customize = 1; /* we provide flexible functions for */ static int allow_customize_debug = 1;/* exchanging memory-related functions at * run-time, but this must be done * before any blocks are actually * allocated; or we'll run into huge * problems when malloc/free pairs * don't match etc. */ /* the following pointers may be changed as long as 'allow_customize' is set */ static void *(*malloc_func)(size_t) = malloc; static void *default_malloc_ex(size_t num, const char *file, int line) { return malloc_func(num); } static void *(*malloc_ex_func)(size_t, const char *file, int line) = default_malloc_ex; static void *(*realloc_func)(void *, size_t)= realloc; static void *default_realloc_ex(void *str, size_t num, const char *file, int line) { return realloc_func(str,num); } static void *(*realloc_ex_func)(void *, size_t, const char *file, int line) = default_realloc_ex; static void (*free_func)(void *) = free; static void *(*malloc_locked_func)(size_t) = malloc; static void *default_malloc_locked_ex(size_t num, const char *file, int line) { return malloc_locked_func(num); } static void *(*malloc_locked_ex_func)(size_t, const char *file, int line) = default_malloc_locked_ex; static void (*free_locked_func)(void *) = free; /* may be changed as long as 'allow_customize_debug' is set */ /* XXX use correct function pointer types */ #ifdef CRYPTO_MDEBUG /* use default functions from mem_dbg.c */ static void (*malloc_debug_func)(void *,int,const char *,int,int) = CRYPTO_dbg_malloc; static void (*realloc_debug_func)(void *,void *,int,const char *,int,int) = CRYPTO_dbg_realloc; static void (*free_debug_func)(void *,int) = CRYPTO_dbg_free; static void (*set_debug_options_func)(long) = CRYPTO_dbg_set_options; static long (*get_debug_options_func)(void) = CRYPTO_dbg_get_options; #else /* applications can use CRYPTO_malloc_debug_init() to select above case * at run-time */ static void (*malloc_debug_func)(void *,int,const char *,int,int) = NULL; static void (*realloc_debug_func)(void *,void *,int,const char *,int,int) = NULL; static void (*free_debug_func)(void *,int) = NULL; static void (*set_debug_options_func)(long) = NULL; static long (*get_debug_options_func)(void) = NULL; #endif int CRYPTO_set_mem_functions(void *(*m)(size_t), void *(*r)(void *, size_t), void (*f)(void *)) { /* Dummy call just to ensure OPENSSL_init() gets linked in */ OPENSSL_init(); if (!allow_customize) return 0; if ((m == 0) || (r == 0) || (f == 0)) return 0; malloc_func=m; malloc_ex_func=default_malloc_ex; realloc_func=r; realloc_ex_func=default_realloc_ex; free_func=f; malloc_locked_func=m; malloc_locked_ex_func=default_malloc_locked_ex; free_locked_func=f; return 1; } int CRYPTO_set_mem_ex_functions( void *(*m)(size_t,const char *,int), void *(*r)(void *, size_t,const char *,int), void (*f)(void *)) { if (!allow_customize) return 0; if ((m == 0) || (r == 0) || (f == 0)) return 0; malloc_func=0; malloc_ex_func=m; realloc_func=0; realloc_ex_func=r; free_func=f; malloc_locked_func=0; malloc_locked_ex_func=m; free_locked_func=f; return 1; } int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*f)(void *)) { if (!allow_customize) return 0; if ((m == NULL) || (f == NULL)) return 0; malloc_locked_func=m; malloc_locked_ex_func=default_malloc_locked_ex; free_locked_func=f; return 1; } int CRYPTO_set_locked_mem_ex_functions( void *(*m)(size_t,const char *,int), void (*f)(void *)) { if (!allow_customize) return 0; if ((m == NULL) || (f == NULL)) return 0; malloc_locked_func=0; malloc_locked_ex_func=m; free_func=f; return 1; } int CRYPTO_set_mem_debug_functions(void (*m)(void *,int,const char *,int,int), void (*r)(void *,void *,int,const char *,int,int), void (*f)(void *,int), void (*so)(long), long (*go)(void)) { if (!allow_customize_debug) return 0; OPENSSL_init(); malloc_debug_func=m; realloc_debug_func=r; free_debug_func=f; set_debug_options_func=so; get_debug_options_func=go; return 1; } void CRYPTO_get_mem_functions(void *(**m)(size_t), void *(**r)(void *, size_t), void (**f)(void *)) { if (m != NULL) *m = (malloc_ex_func == default_malloc_ex) ? malloc_func : 0; if (r != NULL) *r = (realloc_ex_func == default_realloc_ex) ? realloc_func : 0; if (f != NULL) *f=free_func; } void CRYPTO_get_mem_ex_functions( void *(**m)(size_t,const char *,int), void *(**r)(void *, size_t,const char *,int), void (**f)(void *)) { if (m != NULL) *m = (malloc_ex_func != default_malloc_ex) ? malloc_ex_func : 0; if (r != NULL) *r = (realloc_ex_func != default_realloc_ex) ? realloc_ex_func : 0; if (f != NULL) *f=free_func; } void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *)) { if (m != NULL) *m = (malloc_locked_ex_func == default_malloc_locked_ex) ? malloc_locked_func : 0; if (f != NULL) *f=free_locked_func; } void CRYPTO_get_locked_mem_ex_functions( void *(**m)(size_t,const char *,int), void (**f)(void *)) { if (m != NULL) *m = (malloc_locked_ex_func != default_malloc_locked_ex) ? malloc_locked_ex_func : 0; if (f != NULL) *f=free_locked_func; } void CRYPTO_get_mem_debug_functions(void (**m)(void *,int,const char *,int,int), void (**r)(void *,void *,int,const char *,int,int), void (**f)(void *,int), void (**so)(long), long (**go)(void)) { if (m != NULL) *m=malloc_debug_func; if (r != NULL) *r=realloc_debug_func; if (f != NULL) *f=free_debug_func; if (so != NULL) *so=set_debug_options_func; if (go != NULL) *go=get_debug_options_func; } void *CRYPTO_malloc_locked(int num, const char *file, int line) { void *ret = NULL; if (num <= 0) return NULL; allow_customize = 0; if (malloc_debug_func != NULL) { allow_customize_debug = 0; malloc_debug_func(NULL, num, file, line, 0); } ret = malloc_locked_ex_func(num,file,line); #ifdef LEVITTE_DEBUG_MEM fprintf(stderr, "LEVITTE_DEBUG_MEM: > 0x%p (%d)\n", ret, num); #endif if (malloc_debug_func != NULL) malloc_debug_func(ret, num, file, line, 1); #ifndef OPENSSL_CPUID_OBJ /* Create a dependency on the value of 'cleanse_ctr' so our memory * sanitisation function can't be optimised out. NB: We only do * this for >2Kb so the overhead doesn't bother us. */ if(ret && (num > 2048)) { extern unsigned char cleanse_ctr; ((unsigned char *)ret)[0] = cleanse_ctr; } #endif return ret; } void CRYPTO_free_locked(void *str) { if (free_debug_func != NULL) free_debug_func(str, 0); #ifdef LEVITTE_DEBUG_MEM fprintf(stderr, "LEVITTE_DEBUG_MEM: < 0x%p\n", str); #endif free_locked_func(str); if (free_debug_func != NULL) free_debug_func(NULL, 1); } void *CRYPTO_malloc(int num, const char *file, int line) { void *ret = NULL; if (num <= 0) return NULL; allow_customize = 0; if (malloc_debug_func != NULL) { allow_customize_debug = 0; malloc_debug_func(NULL, num, file, line, 0); } ret = malloc_ex_func(num,file,line); #ifdef LEVITTE_DEBUG_MEM fprintf(stderr, "LEVITTE_DEBUG_MEM: > 0x%p (%d)\n", ret, num); #endif if (malloc_debug_func != NULL) malloc_debug_func(ret, num, file, line, 1); #ifndef OPENSSL_CPUID_OBJ /* Create a dependency on the value of 'cleanse_ctr' so our memory * sanitisation function can't be optimised out. NB: We only do * this for >2Kb so the overhead doesn't bother us. */ if(ret && (num > 2048)) { extern unsigned char cleanse_ctr; ((unsigned char *)ret)[0] = cleanse_ctr; } #endif return ret; } char *CRYPTO_strdup(const char *str, const char *file, int line) { char *ret = CRYPTO_malloc(strlen(str)+1, file, line); strcpy(ret, str); return ret; } void *CRYPTO_realloc(void *str, int num, const char *file, int line) { void *ret = NULL; if (str == NULL) return CRYPTO_malloc(num, file, line); if (num <= 0) return NULL; if (realloc_debug_func != NULL) realloc_debug_func(str, NULL, num, file, line, 0); ret = realloc_ex_func(str,num,file,line); #ifdef LEVITTE_DEBUG_MEM fprintf(stderr, "LEVITTE_DEBUG_MEM: | 0x%p -> 0x%p (%d)\n", str, ret, num); #endif if (realloc_debug_func != NULL) realloc_debug_func(str, ret, num, file, line, 1); return ret; } void *CRYPTO_realloc_clean(void *str, int old_len, int num, const char *file, int line) { void *ret = NULL; if (str == NULL) return CRYPTO_malloc(num, file, line); if (num <= 0) return NULL; /* We don't support shrinking the buffer. Note the memcpy that copies * |old_len| bytes to the new buffer, below. */ if (num < old_len) return NULL; if (realloc_debug_func != NULL) realloc_debug_func(str, NULL, num, file, line, 0); ret=malloc_ex_func(num,file,line); if(ret) { memcpy(ret,str,old_len); OPENSSL_cleanse(str,old_len); free_func(str); } #ifdef LEVITTE_DEBUG_MEM fprintf(stderr, "LEVITTE_DEBUG_MEM: | 0x%p -> 0x%p (%d)\n", str, ret, num); #endif if (realloc_debug_func != NULL) realloc_debug_func(str, ret, num, file, line, 1); return ret; } void CRYPTO_free(void *str) { if (free_debug_func != NULL) free_debug_func(str, 0); #ifdef LEVITTE_DEBUG_MEM fprintf(stderr, "LEVITTE_DEBUG_MEM: < 0x%p\n", str); #endif free_func(str); if (free_debug_func != NULL) free_debug_func(NULL, 1); } void *CRYPTO_remalloc(void *a, int num, const char *file, int line) { if (a != NULL) OPENSSL_free(a); a=(char *)OPENSSL_malloc(num); return(a); } void CRYPTO_set_mem_debug_options(long bits) { if (set_debug_options_func != NULL) set_debug_options_func(bits); } long CRYPTO_get_mem_debug_options(void) { if (get_debug_options_func != NULL) return get_debug_options_func(); return 0; }