c8e89d58a5
Remove assertion when mmap() fails. Only run the 1<<31 limit test on Linux Reviewed-by: Richard Levitte <levitte@openssl.org> Reviewed-by: Rich Salz <rsalz@openssl.org> (Merged from https://github.com/openssl/openssl/pull/3455)
121 lines
4.2 KiB
C
121 lines
4.2 KiB
C
/*
|
|
* Copyright 2015-2017 The OpenSSL Project Authors. All Rights Reserved.
|
|
*
|
|
* Licensed under the OpenSSL license (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
|
|
*/
|
|
|
|
#include <openssl/crypto.h>
|
|
|
|
#include "testutil.h"
|
|
|
|
static int test_sec_mem(void)
|
|
{
|
|
#if defined(OPENSSL_SYS_LINUX) || defined(OPENSSL_SYS_UNIX)
|
|
int testresult = 0;
|
|
char *p = NULL, *q = NULL, *r = NULL, *s = NULL;
|
|
|
|
r = OPENSSL_secure_malloc(20);
|
|
/* r = non-secure 20 */
|
|
if (!TEST_ptr(r)
|
|
|| !TEST_true(CRYPTO_secure_malloc_init(4096, 32))
|
|
|| !TEST_false(CRYPTO_secure_allocated(r)))
|
|
goto end;
|
|
p = OPENSSL_secure_malloc(20);
|
|
if (!TEST_ptr(p)
|
|
/* r = non-secure 20, p = secure 20 */
|
|
|| !TEST_true(CRYPTO_secure_allocated(p))
|
|
/* 20 secure -> 32-byte minimum allocaton unit */
|
|
|| !TEST_size_t_eq(CRYPTO_secure_used(), 32))
|
|
goto end;
|
|
q = OPENSSL_malloc(20);
|
|
if (!TEST_ptr(q))
|
|
goto end;
|
|
/* r = non-secure 20, p = secure 20, q = non-secure 20 */
|
|
if (!TEST_false(CRYPTO_secure_allocated(q)))
|
|
goto end;
|
|
s = OPENSSL_secure_malloc(20);
|
|
if (!TEST_ptr(s)
|
|
/* r = non-secure 20, p = secure 20, q = non-secure 20, s = secure 20 */
|
|
|| !TEST_true(CRYPTO_secure_allocated(s))
|
|
/* 2 * 20 secure -> 64 bytes allocated */
|
|
|| !TEST_size_t_eq(CRYPTO_secure_used(), 64))
|
|
goto end;
|
|
OPENSSL_secure_free(p);
|
|
p = NULL;
|
|
/* 20 secure -> 32 bytes allocated */
|
|
if (!TEST_size_t_eq(CRYPTO_secure_used(), 32))
|
|
goto end;
|
|
OPENSSL_free(q);
|
|
q = NULL;
|
|
/* should not complete, as secure memory is still allocated */
|
|
if (!TEST_false(CRYPTO_secure_malloc_done())
|
|
|| !TEST_true(CRYPTO_secure_malloc_initialized()))
|
|
goto end;
|
|
OPENSSL_secure_free(s);
|
|
s = NULL;
|
|
/* secure memory should now be 0, so done should complete */
|
|
if (!TEST_size_t_eq(CRYPTO_secure_used(), 0)
|
|
|| !TEST_true(CRYPTO_secure_malloc_done())
|
|
|| !TEST_false(CRYPTO_secure_malloc_initialized()))
|
|
goto end;
|
|
|
|
TEST_info("Possible infinite loop: allocate more than available");
|
|
if (!TEST_true(CRYPTO_secure_malloc_init(32768, 16)))
|
|
goto end;
|
|
TEST_ptr_null(OPENSSL_secure_malloc((size_t)-1));
|
|
TEST_true(CRYPTO_secure_malloc_done());
|
|
|
|
TEST_info("Possible infinite loop: small arena");
|
|
if (!TEST_false(CRYPTO_secure_malloc_init(16, 16)))
|
|
goto end;
|
|
TEST_false(CRYPTO_secure_malloc_initialized());
|
|
TEST_ptr_null(OPENSSL_secure_malloc((size_t)-1));
|
|
TEST_true(CRYPTO_secure_malloc_done());
|
|
|
|
/*-
|
|
* There was also a possible infinite loop when the number of
|
|
* elements was 1<<31, as |int i| was set to that, which is a
|
|
* negative number. However, it requires minimum input values:
|
|
*
|
|
* CRYPTO_secure_malloc_init((size_t)1<<34, (size_t)1<<4);
|
|
*
|
|
* Which really only works on 64-bit systems, and even then the
|
|
* code attempts to allocate 16 GB secure memory arena. Linux
|
|
* can deal with this better than other Unixy OS's (e.g. MacOS)
|
|
* but we don't want to push the system too hard during a unit
|
|
* test. In addition, trying to allocate 16GB will cause the
|
|
* mlock() call to fail, so that was at least changed to no
|
|
* longer be an assert. If the reader of this comment really
|
|
* wants to make sure that infinite loop is fixed, they can
|
|
* enable the code below.
|
|
*/
|
|
# if 0
|
|
/* This test should only be run under Linux... runner beware */
|
|
if (sizeof(size_t) > 4) {
|
|
TEST_info("Possible infinite loop: 1<<31 limit");
|
|
if (TEST_true(CRYPTO_secure_malloc_init((size_t)1<<34, (size_t)1<<4) != 0))
|
|
TEST_true(CRYPTO_secure_malloc_done());
|
|
}
|
|
# endif
|
|
|
|
/* this can complete - it was not really secure */
|
|
testresult = 1;
|
|
end:
|
|
OPENSSL_secure_free(p);
|
|
OPENSSL_free(q);
|
|
OPENSSL_secure_free(r);
|
|
OPENSSL_secure_free(s);
|
|
return testresult;
|
|
#else
|
|
/* Should fail. */
|
|
return TEST_false(CRYPTO_secure_malloc_init(4096, 32));
|
|
#endif
|
|
}
|
|
|
|
void register_tests(void)
|
|
{
|
|
ADD_TEST(test_sec_mem);
|
|
}
|