2016-05-18 02:51:04 +08:00
|
|
|
/*
|
2018-01-19 17:49:22 +08:00
|
|
|
* Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
|
2017-06-16 00:03:40 +08:00
|
|
|
* Copyright 2004-2014, Akamai Technologies. All Rights Reserved.
|
2016-05-18 02:51:04 +08:00
|
|
|
*
|
2018-12-06 21:03:01 +08:00
|
|
|
* Licensed under the Apache License 2.0 (the "License"). You may not use
|
2016-05-18 02:51:04 +08:00
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2015-04-25 04:39:40 +08:00
|
|
|
/*
|
|
|
|
* This file is in two halves. The first half implements the public API
|
|
|
|
* to be used by external consumers, and to be used by OpenSSL to store
|
|
|
|
* data in a "secure arena." The second half implements the secure arena.
|
|
|
|
* For details on that implementation, see below (look for uppercase
|
|
|
|
* "SECURE HEAP IMPLEMENTATION").
|
|
|
|
*/
|
2017-08-22 23:07:56 +08:00
|
|
|
#include "e_os.h"
|
2017-08-24 07:05:07 +08:00
|
|
|
#include <openssl/crypto.h>
|
2015-04-25 04:39:40 +08:00
|
|
|
|
2016-02-10 10:54:45 +08:00
|
|
|
#include <string.h>
|
|
|
|
|
2018-10-05 07:05:54 +08:00
|
|
|
/* e_os.h defines OPENSSL_SECURE_MEMORY if secure memory can be implemented */
|
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2015-06-24 06:33:02 +08:00
|
|
|
# include <stdlib.h>
|
|
|
|
# include <assert.h>
|
|
|
|
# include <unistd.h>
|
2015-11-14 04:30:44 +08:00
|
|
|
# include <sys/types.h>
|
2015-04-25 04:39:40 +08:00
|
|
|
# include <sys/mman.h>
|
2017-03-24 00:56:22 +08:00
|
|
|
# if defined(OPENSSL_SYS_LINUX)
|
|
|
|
# include <sys/syscall.h>
|
2018-03-11 02:38:28 +08:00
|
|
|
# if defined(SYS_mlock2)
|
|
|
|
# include <linux/mman.h>
|
|
|
|
# include <errno.h>
|
|
|
|
# endif
|
2017-03-24 00:56:22 +08:00
|
|
|
# endif
|
2015-04-25 04:39:40 +08:00
|
|
|
# include <sys/param.h>
|
2015-11-14 04:30:44 +08:00
|
|
|
# include <sys/stat.h>
|
|
|
|
# include <fcntl.h>
|
2015-04-25 04:39:40 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#define CLEAR(p, s) OPENSSL_cleanse(p, s)
|
2015-07-31 16:49:20 +08:00
|
|
|
#ifndef PAGE_SIZE
|
|
|
|
# define PAGE_SIZE 4096
|
|
|
|
#endif
|
2018-03-02 23:50:11 +08:00
|
|
|
#if !defined(MAP_ANON) && defined(MAP_ANONYMOUS)
|
|
|
|
# define MAP_ANON MAP_ANONYMOUS
|
|
|
|
#endif
|
2015-04-25 04:39:40 +08:00
|
|
|
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2015-09-05 20:32:58 +08:00
|
|
|
static size_t secure_mem_used;
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
static int secure_mem_initialized;
|
|
|
|
|
2016-03-08 23:44:05 +08:00
|
|
|
static CRYPTO_RWLOCK *sec_malloc_lock = NULL;
|
|
|
|
|
2015-04-25 04:39:40 +08:00
|
|
|
/*
|
|
|
|
* These are the functions that must be implemented by a secure heap (sh).
|
|
|
|
*/
|
|
|
|
static int sh_init(size_t size, int minsize);
|
2017-03-03 08:16:57 +08:00
|
|
|
static void *sh_malloc(size_t size);
|
|
|
|
static void sh_free(void *ptr);
|
2015-04-25 04:39:40 +08:00
|
|
|
static void sh_done(void);
|
2016-04-12 04:03:42 +08:00
|
|
|
static size_t sh_actual_size(char *ptr);
|
2015-04-25 04:39:40 +08:00
|
|
|
static int sh_allocated(const char *ptr);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
int CRYPTO_secure_malloc_init(size_t size, int minsize)
|
|
|
|
{
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2015-04-25 04:39:40 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!secure_mem_initialized) {
|
Revert the crypto "global lock" implementation
Conceptually, this is a squashed version of:
Revert "Address feedback"
This reverts commit 75551e07bd2339dfea06ef1d31d69929e13a4495.
and
Revert "Add CRYPTO_thread_glock_new"
This reverts commit ed6b2c7938ec6f07b15745d4183afc276e74c6dd.
But there were some intervening commits that made neither revert apply
cleanly, so instead do it all as one shot.
The crypto global locks were an attempt to cope with the awkward
POSIX semantics for pthread_atfork(); its documentation (the "RATIONALE"
section) indicates that the expected usage is to have the prefork handler
lock all "global" locks, and the parent and child handlers release those
locks, to ensure that forking happens with a consistent (lock) state.
However, the set of functions available in the child process is limited
to async-signal-safe functions, and pthread_mutex_unlock() is not on
the list of async-signal-safe functions! The only synchronization
primitives that are async-signal-safe are the semaphore primitives,
which are not really appropriate for general-purpose usage.
However, the state consistency problem that the global locks were
attempting to solve is not actually a serious problem, particularly for
OpenSSL. That is, we can consider four cases of forking application
that might use OpenSSL:
(1) Single-threaded, does not call into OpenSSL in the child (e.g.,
the child calls exec() immediately)
For this class of process, no locking is needed at all, since there is
only ever a single thread of execution and the only reentrancy is due to
signal handlers (which are themselves limited to async-signal-safe
operation and should not be doing much work at all).
(2) Single-threaded, calls into OpenSSL after fork()
The application must ensure that it does not fork() with an unexpected
lock held (that is, one that would get unlocked in the parent but
accidentally remain locked in the child and cause deadlock). Since
OpenSSL does not expose any of its internal locks to the application
and the application is single-threaded, the OpenSSL internal locks
will be unlocked for the fork(), and the state will be consistent.
(OpenSSL will need to reseed its PRNG in the child, but that is
an orthogonal issue.) If the application makes use of locks from
libcrypto, proper handling for those locks is the responsibility of
the application, as for any other locking primitive that is available
for application programming.
(3) Multi-threaded, does not call into OpenSSL after fork()
As for (1), the OpenSSL state is only relevant in the parent, so
no particular fork()-related handling is needed. The internal locks
are relevant, but there is no interaction with the child to consider.
(4) Multi-threaded, calls into OpenSSL after fork()
This is the case where the pthread_atfork() hooks to ensure that all
global locks are in a known state across fork() would come into play,
per the above discussion. However, these "calls into OpenSSL after
fork()" are still subject to the restriction to async-signal-safe
functions. Since OpenSSL uses all sorts of locking and libc functions
that are not on the list of safe functions (e.g., malloc()), this
case is not currently usable and is unlikely to ever be usable,
independently of the locking situation. So, there is no need to
go through contortions to attempt to support this case in the one small
area of locking interaction with fork().
In light of the above analysis (thanks @davidben and @achernya), go
back to the simpler implementation that does not need to distinguish
"library-global" locks or to have complicated atfork handling for locks.
Reviewed-by: Kurt Roeckx <kurt@roeckx.be>
Reviewed-by: Matthias St. Pierre <Matthias.St.Pierre@ncp-e.com>
(Merged from https://github.com/openssl/openssl/pull/5089)
2018-01-16 23:49:54 +08:00
|
|
|
sec_malloc_lock = CRYPTO_THREAD_lock_new();
|
2016-03-08 23:44:05 +08:00
|
|
|
if (sec_malloc_lock == NULL)
|
|
|
|
return 0;
|
Fix infinite loops in secure memory allocation.
Issue 1:
sh.bittable_size is a size_t but i is and int, which can result in
freelist == -1 if sh.bittable_size exceeds an int.
This seems to result in an OPENSSL_assert due to invalid allocation
size, so maybe that is "ok."
Worse, if sh.bittable_size is exactly 1<<31, then this becomes an
infinite loop (because 1<<31 is a negative int, so it can be shifted
right forever and sticks at -1).
Issue 2:
CRYPTO_secure_malloc_init() sets secure_mem_initialized=1 even when
sh_init() returns 0.
If sh_init() fails, we end up with secure_mem_initialized=1 but
sh.minsize=0. If you then call secure_malloc(), which then calls,
sh_malloc(), this then enters an infite loop since 0 << anything will
never be larger than size.
Issue 3:
That same sh_malloc loop will loop forever for a size greater
than size_t/2 because i will proceed (assuming sh.minsize=16):
i=16, 32, 64, ..., size_t/8, size_t/4, size_t/2, 0, 0, 0, 0, ....
This sequence will never be larger than "size".
Reviewed-by: Rich Salz <rsalz@openssl.org>
Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3449)
2017-05-12 03:48:10 +08:00
|
|
|
if ((ret = sh_init(size, minsize)) != 0) {
|
|
|
|
secure_mem_initialized = 1;
|
|
|
|
} else {
|
|
|
|
CRYPTO_THREAD_lock_free(sec_malloc_lock);
|
|
|
|
sec_malloc_lock = NULL;
|
|
|
|
}
|
2015-04-25 04:39:40 +08:00
|
|
|
}
|
2016-03-08 23:44:05 +08:00
|
|
|
|
2015-04-25 04:39:40 +08:00
|
|
|
return ret;
|
|
|
|
#else
|
|
|
|
return 0;
|
2018-10-05 07:05:54 +08:00
|
|
|
#endif /* OPENSSL_SECURE_MEMORY */
|
2015-04-25 04:39:40 +08:00
|
|
|
}
|
|
|
|
|
2018-05-09 23:09:50 +08:00
|
|
|
int CRYPTO_secure_malloc_done(void)
|
2015-04-25 04:39:40 +08:00
|
|
|
{
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2016-04-12 04:03:42 +08:00
|
|
|
if (secure_mem_used == 0) {
|
|
|
|
sh_done();
|
|
|
|
secure_mem_initialized = 0;
|
|
|
|
CRYPTO_THREAD_lock_free(sec_malloc_lock);
|
Fix infinite loops in secure memory allocation.
Issue 1:
sh.bittable_size is a size_t but i is and int, which can result in
freelist == -1 if sh.bittable_size exceeds an int.
This seems to result in an OPENSSL_assert due to invalid allocation
size, so maybe that is "ok."
Worse, if sh.bittable_size is exactly 1<<31, then this becomes an
infinite loop (because 1<<31 is a negative int, so it can be shifted
right forever and sticks at -1).
Issue 2:
CRYPTO_secure_malloc_init() sets secure_mem_initialized=1 even when
sh_init() returns 0.
If sh_init() fails, we end up with secure_mem_initialized=1 but
sh.minsize=0. If you then call secure_malloc(), which then calls,
sh_malloc(), this then enters an infite loop since 0 << anything will
never be larger than size.
Issue 3:
That same sh_malloc loop will loop forever for a size greater
than size_t/2 because i will proceed (assuming sh.minsize=16):
i=16, 32, 64, ..., size_t/8, size_t/4, size_t/2, 0, 0, 0, 0, ....
This sequence will never be larger than "size".
Reviewed-by: Rich Salz <rsalz@openssl.org>
Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3449)
2017-05-12 03:48:10 +08:00
|
|
|
sec_malloc_lock = NULL;
|
2016-04-12 04:03:42 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2018-10-05 07:05:54 +08:00
|
|
|
#endif /* OPENSSL_SECURE_MEMORY */
|
2016-04-12 04:03:42 +08:00
|
|
|
return 0;
|
2015-04-25 04:39:40 +08:00
|
|
|
}
|
|
|
|
|
2018-05-09 23:09:50 +08:00
|
|
|
int CRYPTO_secure_malloc_initialized(void)
|
2015-04-25 04:39:40 +08:00
|
|
|
{
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2015-04-25 04:39:40 +08:00
|
|
|
return secure_mem_initialized;
|
|
|
|
#else
|
|
|
|
return 0;
|
2018-10-05 07:05:54 +08:00
|
|
|
#endif /* OPENSSL_SECURE_MEMORY */
|
2015-04-25 04:39:40 +08:00
|
|
|
}
|
|
|
|
|
2015-12-17 15:24:26 +08:00
|
|
|
void *CRYPTO_secure_malloc(size_t num, const char *file, int line)
|
2015-04-25 04:39:40 +08:00
|
|
|
{
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2015-04-25 04:39:40 +08:00
|
|
|
void *ret;
|
|
|
|
size_t actual_size;
|
|
|
|
|
|
|
|
if (!secure_mem_initialized) {
|
|
|
|
return CRYPTO_malloc(num, file, line);
|
|
|
|
}
|
2016-03-08 23:44:05 +08:00
|
|
|
CRYPTO_THREAD_write_lock(sec_malloc_lock);
|
2015-04-25 04:39:40 +08:00
|
|
|
ret = sh_malloc(num);
|
|
|
|
actual_size = ret ? sh_actual_size(ret) : 0;
|
|
|
|
secure_mem_used += actual_size;
|
2016-03-08 23:44:05 +08:00
|
|
|
CRYPTO_THREAD_unlock(sec_malloc_lock);
|
2015-04-25 04:39:40 +08:00
|
|
|
return ret;
|
|
|
|
#else
|
|
|
|
return CRYPTO_malloc(num, file, line);
|
2018-10-05 07:05:54 +08:00
|
|
|
#endif /* OPENSSL_SECURE_MEMORY */
|
2015-04-25 04:39:40 +08:00
|
|
|
}
|
|
|
|
|
2016-01-28 12:16:47 +08:00
|
|
|
void *CRYPTO_secure_zalloc(size_t num, const char *file, int line)
|
|
|
|
{
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2018-08-22 07:20:18 +08:00
|
|
|
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);
|
2016-01-28 12:16:47 +08:00
|
|
|
}
|
|
|
|
|
2016-02-17 09:24:25 +08:00
|
|
|
void CRYPTO_secure_free(void *ptr, const char *file, int line)
|
2015-04-25 04:39:40 +08:00
|
|
|
{
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2015-04-25 04:39:40 +08:00
|
|
|
size_t actual_size;
|
|
|
|
|
|
|
|
if (ptr == NULL)
|
|
|
|
return;
|
2016-04-12 04:03:42 +08:00
|
|
|
if (!CRYPTO_secure_allocated(ptr)) {
|
2016-02-17 09:24:25 +08:00
|
|
|
CRYPTO_free(ptr, file, line);
|
2015-04-25 04:39:40 +08:00
|
|
|
return;
|
|
|
|
}
|
2016-03-08 23:44:05 +08:00
|
|
|
CRYPTO_THREAD_write_lock(sec_malloc_lock);
|
2015-04-25 04:39:40 +08:00
|
|
|
actual_size = sh_actual_size(ptr);
|
|
|
|
CLEAR(ptr, actual_size);
|
|
|
|
secure_mem_used -= actual_size;
|
|
|
|
sh_free(ptr);
|
2016-03-08 23:44:05 +08:00
|
|
|
CRYPTO_THREAD_unlock(sec_malloc_lock);
|
2015-04-25 04:39:40 +08:00
|
|
|
#else
|
2016-02-17 21:41:26 +08:00
|
|
|
CRYPTO_free(ptr, file, line);
|
2018-10-05 07:05:54 +08:00
|
|
|
#endif /* OPENSSL_SECURE_MEMORY */
|
2015-04-25 04:39:40 +08:00
|
|
|
}
|
|
|
|
|
2017-07-29 03:24:02 +08:00
|
|
|
void CRYPTO_secure_clear_free(void *ptr, size_t num,
|
|
|
|
const char *file, int line)
|
|
|
|
{
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2017-07-29 03:24:02 +08:00
|
|
|
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);
|
2018-10-05 07:05:54 +08:00
|
|
|
#endif /* OPENSSL_SECURE_MEMORY */
|
2017-07-29 03:24:02 +08:00
|
|
|
}
|
|
|
|
|
2015-04-25 04:39:40 +08:00
|
|
|
int CRYPTO_secure_allocated(const void *ptr)
|
|
|
|
{
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2015-04-25 04:39:40 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!secure_mem_initialized)
|
|
|
|
return 0;
|
2016-03-08 23:44:05 +08:00
|
|
|
CRYPTO_THREAD_write_lock(sec_malloc_lock);
|
2015-04-25 04:39:40 +08:00
|
|
|
ret = sh_allocated(ptr);
|
2016-03-08 23:44:05 +08:00
|
|
|
CRYPTO_THREAD_unlock(sec_malloc_lock);
|
2015-04-25 04:39:40 +08:00
|
|
|
return ret;
|
|
|
|
#else
|
|
|
|
return 0;
|
2018-10-05 07:05:54 +08:00
|
|
|
#endif /* OPENSSL_SECURE_MEMORY */
|
2015-04-25 04:39:40 +08:00
|
|
|
}
|
|
|
|
|
2018-05-09 23:09:50 +08:00
|
|
|
size_t CRYPTO_secure_used(void)
|
2016-01-08 04:06:38 +08:00
|
|
|
{
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2016-01-08 04:06:38 +08:00
|
|
|
return secure_mem_used;
|
|
|
|
#else
|
|
|
|
return 0;
|
2018-10-05 07:05:54 +08:00
|
|
|
#endif /* OPENSSL_SECURE_MEMORY */
|
2016-01-08 04:06:38 +08:00
|
|
|
}
|
|
|
|
|
2016-01-08 05:05:45 +08:00
|
|
|
size_t CRYPTO_secure_actual_size(void *ptr)
|
|
|
|
{
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2016-01-08 05:05:45 +08:00
|
|
|
size_t actual_size;
|
|
|
|
|
2016-03-08 23:44:05 +08:00
|
|
|
CRYPTO_THREAD_write_lock(sec_malloc_lock);
|
2016-01-08 05:05:45 +08:00
|
|
|
actual_size = sh_actual_size(ptr);
|
2016-03-08 23:44:05 +08:00
|
|
|
CRYPTO_THREAD_unlock(sec_malloc_lock);
|
2016-01-08 05:05:45 +08:00
|
|
|
return actual_size;
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
2015-04-25 04:39:40 +08:00
|
|
|
/* END OF PAGE ...
|
|
|
|
|
|
|
|
... START OF PAGE */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SECURE HEAP IMPLEMENTATION
|
|
|
|
*/
|
2018-10-05 07:05:54 +08:00
|
|
|
#ifdef OPENSSL_SECURE_MEMORY
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The implementation provided here uses a fixed-sized mmap() heap,
|
|
|
|
* which is locked into memory, not written to core files, and protected
|
|
|
|
* on either side by an unmapped page, which will catch pointer overruns
|
|
|
|
* (or underruns) and an attempt to read data out of the secure heap.
|
|
|
|
* Free'd memory is zero'd or otherwise cleansed.
|
|
|
|
*
|
|
|
|
* This is a pretty standard buddy allocator. We keep areas in a multiple
|
|
|
|
* of "sh.minsize" units. The freelist and bitmaps are kept separately,
|
|
|
|
* so all (and only) data is kept in the mmap'd heap.
|
|
|
|
*
|
|
|
|
* This code assumes eight-bit bytes. The numbers 3 and 7 are all over the
|
|
|
|
* place.
|
|
|
|
*/
|
|
|
|
|
2016-04-12 04:03:42 +08:00
|
|
|
#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))))
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
#define WITHIN_ARENA(p) \
|
|
|
|
((char*)(p) >= sh.arena && (char*)(p) < &sh.arena[sh.arena_size])
|
|
|
|
#define WITHIN_FREELIST(p) \
|
|
|
|
((char*)(p) >= (char*)sh.freelist && (char*)(p) < (char*)&sh.freelist[sh.freelist_size])
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct sh_list_st
|
|
|
|
{
|
|
|
|
struct sh_list_st *next;
|
|
|
|
struct sh_list_st **p_next;
|
|
|
|
} SH_LIST;
|
|
|
|
|
|
|
|
typedef struct sh_st
|
|
|
|
{
|
|
|
|
char* map_result;
|
|
|
|
size_t map_size;
|
|
|
|
char *arena;
|
2016-04-12 04:03:42 +08:00
|
|
|
size_t arena_size;
|
2015-04-25 04:39:40 +08:00
|
|
|
char **freelist;
|
2016-04-12 04:03:42 +08:00
|
|
|
ossl_ssize_t freelist_size;
|
|
|
|
size_t minsize;
|
2015-04-25 04:39:40 +08:00
|
|
|
unsigned char *bittable;
|
|
|
|
unsigned char *bitmalloc;
|
2016-04-12 04:03:42 +08:00
|
|
|
size_t bittable_size; /* size in bits */
|
2015-04-25 04:39:40 +08:00
|
|
|
} SH;
|
|
|
|
|
|
|
|
static SH sh;
|
|
|
|
|
2016-04-12 04:03:42 +08:00
|
|
|
static size_t sh_getlist(char *ptr)
|
2015-04-25 04:39:40 +08:00
|
|
|
{
|
2016-04-12 04:03:42 +08:00
|
|
|
ossl_ssize_t list = sh.freelist_size - 1;
|
|
|
|
size_t bit = (sh.arena_size + ptr - sh.arena) / sh.minsize;
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
for (; bit; bit >>= 1, list--) {
|
|
|
|
if (TESTBIT(sh.bittable, bit))
|
|
|
|
break;
|
|
|
|
OPENSSL_assert((bit & 1) == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int sh_testbit(char *ptr, int list, unsigned char *table)
|
|
|
|
{
|
2016-04-12 04:03:42 +08:00
|
|
|
size_t bit;
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
OPENSSL_assert(list >= 0 && list < sh.freelist_size);
|
|
|
|
OPENSSL_assert(((ptr - sh.arena) & ((sh.arena_size >> list) - 1)) == 0);
|
2016-04-12 04:03:42 +08:00
|
|
|
bit = (ONE << list) + ((ptr - sh.arena) / (sh.arena_size >> list));
|
2015-04-25 04:39:40 +08:00
|
|
|
OPENSSL_assert(bit > 0 && bit < sh.bittable_size);
|
|
|
|
return TESTBIT(table, bit);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_clearbit(char *ptr, int list, unsigned char *table)
|
|
|
|
{
|
2016-04-12 04:03:42 +08:00
|
|
|
size_t bit;
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
OPENSSL_assert(list >= 0 && list < sh.freelist_size);
|
|
|
|
OPENSSL_assert(((ptr - sh.arena) & ((sh.arena_size >> list) - 1)) == 0);
|
2016-04-12 04:03:42 +08:00
|
|
|
bit = (ONE << list) + ((ptr - sh.arena) / (sh.arena_size >> list));
|
2015-04-25 04:39:40 +08:00
|
|
|
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)
|
|
|
|
{
|
2016-04-12 04:03:42 +08:00
|
|
|
size_t bit;
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
OPENSSL_assert(list >= 0 && list < sh.freelist_size);
|
|
|
|
OPENSSL_assert(((ptr - sh.arena) & ((sh.arena_size >> list) - 1)) == 0);
|
2016-04-12 04:03:42 +08:00
|
|
|
bit = (ONE << list) + ((ptr - sh.arena) / (sh.arena_size >> list));
|
2015-04-25 04:39:40 +08:00
|
|
|
OPENSSL_assert(bit > 0 && bit < sh.bittable_size);
|
|
|
|
OPENSSL_assert(!TESTBIT(table, bit));
|
|
|
|
SETBIT(table, bit);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_add_to_list(char **list, char *ptr)
|
|
|
|
{
|
|
|
|
SH_LIST *temp;
|
|
|
|
|
|
|
|
OPENSSL_assert(WITHIN_FREELIST(list));
|
|
|
|
OPENSSL_assert(WITHIN_ARENA(ptr));
|
|
|
|
|
|
|
|
temp = (SH_LIST *)ptr;
|
|
|
|
temp->next = *(SH_LIST **)list;
|
|
|
|
OPENSSL_assert(temp->next == NULL || WITHIN_ARENA(temp->next));
|
|
|
|
temp->p_next = (SH_LIST **)list;
|
|
|
|
|
|
|
|
if (temp->next != NULL) {
|
|
|
|
OPENSSL_assert((char **)temp->next->p_next == list);
|
|
|
|
temp->next->p_next = &(temp->next);
|
|
|
|
}
|
|
|
|
|
|
|
|
*list = ptr;
|
|
|
|
}
|
|
|
|
|
2016-02-14 11:33:56 +08:00
|
|
|
static void sh_remove_from_list(char *ptr)
|
2015-04-25 04:39:40 +08:00
|
|
|
{
|
|
|
|
SH_LIST *temp, *temp2;
|
|
|
|
|
|
|
|
temp = (SH_LIST *)ptr;
|
|
|
|
if (temp->next != NULL)
|
|
|
|
temp->next->p_next = temp->p_next;
|
|
|
|
*temp->p_next = temp->next;
|
|
|
|
if (temp->next == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
temp2 = temp->next;
|
|
|
|
OPENSSL_assert(WITHIN_FREELIST(temp2->p_next) || WITHIN_ARENA(temp2->p_next));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int sh_init(size_t size, int minsize)
|
|
|
|
{
|
Fix infinite loops in secure memory allocation.
Issue 1:
sh.bittable_size is a size_t but i is and int, which can result in
freelist == -1 if sh.bittable_size exceeds an int.
This seems to result in an OPENSSL_assert due to invalid allocation
size, so maybe that is "ok."
Worse, if sh.bittable_size is exactly 1<<31, then this becomes an
infinite loop (because 1<<31 is a negative int, so it can be shifted
right forever and sticks at -1).
Issue 2:
CRYPTO_secure_malloc_init() sets secure_mem_initialized=1 even when
sh_init() returns 0.
If sh_init() fails, we end up with secure_mem_initialized=1 but
sh.minsize=0. If you then call secure_malloc(), which then calls,
sh_malloc(), this then enters an infite loop since 0 << anything will
never be larger than size.
Issue 3:
That same sh_malloc loop will loop forever for a size greater
than size_t/2 because i will proceed (assuming sh.minsize=16):
i=16, 32, 64, ..., size_t/8, size_t/4, size_t/2, 0, 0, 0, 0, ....
This sequence will never be larger than "size".
Reviewed-by: Rich Salz <rsalz@openssl.org>
Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3449)
2017-05-12 03:48:10 +08:00
|
|
|
int ret;
|
|
|
|
size_t i;
|
2015-04-25 04:39:40 +08:00
|
|
|
size_t pgsize;
|
|
|
|
size_t aligned;
|
|
|
|
|
2017-12-08 02:39:34 +08:00
|
|
|
memset(&sh, 0, sizeof(sh));
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
/* make sure size and minsize are 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)
|
|
|
|
goto err;
|
|
|
|
|
2017-02-17 08:39:20 +08:00
|
|
|
while (minsize < (int)sizeof(SH_LIST))
|
|
|
|
minsize *= 2;
|
|
|
|
|
2015-04-25 04:39:40 +08:00
|
|
|
sh.arena_size = size;
|
|
|
|
sh.minsize = minsize;
|
|
|
|
sh.bittable_size = (sh.arena_size / sh.minsize) * 2;
|
|
|
|
|
2017-02-13 08:36:43 +08:00
|
|
|
/* Prevent allocations of size 0 later on */
|
|
|
|
if (sh.bittable_size >> 3 == 0)
|
|
|
|
goto err;
|
|
|
|
|
2015-04-25 04:39:40 +08:00
|
|
|
sh.freelist_size = -1;
|
|
|
|
for (i = sh.bittable_size; i; i >>= 1)
|
|
|
|
sh.freelist_size++;
|
|
|
|
|
2017-12-08 02:39:34 +08:00
|
|
|
sh.freelist = OPENSSL_zalloc(sh.freelist_size * sizeof(char *));
|
2015-04-25 04:39:40 +08:00
|
|
|
OPENSSL_assert(sh.freelist != NULL);
|
|
|
|
if (sh.freelist == NULL)
|
|
|
|
goto err;
|
|
|
|
|
2015-08-26 01:25:58 +08:00
|
|
|
sh.bittable = OPENSSL_zalloc(sh.bittable_size >> 3);
|
2015-04-25 04:39:40 +08:00
|
|
|
OPENSSL_assert(sh.bittable != NULL);
|
|
|
|
if (sh.bittable == NULL)
|
|
|
|
goto err;
|
|
|
|
|
2015-08-26 01:25:58 +08:00
|
|
|
sh.bitmalloc = OPENSSL_zalloc(sh.bittable_size >> 3);
|
2015-04-25 04:39:40 +08:00
|
|
|
OPENSSL_assert(sh.bitmalloc != NULL);
|
|
|
|
if (sh.bitmalloc == NULL)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
/* Allocate space for heap, and two extra pages as guards */
|
2015-11-12 23:11:34 +08:00
|
|
|
#if defined(_SC_PAGE_SIZE) || defined (_SC_PAGESIZE)
|
|
|
|
{
|
|
|
|
# if defined(_SC_PAGE_SIZE)
|
|
|
|
long tmppgsize = sysconf(_SC_PAGE_SIZE);
|
|
|
|
# else
|
|
|
|
long tmppgsize = sysconf(_SC_PAGESIZE);
|
|
|
|
# endif
|
|
|
|
if (tmppgsize < 1)
|
|
|
|
pgsize = PAGE_SIZE;
|
|
|
|
else
|
|
|
|
pgsize = (size_t)tmppgsize;
|
|
|
|
}
|
2015-04-25 04:39:40 +08:00
|
|
|
#else
|
|
|
|
pgsize = PAGE_SIZE;
|
|
|
|
#endif
|
|
|
|
sh.map_size = pgsize + sh.arena_size + pgsize;
|
2015-11-14 04:30:44 +08:00
|
|
|
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
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
sh.map_result = MAP_FAILED;
|
|
|
|
if ((fd = open("/dev/zero", O_RDWR)) >= 0) {
|
|
|
|
sh.map_result = mmap(NULL, sh.map_size,
|
|
|
|
PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
}
|
2015-04-25 04:39:40 +08:00
|
|
|
if (sh.map_result == MAP_FAILED)
|
|
|
|
goto err;
|
|
|
|
sh.arena = (char *)(sh.map_result + pgsize);
|
|
|
|
sh_setbit(sh.arena, 0, sh.bittable);
|
|
|
|
sh_add_to_list(&sh.freelist[0], sh.arena);
|
|
|
|
|
|
|
|
/* Now try to add guard pages and lock into memory. */
|
|
|
|
ret = 1;
|
|
|
|
|
|
|
|
/* Starting guard is already aligned from mmap. */
|
|
|
|
if (mprotect(sh.map_result, pgsize, PROT_NONE) < 0)
|
|
|
|
ret = 2;
|
|
|
|
|
|
|
|
/* Ending guard page - need to round up to page boundary */
|
|
|
|
aligned = (pgsize + sh.arena_size + (pgsize - 1)) & ~(pgsize - 1);
|
|
|
|
if (mprotect(sh.map_result + aligned, pgsize, PROT_NONE) < 0)
|
|
|
|
ret = 2;
|
|
|
|
|
2017-03-24 00:56:22 +08:00
|
|
|
#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
|
2015-04-25 04:39:40 +08:00
|
|
|
if (mlock(sh.arena, sh.arena_size) < 0)
|
|
|
|
ret = 2;
|
2017-03-24 00:56:22 +08:00
|
|
|
#endif
|
2015-04-25 04:39:40 +08:00
|
|
|
#ifdef MADV_DONTDUMP
|
|
|
|
if (madvise(sh.arena, sh.arena_size, MADV_DONTDUMP) < 0)
|
|
|
|
ret = 2;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
err:
|
|
|
|
sh_done();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-05-09 23:09:50 +08:00
|
|
|
static void sh_done(void)
|
2015-04-25 04:39:40 +08:00
|
|
|
{
|
|
|
|
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);
|
2017-12-08 02:39:34 +08:00
|
|
|
memset(&sh, 0, sizeof(sh));
|
2015-04-25 04:39:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_allocated(const char *ptr)
|
|
|
|
{
|
|
|
|
return WITHIN_ARENA(ptr) ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *sh_find_my_buddy(char *ptr, int list)
|
|
|
|
{
|
2016-04-12 04:03:42 +08:00
|
|
|
size_t bit;
|
2015-04-25 04:39:40 +08:00
|
|
|
char *chunk = NULL;
|
|
|
|
|
2016-04-12 04:03:42 +08:00
|
|
|
bit = (ONE << list) + (ptr - sh.arena) / (sh.arena_size >> list);
|
2015-04-25 04:39:40 +08:00
|
|
|
bit ^= 1;
|
|
|
|
|
|
|
|
if (TESTBIT(sh.bittable, bit) && !TESTBIT(sh.bitmalloc, bit))
|
2016-04-12 04:03:42 +08:00
|
|
|
chunk = sh.arena + ((bit & ((ONE << list) - 1)) * (sh.arena_size >> list));
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
return chunk;
|
|
|
|
}
|
|
|
|
|
2017-03-03 08:16:57 +08:00
|
|
|
static void *sh_malloc(size_t size)
|
2015-04-25 04:39:40 +08:00
|
|
|
{
|
2016-04-12 04:03:42 +08:00
|
|
|
ossl_ssize_t list, slist;
|
2015-04-25 04:39:40 +08:00
|
|
|
size_t i;
|
|
|
|
char *chunk;
|
|
|
|
|
Fix infinite loops in secure memory allocation.
Issue 1:
sh.bittable_size is a size_t but i is and int, which can result in
freelist == -1 if sh.bittable_size exceeds an int.
This seems to result in an OPENSSL_assert due to invalid allocation
size, so maybe that is "ok."
Worse, if sh.bittable_size is exactly 1<<31, then this becomes an
infinite loop (because 1<<31 is a negative int, so it can be shifted
right forever and sticks at -1).
Issue 2:
CRYPTO_secure_malloc_init() sets secure_mem_initialized=1 even when
sh_init() returns 0.
If sh_init() fails, we end up with secure_mem_initialized=1 but
sh.minsize=0. If you then call secure_malloc(), which then calls,
sh_malloc(), this then enters an infite loop since 0 << anything will
never be larger than size.
Issue 3:
That same sh_malloc loop will loop forever for a size greater
than size_t/2 because i will proceed (assuming sh.minsize=16):
i=16, 32, 64, ..., size_t/8, size_t/4, size_t/2, 0, 0, 0, 0, ....
This sequence will never be larger than "size".
Reviewed-by: Rich Salz <rsalz@openssl.org>
Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3449)
2017-05-12 03:48:10 +08:00
|
|
|
if (size > sh.arena_size)
|
|
|
|
return NULL;
|
|
|
|
|
2015-04-25 04:39:40 +08:00
|
|
|
list = sh.freelist_size - 1;
|
|
|
|
for (i = sh.minsize; i < size; i <<= 1)
|
|
|
|
list--;
|
|
|
|
if (list < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* try to find a larger entry to split */
|
|
|
|
for (slist = list; slist >= 0; slist--)
|
|
|
|
if (sh.freelist[slist] != NULL)
|
|
|
|
break;
|
|
|
|
if (slist < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* split larger entry */
|
|
|
|
while (slist != list) {
|
|
|
|
char *temp = sh.freelist[slist];
|
|
|
|
|
|
|
|
/* remove from bigger list */
|
|
|
|
OPENSSL_assert(!sh_testbit(temp, slist, sh.bitmalloc));
|
|
|
|
sh_clearbit(temp, slist, sh.bittable);
|
2016-02-14 11:33:56 +08:00
|
|
|
sh_remove_from_list(temp);
|
2015-04-25 04:39:40 +08:00
|
|
|
OPENSSL_assert(temp != sh.freelist[slist]);
|
|
|
|
|
|
|
|
/* done with bigger list */
|
|
|
|
slist++;
|
|
|
|
|
|
|
|
/* add to smaller list */
|
|
|
|
OPENSSL_assert(!sh_testbit(temp, slist, sh.bitmalloc));
|
|
|
|
sh_setbit(temp, slist, sh.bittable);
|
|
|
|
sh_add_to_list(&sh.freelist[slist], temp);
|
|
|
|
OPENSSL_assert(sh.freelist[slist] == temp);
|
|
|
|
|
|
|
|
/* split in 2 */
|
|
|
|
temp += sh.arena_size >> slist;
|
|
|
|
OPENSSL_assert(!sh_testbit(temp, slist, sh.bitmalloc));
|
|
|
|
sh_setbit(temp, slist, sh.bittable);
|
|
|
|
sh_add_to_list(&sh.freelist[slist], temp);
|
|
|
|
OPENSSL_assert(sh.freelist[slist] == temp);
|
|
|
|
|
|
|
|
OPENSSL_assert(temp-(sh.arena_size >> slist) == sh_find_my_buddy(temp, slist));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* peel off memory to hand back */
|
|
|
|
chunk = sh.freelist[list];
|
|
|
|
OPENSSL_assert(sh_testbit(chunk, list, sh.bittable));
|
|
|
|
sh_setbit(chunk, list, sh.bitmalloc);
|
2016-02-14 11:33:56 +08:00
|
|
|
sh_remove_from_list(chunk);
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
OPENSSL_assert(WITHIN_ARENA(chunk));
|
|
|
|
|
2018-08-22 07:20:18 +08:00
|
|
|
/* zero the free list header as a precaution against information leakage */
|
|
|
|
memset(chunk, 0, sizeof(SH_LIST));
|
|
|
|
|
2015-04-25 04:39:40 +08:00
|
|
|
return chunk;
|
|
|
|
}
|
|
|
|
|
2017-03-03 08:16:57 +08:00
|
|
|
static void sh_free(void *ptr)
|
2015-04-25 04:39:40 +08:00
|
|
|
{
|
2016-04-12 04:03:42 +08:00
|
|
|
size_t list;
|
2017-03-03 08:16:57 +08:00
|
|
|
void *buddy;
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
if (ptr == NULL)
|
|
|
|
return;
|
|
|
|
OPENSSL_assert(WITHIN_ARENA(ptr));
|
|
|
|
if (!WITHIN_ARENA(ptr))
|
|
|
|
return;
|
|
|
|
|
|
|
|
list = sh_getlist(ptr);
|
|
|
|
OPENSSL_assert(sh_testbit(ptr, list, sh.bittable));
|
|
|
|
sh_clearbit(ptr, list, sh.bitmalloc);
|
|
|
|
sh_add_to_list(&sh.freelist[list], ptr);
|
|
|
|
|
|
|
|
/* Try to coalesce two adjacent free areas. */
|
|
|
|
while ((buddy = sh_find_my_buddy(ptr, list)) != NULL) {
|
|
|
|
OPENSSL_assert(ptr == sh_find_my_buddy(buddy, list));
|
|
|
|
OPENSSL_assert(ptr != NULL);
|
|
|
|
OPENSSL_assert(!sh_testbit(ptr, list, sh.bitmalloc));
|
|
|
|
sh_clearbit(ptr, list, sh.bittable);
|
2016-02-14 11:33:56 +08:00
|
|
|
sh_remove_from_list(ptr);
|
2015-04-25 04:39:40 +08:00
|
|
|
OPENSSL_assert(!sh_testbit(ptr, list, sh.bitmalloc));
|
|
|
|
sh_clearbit(buddy, list, sh.bittable);
|
2016-02-14 11:33:56 +08:00
|
|
|
sh_remove_from_list(buddy);
|
2015-04-25 04:39:40 +08:00
|
|
|
|
|
|
|
list--;
|
|
|
|
|
2018-08-22 07:20:18 +08:00
|
|
|
/* Zero the higher addressed block's free list pointers */
|
|
|
|
memset(ptr > buddy ? ptr : buddy, 0, sizeof(SH_LIST));
|
2015-04-25 04:39:40 +08:00
|
|
|
if (ptr > buddy)
|
|
|
|
ptr = buddy;
|
|
|
|
|
|
|
|
OPENSSL_assert(!sh_testbit(ptr, list, sh.bitmalloc));
|
|
|
|
sh_setbit(ptr, list, sh.bittable);
|
|
|
|
sh_add_to_list(&sh.freelist[list], ptr);
|
|
|
|
OPENSSL_assert(sh.freelist[list] == ptr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-12 04:03:42 +08:00
|
|
|
static size_t sh_actual_size(char *ptr)
|
2015-04-25 04:39:40 +08:00
|
|
|
{
|
|
|
|
int list;
|
|
|
|
|
|
|
|
OPENSSL_assert(WITHIN_ARENA(ptr));
|
|
|
|
if (!WITHIN_ARENA(ptr))
|
|
|
|
return 0;
|
|
|
|
list = sh_getlist(ptr);
|
|
|
|
OPENSSL_assert(sh_testbit(ptr, list, sh.bittable));
|
2016-04-12 04:03:42 +08:00
|
|
|
return sh.arena_size / (ONE << list);
|
2015-04-25 04:39:40 +08:00
|
|
|
}
|
2018-10-05 07:05:54 +08:00
|
|
|
#endif /* OPENSSL_SECURE_MEMORY */
|