Commit 5e130ae6 authored by Dr. Matthias St. Pierre's avatar Dr. Matthias St. Pierre
Browse files

test/secmemtest: test secure memory only if it is implemented 



Fixes #7322

Reviewed-by: default avatarPaul Dale <paul.dale@oracle.com>
Reviewed-by: default avatarBernd Edlinger <bernd.edlinger@hotmail.de>
(Merged from https://github.com/openssl/openssl/pull/7351)

(cherry picked from commit 8529b156421805415bc7b17758255394de580c61)
parent c11c2805

crypto/mem_sec.c

+23 −27
Original line number Original line Diff line number Diff line
@@ -20,12 +20,8 @@ 




#include <string.h>

#include <string.h>





/* e_os.h includes unistd.h, which defines _POSIX_VERSION */

/* e_os.h defines OPENSSL_SECURE_MEMORY if secure memory can be implemented */

#if !defined(OPENSSL_NO_SECURE_MEMORY) && defined(OPENSSL_SYS_UNIX) \

#ifdef OPENSSL_SECURE_MEMORY

    && ( (defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112L) \

         || defined(__sun) || defined(__hpux) || defined(__sgi) \

         || defined(__osf__) )

# define IMPLEMENTED

# include <stdlib.h>

# include <stdlib.h>

# include <assert.h>

# include <assert.h>

# include <unistd.h>

# include <unistd.h>
@@ -51,7 +47,7 @@ 
# define MAP_ANON MAP_ANONYMOUS

# define MAP_ANON MAP_ANONYMOUS

#endif

#endif





#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY

static size_t secure_mem_used;

static size_t secure_mem_used;





static int secure_mem_initialized;

static int secure_mem_initialized;
@@ -71,7 +67,7 @@ static int sh_allocated(const char *ptr); 




int CRYPTO_secure_malloc_init(size_t size, int minsize)

int CRYPTO_secure_malloc_init(size_t size, int minsize)

{

{

#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY

    int ret = 0;

    int ret = 0;





    if (!secure_mem_initialized) {

    if (!secure_mem_initialized) {
@@ -89,12 +85,12 @@ int CRYPTO_secure_malloc_init(size_t size, int minsize) 
    return ret;

    return ret;

#else

#else

    return 0;

    return 0;

#endif /* IMPLEMENTED */

#endif /* OPENSSL_SECURE_MEMORY */

}

}





int CRYPTO_secure_malloc_done(void)

int CRYPTO_secure_malloc_done(void)

{

{

#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY

    if (secure_mem_used == 0) {

    if (secure_mem_used == 0) {

        sh_done();

        sh_done();

        secure_mem_initialized = 0;

        secure_mem_initialized = 0;
@@ -102,22 +98,22 @@ int CRYPTO_secure_malloc_done(void) 
        sec_malloc_lock = NULL;

        sec_malloc_lock = NULL;

        return 1;

        return 1;

    }

    }

#endif /* IMPLEMENTED */

#endif /* OPENSSL_SECURE_MEMORY */

    return 0;

    return 0;

}

}





int CRYPTO_secure_malloc_initialized(void)

int CRYPTO_secure_malloc_initialized(void)

{

{

#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY

    return secure_mem_initialized;

    return secure_mem_initialized;

#else

#else

    return 0;

    return 0;

#endif /* IMPLEMENTED */

#endif /* OPENSSL_SECURE_MEMORY */

}

}





void *CRYPTO_secure_malloc(size_t num, const char *file, int line)

void *CRYPTO_secure_malloc(size_t num, const char *file, int line)

{

{

#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY

    void *ret;

    void *ret;

    size_t actual_size;

    size_t actual_size;
@@ -132,12 +128,12 @@ void *CRYPTO_secure_malloc(size_t num, const char *file, int line) 
    return ret;

    return ret;

#else

#else

    return CRYPTO_malloc(num, file, line);

    return CRYPTO_malloc(num, file, line);

#endif /* IMPLEMENTED */

#endif /* OPENSSL_SECURE_MEMORY */

}

}





void *CRYPTO_secure_zalloc(size_t num, const char *file, int line)

void *CRYPTO_secure_zalloc(size_t num, const char *file, int line)

{

{

#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY

    if (secure_mem_initialized)

    if (secure_mem_initialized)

        /* CRYPTO_secure_malloc() zeroes allocations when it is implemented */

        /* CRYPTO_secure_malloc() zeroes allocations when it is implemented */

        return CRYPTO_secure_malloc(num, file, line);

        return CRYPTO_secure_malloc(num, file, line);
@@ -147,7 +143,7 @@ void *CRYPTO_secure_zalloc(size_t num, const char *file, int line) 




void CRYPTO_secure_free(void *ptr, const char *file, int line)

void CRYPTO_secure_free(void *ptr, const char *file, int line)

{

{

#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY

    size_t actual_size;

    size_t actual_size;





    if (ptr == NULL)

    if (ptr == NULL)
@@ -164,13 +160,13 @@ void CRYPTO_secure_free(void *ptr, const char *file, int line) 
    CRYPTO_THREAD_unlock(sec_malloc_lock);

    CRYPTO_THREAD_unlock(sec_malloc_lock);

#else

#else

    CRYPTO_free(ptr, file, line);

    CRYPTO_free(ptr, file, line);

#endif /* IMPLEMENTED */

#endif /* OPENSSL_SECURE_MEMORY */

}

}





void CRYPTO_secure_clear_free(void *ptr, size_t num,

void CRYPTO_secure_clear_free(void *ptr, size_t num,

                              const char *file, int line)

                              const char *file, int line)

{

{

#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY

    size_t actual_size;

    size_t actual_size;





    if (ptr == NULL)

    if (ptr == NULL)
@@ -191,12 +187,12 @@ void CRYPTO_secure_clear_free(void *ptr, size_t num, 
        return;

        return;

    OPENSSL_cleanse(ptr, num);

    OPENSSL_cleanse(ptr, num);

    CRYPTO_free(ptr, file, line);

    CRYPTO_free(ptr, file, line);

#endif /* IMPLEMENTED */

#endif /* OPENSSL_SECURE_MEMORY */

}

}





int CRYPTO_secure_allocated(const void *ptr)

int CRYPTO_secure_allocated(const void *ptr)

{

{

#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY

    int ret;

    int ret;





    if (!secure_mem_initialized)

    if (!secure_mem_initialized)
@@ -207,21 +203,21 @@ int CRYPTO_secure_allocated(const void *ptr) 
    return ret;

    return ret;

#else

#else

    return 0;

    return 0;

#endif /* IMPLEMENTED */

#endif /* OPENSSL_SECURE_MEMORY */

}

}





size_t CRYPTO_secure_used(void)

size_t CRYPTO_secure_used(void)

{

{

#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY

    return secure_mem_used;

    return secure_mem_used;

#else

#else

    return 0;

    return 0;

#endif /* IMPLEMENTED */

#endif /* OPENSSL_SECURE_MEMORY */

}

}





size_t CRYPTO_secure_actual_size(void *ptr)

size_t CRYPTO_secure_actual_size(void *ptr)

{

{

#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY

    size_t actual_size;

    size_t actual_size;





    CRYPTO_THREAD_write_lock(sec_malloc_lock);

    CRYPTO_THREAD_write_lock(sec_malloc_lock);
@@ -239,7 +235,7 @@ size_t CRYPTO_secure_actual_size(void *ptr) 
/*

/*

 * SECURE HEAP IMPLEMENTATION

 * SECURE HEAP IMPLEMENTATION

 */

 */

#ifdef IMPLEMENTED

#ifdef OPENSSL_SECURE_MEMORY









/*

/*
@@ -647,4 +643,4 @@ static size_t sh_actual_size(char *ptr) 
    OPENSSL_assert(sh_testbit(ptr, list, sh.bittable));

    OPENSSL_assert(sh_testbit(ptr, list, sh.bittable));

    return sh.arena_size / (ONE << list);

    return sh.arena_size / (ONE << list);

}

}

#endif /* IMPLEMENTED */
 
#endif /* OPENSSL_SECURE_MEMORY */

e_os.h

+10 −3
Original line number Original line Diff line number Diff line
@@ -321,4 +321,11 @@ struct servent *getservbyname(const char *name, const char *proto); 
#  define CRYPTO_memcmp memcmp

#  define CRYPTO_memcmp memcmp

# endif

# endif





/* unistd.h defines _POSIX_VERSION */

# if !defined(OPENSSL_NO_SECURE_MEMORY) && defined(OPENSSL_SYS_UNIX) \

     && ( (defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112L)      \

          || defined(__sun) || defined(__hpux) || defined(__sgi)      \

          || defined(__osf__) )

#  define OPENSSL_SECURE_MEMORY  /* secure memory is implemented */

# endif

#endif
 
#endif

test/secmemtest.c

+6 −3
Original line number Original line Diff line number Diff line
@@ -10,13 +10,16 @@ 
#include <openssl/crypto.h>

#include <openssl/crypto.h>





#include "testutil.h"

#include "testutil.h"

#include "../e_os.h"





static int test_sec_mem(void)

static int test_sec_mem(void)

{

{

#if defined(OPENSSL_SYS_LINUX) || defined(OPENSSL_SYS_UNIX)

#ifdef OPENSSL_SECURE_MEMORY

    int testresult = 0;

    int testresult = 0;

    char *p = NULL, *q = NULL, *r = NULL, *s = NULL;

    char *p = NULL, *q = NULL, *r = NULL, *s = NULL;





    TEST_info("Secure memory is implemented.");



    s = OPENSSL_secure_malloc(20);

    s = OPENSSL_secure_malloc(20);

    /* s = non-secure 20 */

    /* s = non-secure 20 */

    if (!TEST_ptr(s)

    if (!TEST_ptr(s)
@@ -124,6 +127,7 @@ static int test_sec_mem(void) 
    OPENSSL_secure_free(s);

    OPENSSL_secure_free(s);

    return testresult;

    return testresult;

#else

#else

    TEST_info("Secure memory is *not* implemented.");

    /* Should fail. */

    /* Should fail. */

    return TEST_false(CRYPTO_secure_malloc_init(4096, 32));

    return TEST_false(CRYPTO_secure_malloc_init(4096, 32));

#endif

#endif
@@ -131,7 +135,7 @@ static int test_sec_mem(void) 




static int test_sec_mem_clear(void)

static int test_sec_mem_clear(void)

{

{

#if defined(OPENSSL_SYS_LINUX) || defined(OPENSSL_SYS_UNIX)

#ifdef OPENSSL_SECURE_MEMORY

    const int size = 64;

    const int size = 64;

    unsigned char *p = NULL;

    unsigned char *p = NULL;

    int i, res = 0;

    int i, res = 0;
@@ -162,7 +166,6 @@ static int test_sec_mem_clear(void) 




    res = 1;

    res = 1;

    p = NULL;

    p = NULL;



err:

err:

    OPENSSL_secure_free(p);

    OPENSSL_secure_free(p);

    CRYPTO_secure_malloc_done();

    CRYPTO_secure_malloc_done();