/*
+ * Copyright 2015-2020 The OpenSSL Project Authors. All Rights Reserved.
* Copyright 2004-2014, Akamai Technologies. All Rights Reserved.
- * This file is distributed under the terms of the OpenSSL license.
+ *
+ * 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
*/
/*
* For details on that implementation, see below (look for uppercase
* "SECURE HEAP IMPLEMENTATION").
*/
+#include "e_os.h"
#include <openssl/crypto.h>
-#include <e_os.h>
-#if defined(OPENSSL_SYS_LINUX) || defined(OPENSSL_SYS_UNIX)
-# define IMPLEMENTED
+#include <string.h>
+
+#ifndef OPENSSL_NO_SECURE_MEMORY
# include <stdlib.h>
-# include <string.h>
# include <assert.h>
# include <unistd.h>
# include <sys/types.h>
# include <sys/mman.h>
-# include <sys/param.h>
+# if defined(OPENSSL_SYS_LINUX)
+# include <sys/syscall.h>
+# if defined(SYS_mlock2)
+# include <linux/mman.h>
+# include <errno.h>
+# endif
+# include <sys/param.h>
+# endif
# include <sys/stat.h>
# include <fcntl.h>
#endif
-#define LOCK() CRYPTO_w_lock(CRYPTO_LOCK_MALLOC)
-#define UNLOCK() CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC)
#define CLEAR(p, s) OPENSSL_cleanse(p, s)
#ifndef PAGE_SIZE
# define PAGE_SIZE 4096
#endif
+#if !defined(MAP_ANON) && defined(MAP_ANONYMOUS)
+# define MAP_ANON MAP_ANONYMOUS
+#endif
-#ifdef IMPLEMENTED
+#ifndef OPENSSL_NO_SECURE_MEMORY
static size_t secure_mem_used;
static int secure_mem_initialized;
-static int too_late;
+
+static CRYPTO_RWLOCK *sec_malloc_lock = NULL;
/*
* These are the functions that must be implemented by a secure heap (sh).
*/
-static int sh_init(size_t size, int minsize);
-static char *sh_malloc(size_t size);
-static void sh_free(char *ptr);
+static int sh_init(size_t size, size_t minsize);
+static void *sh_malloc(size_t size);
+static void sh_free(void *ptr);
static void sh_done(void);
-static int sh_actual_size(char *ptr);
+static size_t sh_actual_size(char *ptr);
static int sh_allocated(const char *ptr);
#endif
-int CRYPTO_secure_malloc_init(size_t size, int minsize)
+int CRYPTO_secure_malloc_init(size_t size, size_t minsize)
{
-#ifdef IMPLEMENTED
+#ifndef OPENSSL_NO_SECURE_MEMORY
int ret = 0;
- if (too_late)
- return ret;
- LOCK();
- OPENSSL_assert(!secure_mem_initialized);
if (!secure_mem_initialized) {
- ret = sh_init(size, minsize);
- secure_mem_initialized = 1;
+ sec_malloc_lock = CRYPTO_THREAD_lock_new();
+ if (sec_malloc_lock == NULL)
+ return 0;
+ if ((ret = sh_init(size, minsize)) != 0) {
+ secure_mem_initialized = 1;
+ } else {
+ CRYPTO_THREAD_lock_free(sec_malloc_lock);
+ sec_malloc_lock = NULL;
+ }
}
- UNLOCK();
+
return ret;
#else
return 0;
-#endif /* IMPLEMENTED */
+#endif /* OPENSSL_NO_SECURE_MEMORY */
}
-void CRYPTO_secure_malloc_done()
+int CRYPTO_secure_malloc_done(void)
{
-#ifdef IMPLEMENTED
- LOCK();
- sh_done();
- secure_mem_initialized = 0;
- UNLOCK();
-#endif /* IMPLEMENTED */
+#ifndef OPENSSL_NO_SECURE_MEMORY
+ if (secure_mem_used == 0) {
+ sh_done();
+ secure_mem_initialized = 0;
+ CRYPTO_THREAD_lock_free(sec_malloc_lock);
+ sec_malloc_lock = NULL;
+ return 1;
+ }
+#endif /* OPENSSL_NO_SECURE_MEMORY */
+ return 0;
}
-int CRYPTO_secure_malloc_initialized()
+int CRYPTO_secure_malloc_initialized(void)
{
-#ifdef IMPLEMENTED
+#ifndef OPENSSL_NO_SECURE_MEMORY
return secure_mem_initialized;
#else
return 0;
-#endif /* IMPLEMENTED */
+#endif /* OPENSSL_NO_SECURE_MEMORY */
}
void *CRYPTO_secure_malloc(size_t num, const char *file, int line)
{
-#ifdef IMPLEMENTED
+#ifndef OPENSSL_NO_SECURE_MEMORY
void *ret;
size_t actual_size;
if (!secure_mem_initialized) {
- too_late = 1;
return CRYPTO_malloc(num, file, line);
}
- LOCK();
+ CRYPTO_THREAD_write_lock(sec_malloc_lock);
ret = sh_malloc(num);
actual_size = ret ? sh_actual_size(ret) : 0;
secure_mem_used += actual_size;
- UNLOCK();
+ CRYPTO_THREAD_unlock(sec_malloc_lock);
return ret;
#else
return CRYPTO_malloc(num, file, line);
-#endif /* IMPLEMENTED */
+#endif /* OPENSSL_NO_SECURE_MEMORY */
+}
+
+void *CRYPTO_secure_zalloc(size_t num, const char *file, int line)
+{
+#ifndef OPENSSL_NO_SECURE_MEMORY
+ if (secure_mem_initialized)
+ /* CRYPTO_secure_malloc() zeroes allocations when it is implemented */
+ return CRYPTO_secure_malloc(num, file, line);
+#endif
+ return CRYPTO_zalloc(num, file, line);
}
-void CRYPTO_secure_free(void *ptr)
+void CRYPTO_secure_free(void *ptr, const char *file, int line)
{
-#ifdef IMPLEMENTED
+#ifndef OPENSSL_NO_SECURE_MEMORY
size_t actual_size;
if (ptr == NULL)
return;
- if (!secure_mem_initialized) {
- CRYPTO_free(ptr);
+ if (!CRYPTO_secure_allocated(ptr)) {
+ CRYPTO_free(ptr, file, line);
return;
}
- LOCK();
+ CRYPTO_THREAD_write_lock(sec_malloc_lock);
actual_size = sh_actual_size(ptr);
CLEAR(ptr, actual_size);
secure_mem_used -= actual_size;
sh_free(ptr);
- UNLOCK();
+ CRYPTO_THREAD_unlock(sec_malloc_lock);
#else
- CRYPTO_free(ptr);
-#endif /* IMPLEMENTED */
+ CRYPTO_free(ptr, file, line);
+#endif /* OPENSSL_NO_SECURE_MEMORY */
+}
+
+void CRYPTO_secure_clear_free(void *ptr, size_t num,
+ const char *file, int line)
+{
+#ifndef OPENSSL_NO_SECURE_MEMORY
+ size_t actual_size;
+
+ if (ptr == NULL)
+ return;
+ if (!CRYPTO_secure_allocated(ptr)) {
+ OPENSSL_cleanse(ptr, num);
+ CRYPTO_free(ptr, file, line);
+ return;
+ }
+ CRYPTO_THREAD_write_lock(sec_malloc_lock);
+ actual_size = sh_actual_size(ptr);
+ CLEAR(ptr, actual_size);
+ secure_mem_used -= actual_size;
+ sh_free(ptr);
+ CRYPTO_THREAD_unlock(sec_malloc_lock);
+#else
+ if (ptr == NULL)
+ return;
+ OPENSSL_cleanse(ptr, num);
+ CRYPTO_free(ptr, file, line);
+#endif /* OPENSSL_NO_SECURE_MEMORY */
}
int CRYPTO_secure_allocated(const void *ptr)
{
-#ifdef IMPLEMENTED
+#ifndef OPENSSL_NO_SECURE_MEMORY
int ret;
if (!secure_mem_initialized)
return 0;
- LOCK();
+ CRYPTO_THREAD_write_lock(sec_malloc_lock);
ret = sh_allocated(ptr);
- UNLOCK();
+ CRYPTO_THREAD_unlock(sec_malloc_lock);
return ret;
#else
return 0;
-#endif /* IMPLEMENTED */
+#endif /* OPENSSL_NO_SECURE_MEMORY */
+}
+
+size_t CRYPTO_secure_used(void)
+{
+#ifndef OPENSSL_NO_SECURE_MEMORY
+ return secure_mem_used;
+#else
+ return 0;
+#endif /* OPENSSL_NO_SECURE_MEMORY */
}
-/* END OF PAGE ...
+size_t CRYPTO_secure_actual_size(void *ptr)
+{
+#ifndef OPENSSL_NO_SECURE_MEMORY
+ size_t actual_size;
- ... START OF PAGE */
+ CRYPTO_THREAD_write_lock(sec_malloc_lock);
+ actual_size = sh_actual_size(ptr);
+ CRYPTO_THREAD_unlock(sec_malloc_lock);
+ return actual_size;
+#else
+ return 0;
+#endif
+}
/*
* SECURE HEAP IMPLEMENTATION
*/
-#ifdef IMPLEMENTED
+#ifndef OPENSSL_NO_SECURE_MEMORY
/*
* place.
*/
-# define TESTBIT(t, b) (t[(b) >> 3] & (1 << ((b) & 7)))
-# define SETBIT(t, b) (t[(b) >> 3] |= (1 << ((b) & 7)))
-# define CLEARBIT(t, b) (t[(b) >> 3] &= (0xFF & ~(1 << ((b) & 7))))
+#define ONE ((size_t)1)
+
+# define TESTBIT(t, b) (t[(b) >> 3] & (ONE << ((b) & 7)))
+# define SETBIT(t, b) (t[(b) >> 3] |= (ONE << ((b) & 7)))
+# define CLEARBIT(t, b) (t[(b) >> 3] &= (0xFF & ~(ONE << ((b) & 7))))
#define WITHIN_ARENA(p) \
((char*)(p) >= sh.arena && (char*)(p) < &sh.arena[sh.arena_size])
char* map_result;
size_t map_size;
char *arena;
- int arena_size;
+ size_t arena_size;
char **freelist;
- int freelist_size;
- int minsize;
+ ossl_ssize_t freelist_size;
+ size_t minsize;
unsigned char *bittable;
unsigned char *bitmalloc;
- int bittable_size; /* size in bits */
+ size_t bittable_size; /* size in bits */
} SH;
static SH sh;
-static int sh_getlist(char *ptr)
+static size_t sh_getlist(char *ptr)
{
- int list = sh.freelist_size - 1;
- int bit = (sh.arena_size + ptr - sh.arena) / sh.minsize;
+ ossl_ssize_t list = sh.freelist_size - 1;
+ size_t bit = (sh.arena_size + ptr - sh.arena) / sh.minsize;
for (; bit; bit >>= 1, list--) {
if (TESTBIT(sh.bittable, bit))
static int sh_testbit(char *ptr, int list, unsigned char *table)
{
- int bit;
+ size_t bit;
OPENSSL_assert(list >= 0 && list < sh.freelist_size);
OPENSSL_assert(((ptr - sh.arena) & ((sh.arena_size >> list) - 1)) == 0);
- bit = (1 << list) + ((ptr - sh.arena) / (sh.arena_size >> list));
+ bit = (ONE << list) + ((ptr - sh.arena) / (sh.arena_size >> list));
OPENSSL_assert(bit > 0 && bit < sh.bittable_size);
return TESTBIT(table, bit);
}
static void sh_clearbit(char *ptr, int list, unsigned char *table)
{
- int bit;
+ size_t bit;
OPENSSL_assert(list >= 0 && list < sh.freelist_size);
OPENSSL_assert(((ptr - sh.arena) & ((sh.arena_size >> list) - 1)) == 0);
- bit = (1 << list) + ((ptr - sh.arena) / (sh.arena_size >> list));
+ bit = (ONE << list) + ((ptr - sh.arena) / (sh.arena_size >> list));
OPENSSL_assert(bit > 0 && bit < sh.bittable_size);
OPENSSL_assert(TESTBIT(table, bit));
CLEARBIT(table, bit);
static void sh_setbit(char *ptr, int list, unsigned char *table)
{
- int bit;
+ size_t bit;
OPENSSL_assert(list >= 0 && list < sh.freelist_size);
OPENSSL_assert(((ptr - sh.arena) & ((sh.arena_size >> list) - 1)) == 0);
- bit = (1 << list) + ((ptr - sh.arena) / (sh.arena_size >> list));
+ bit = (ONE << list) + ((ptr - sh.arena) / (sh.arena_size >> list));
OPENSSL_assert(bit > 0 && bit < sh.bittable_size);
OPENSSL_assert(!TESTBIT(table, bit));
SETBIT(table, bit);
*list = ptr;
}
-static void sh_remove_from_list(char *ptr, char *list)
+static void sh_remove_from_list(char *ptr)
{
SH_LIST *temp, *temp2;
}
-static int sh_init(size_t size, int minsize)
+static int sh_init(size_t size, size_t minsize)
{
- int i, ret;
+ int ret;
+ size_t i;
size_t pgsize;
size_t aligned;
- memset(&sh, 0, sizeof sh);
+ memset(&sh, 0, sizeof(sh));
- /* make sure size and minsize are powers of 2 */
+ /* make sure size is a powers of 2 */
OPENSSL_assert(size > 0);
OPENSSL_assert((size & (size - 1)) == 0);
- OPENSSL_assert(minsize > 0);
- OPENSSL_assert((minsize & (minsize - 1)) == 0);
- if (size <= 0 || (size & (size - 1)) != 0)
- goto err;
- if (minsize <= 0 || (minsize & (minsize - 1)) != 0)
+ if (size == 0 || (size & (size - 1)) != 0)
goto err;
+ if (minsize <= sizeof(SH_LIST)) {
+ OPENSSL_assert(sizeof(SH_LIST) <= 65536);
+ /*
+ * Compute the minimum possible allocation size.
+ * This must be a power of 2 and at least as large as the SH_LIST
+ * structure.
+ */
+ minsize = sizeof(SH_LIST) - 1;
+ minsize |= minsize >> 1;
+ minsize |= minsize >> 2;
+ if (sizeof(SH_LIST) > 16)
+ minsize |= minsize >> 4;
+ if (sizeof(SH_LIST) > 256)
+ minsize |= minsize >> 8;
+ minsize++;
+ } else {
+ /* make sure minsize is a powers of 2 */
+ OPENSSL_assert((minsize & (minsize - 1)) == 0);
+ if ((minsize & (minsize - 1)) != 0)
+ goto err;
+ }
+
sh.arena_size = size;
sh.minsize = minsize;
sh.bittable_size = (sh.arena_size / sh.minsize) * 2;
+ /* Prevent allocations of size 0 later on */
+ if (sh.bittable_size >> 3 == 0)
+ goto err;
+
sh.freelist_size = -1;
for (i = sh.bittable_size; i; i >>= 1)
sh.freelist_size++;
- sh.freelist = OPENSSL_zalloc(sh.freelist_size * sizeof (char *));
+ sh.freelist = OPENSSL_zalloc(sh.freelist_size * sizeof(char *));
OPENSSL_assert(sh.freelist != NULL);
if (sh.freelist == NULL)
goto err;
pgsize = PAGE_SIZE;
#endif
sh.map_size = pgsize + sh.arena_size + pgsize;
- if (1) {
+
#ifdef MAP_ANON
- sh.map_result = mmap(NULL, sh.map_size,
- PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0);
- } else {
-#endif
+ sh.map_result = mmap(NULL, sh.map_size,
+ PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0);
+#else
+ {
int fd;
sh.map_result = MAP_FAILED;
close(fd);
}
}
- OPENSSL_assert(sh.map_result != MAP_FAILED);
+#endif
if (sh.map_result == MAP_FAILED)
goto err;
sh.arena = (char *)(sh.map_result + pgsize);
if (mprotect(sh.map_result + aligned, pgsize, PROT_NONE) < 0)
ret = 2;
+#if defined(OPENSSL_SYS_LINUX) && defined(MLOCK_ONFAULT) && defined(SYS_mlock2)
+ if (syscall(SYS_mlock2, sh.arena, sh.arena_size, MLOCK_ONFAULT) < 0) {
+ if (errno == ENOSYS) {
+ if (mlock(sh.arena, sh.arena_size) < 0)
+ ret = 2;
+ } else {
+ ret = 2;
+ }
+ }
+#else
if (mlock(sh.arena, sh.arena_size) < 0)
ret = 2;
+#endif
#ifdef MADV_DONTDUMP
if (madvise(sh.arena, sh.arena_size, MADV_DONTDUMP) < 0)
ret = 2;
return 0;
}
-static void sh_done()
+static void sh_done(void)
{
OPENSSL_free(sh.freelist);
OPENSSL_free(sh.bittable);
OPENSSL_free(sh.bitmalloc);
if (sh.map_result != NULL && sh.map_size)
munmap(sh.map_result, sh.map_size);
- memset(&sh, 0, sizeof sh);
+ memset(&sh, 0, sizeof(sh));
}
static int sh_allocated(const char *ptr)
static char *sh_find_my_buddy(char *ptr, int list)
{
- int bit;
+ size_t bit;
char *chunk = NULL;
- bit = (1 << list) + (ptr - sh.arena) / (sh.arena_size >> list);
+ bit = (ONE << list) + (ptr - sh.arena) / (sh.arena_size >> list);
bit ^= 1;
if (TESTBIT(sh.bittable, bit) && !TESTBIT(sh.bitmalloc, bit))
- chunk = sh.arena + ((bit & ((1 << list) - 1)) * (sh.arena_size >> list));
+ chunk = sh.arena + ((bit & ((ONE << list) - 1)) * (sh.arena_size >> list));
return chunk;
}
-static char *sh_malloc(size_t size)
+static void *sh_malloc(size_t size)
{
- int list, slist;
+ ossl_ssize_t list, slist;
size_t i;
char *chunk;
+ if (size > sh.arena_size)
+ return NULL;
+
list = sh.freelist_size - 1;
for (i = sh.minsize; i < size; i <<= 1)
list--;
/* remove from bigger list */
OPENSSL_assert(!sh_testbit(temp, slist, sh.bitmalloc));
sh_clearbit(temp, slist, sh.bittable);
- sh_remove_from_list(temp, sh.freelist[slist]);
+ sh_remove_from_list(temp);
OPENSSL_assert(temp != sh.freelist[slist]);
/* done with bigger list */
chunk = sh.freelist[list];
OPENSSL_assert(sh_testbit(chunk, list, sh.bittable));
sh_setbit(chunk, list, sh.bitmalloc);
- sh_remove_from_list(chunk, sh.freelist[list]);
+ sh_remove_from_list(chunk);
OPENSSL_assert(WITHIN_ARENA(chunk));
+ /* zero the free list header as a precaution against information leakage */
+ memset(chunk, 0, sizeof(SH_LIST));
+
return chunk;
}
-static void sh_free(char *ptr)
+static void sh_free(void *ptr)
{
- int list;
- char *buddy;
+ size_t list;
+ void *buddy;
if (ptr == NULL)
return;
OPENSSL_assert(ptr != NULL);
OPENSSL_assert(!sh_testbit(ptr, list, sh.bitmalloc));
sh_clearbit(ptr, list, sh.bittable);
- sh_remove_from_list(ptr, sh.freelist[list]);
+ sh_remove_from_list(ptr);
OPENSSL_assert(!sh_testbit(ptr, list, sh.bitmalloc));
sh_clearbit(buddy, list, sh.bittable);
- sh_remove_from_list(buddy, sh.freelist[list]);
+ sh_remove_from_list(buddy);
list--;
+ /* Zero the higher addressed block's free list pointers */
+ memset(ptr > buddy ? ptr : buddy, 0, sizeof(SH_LIST));
if (ptr > buddy)
ptr = buddy;
}
}
-static int sh_actual_size(char *ptr)
+static size_t sh_actual_size(char *ptr)
{
int list;
return 0;
list = sh_getlist(ptr);
OPENSSL_assert(sh_testbit(ptr, list, sh.bittable));
- return sh.arena_size / (1 << list);
+ return sh.arena_size / (ONE << list);
}
-#endif /* IMPLEMENTED */
+#endif /* OPENSSL_NO_SECURE_MEMORY */