Commit 789dfc47 authored by Pauli's avatar Pauli Committed by Matt Caswell
Browse files

Update secmemtest and memeleaktest to use the test infrastructure. 



It isn't easy to use the test framework since it turns memory debugging
on as well and the CRYPTO_mem_leaks_fp function cannot be called twice.

Reviewed-by: default avatarRichard Levitte <levitte@openssl.org>
Reviewed-by: default avatarMatt Caswell <matt@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3169)
parent f5864227

test/build.info

+2 −2
Original line number Diff line number Diff line
@@ -203,7 +203,7 @@ IF[{- !$disabled{tests} -}] 
  INCLUDE[asynctest]=.. ../include

  DEPEND[asynctest]=../libcrypto



  SOURCE[secmemtest]=secmemtest.c

  SOURCE[secmemtest]=secmemtest.c testutil.c test_main.c

  INCLUDE[secmemtest]=../include

  DEPEND[secmemtest]=../libcrypto
@@ -211,7 +211,7 @@ IF[{- !$disabled{tests} -}] 
  INCLUDE[srptest]=../include

  DEPEND[srptest]=../libcrypto



  SOURCE[memleaktest]=memleaktest.c

  SOURCE[memleaktest]=memleaktest.c testutil.c

  INCLUDE[memleaktest]=../include

  DEPEND[memleaktest]=../libcrypto

test/memleaktest.c

+21 −11
Original line number Diff line number Diff line 
/*

 * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.

 * Copyright 2016-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
@@ -7,12 +7,23 @@ 
 * https://www.openssl.org/source/license.html

 */



#include <stdio.h>

#include <string.h>

#include <openssl/bio.h>

#include <openssl/crypto.h>



int main(int argc, char **argv)

#include "testutil.h"



/*

 * We use a proper main function here instead of the custom main from the

 * test framework because the CRYPTO_mem_leaks_fp function cannot be called

 * a second time without trying to use a null pointer.  The test framework

 * calls this function as part of its close down.

 *

 * A work around is to call putenv("OPENSSL_DEBUG_MEMORY=0"); before exiting

 * but that is worse than avoiding the test framework's main.

 */



int main(int argc, char *argv[])

{

#ifndef OPENSSL_NO_CRYPTO_MDEBUG

    char *p;
@@ -25,10 +36,8 @@ int main(int argc, char **argv) 
    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);



    lost = OPENSSL_malloc(3);

    if (lost == NULL) {

        fprintf(stderr, "OPENSSL_malloc failed\n");

        return 1;

    }

    if (!TEST_ptr(lost))

        return EXIT_FAILURE;



    if (argv[1] && strcmp(argv[1], "freeit") == 0) {

        OPENSSL_free(lost);
@@ -37,10 +46,11 @@ int main(int argc, char **argv) 


    noleak = CRYPTO_mem_leaks_fp(stderr);

    /* If -1 return value something bad happened */

    if (noleak == -1)

        return 1;

    return ((lost != NULL) ^ (noleak == 0));

    if (!TEST_int_ne(noleak, -1))

        return EXIT_FAILURE;



    return TEST_int_eq(lost != NULL, noleak == 0) ? EXIT_SUCCESS : EXIT_FAILURE;

#else

    return 0;

    return EXIT_SUCCESS;

#endif

}

test/secmemtest.c

+49 −70
Original line number Diff line number Diff line 
/*

 * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.

 * 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
@@ -9,95 +9,74 @@ 


#include <openssl/crypto.h>



#define perror_line()    perror_line1(__LINE__)

#define perror_line1(l)  perror_line2(l)

#define perror_line2(l)  perror("failed " #l)

#include "test_main.h"

#include "testutil.h"



int main(int argc, char **argv)

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 (r == NULL) {

        perror_line();

        return 1;

    }

    if (!CRYPTO_secure_malloc_init(4096, 32)) {

        perror_line();

        return 1;

    }

    if (CRYPTO_secure_allocated(r)) {

        perror_line();

        return 1;

    }

    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 */

    if (!CRYPTO_secure_allocated(p)) {

        perror_line();

        return 1;

    }

        || !TEST_true(CRYPTO_secure_allocated(p))

        /* 20 secure -> 32-byte minimum allocaton unit */

    if (CRYPTO_secure_used() != 32) {

        perror_line();

        return 1;

    }

        || !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 (CRYPTO_secure_allocated(q)) {

        perror_line();

        return 1;

    }

    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 */

    if (!CRYPTO_secure_allocated(s)) {

        perror_line();

        return 1;

    }

        || !TEST_true(CRYPTO_secure_allocated(s))

        /* 2 * 20 secure -> 64 bytes allocated */

    if (CRYPTO_secure_used() != 64) {

        perror_line();

        return 1;

    }

        || !TEST_size_t_eq(CRYPTO_secure_used(), 64))

        goto end;

    OPENSSL_secure_free(p);

    p = NULL;

    /* 20 secure -> 32 bytes allocated */

    if (CRYPTO_secure_used() != 32) {

        perror_line();

        return 1;

    }

    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 (CRYPTO_secure_malloc_done()) {

        perror_line();

        return 1;

    }

    if (!CRYPTO_secure_malloc_initialized()) {

        perror_line();

        return 1;

    }

    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 (CRYPTO_secure_used() != 0) {

        perror_line();

        return 1;

    }

    if (!CRYPTO_secure_malloc_done()) {

        perror_line();

        return 1;

    }

    if (CRYPTO_secure_malloc_initialized()) {

        perror_line();

        return 1;

    }

    if (!TEST_size_t_eq(CRYPTO_secure_used(), 0)

        || !TEST_true(CRYPTO_secure_malloc_done())

        || !TEST_false(CRYPTO_secure_malloc_initialized()))

        goto end;

    /* 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. */

    if (CRYPTO_secure_malloc_init(4096, 32)) {

        perror_line();

        return 1;

    }

    return TEST_false(CRYPTO_secure_malloc_init(4096, 32));

#endif

    return 0;

}



void register_tests(void)

{

    ADD_TEST(test_sec_mem);

}