[thirdparty/openssl.git] / test / threadstest.c

/*
 * Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
 *
 * 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
 */

#if defined(_WIN32)
# include <windows.h>
#endif

#include <string.h>
#include <openssl/crypto.h>
#include <openssl/evp.h>
#include <openssl/aes.h>
#include <openssl/rsa.h>
#include "testutil.h"

static int do_fips = 0;
static char *privkey;

#if !defined(OPENSSL_THREADS) || defined(CRYPTO_TDEBUG)

typedef unsigned int thread_t;

static int run_thread(thread_t *t, void (*f)(void))
{
    f();
    return 1;
}

static int wait_for_thread(thread_t thread)
{
    return 1;
}

#elif defined(OPENSSL_SYS_WINDOWS)

typedef HANDLE thread_t;

static DWORD WINAPI thread_run(LPVOID arg)
{
    void (*f)(void);

    *(void **) (&f) = arg;

    f();
    return 0;
}

static int run_thread(thread_t *t, void (*f)(void))
{
    *t = CreateThread(NULL, 0, thread_run, *(void **) &f, 0, NULL);
    return *t != NULL;
}

static int wait_for_thread(thread_t thread)
{
    return WaitForSingleObject(thread, INFINITE) == 0;
}

#else

typedef pthread_t thread_t;

static void *thread_run(void *arg)
{
    void (*f)(void);

    *(void **) (&f) = arg;

    f();
    return NULL;
}

static int run_thread(thread_t *t, void (*f)(void))
{
    return pthread_create(t, NULL, thread_run, *(void **) &f) == 0;
}

static int wait_for_thread(thread_t thread)
{
    return pthread_join(thread, NULL) == 0;
}

#endif

static int test_lock(void)
{
    CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();

    if (!TEST_true(CRYPTO_THREAD_read_lock(lock))
        || !TEST_true(CRYPTO_THREAD_unlock(lock)))
        return 0;

    CRYPTO_THREAD_lock_free(lock);

    return 1;
}

static CRYPTO_ONCE once_run = CRYPTO_ONCE_STATIC_INIT;
static unsigned once_run_count = 0;

static void once_do_run(void)
{
    once_run_count++;
}

static void once_run_thread_cb(void)
{
    CRYPTO_THREAD_run_once(&once_run, once_do_run);
}

static int test_once(void)
{
    thread_t thread;

    if (!TEST_true(run_thread(&thread, once_run_thread_cb))
        || !TEST_true(wait_for_thread(thread))
        || !CRYPTO_THREAD_run_once(&once_run, once_do_run)
        || !TEST_int_eq(once_run_count, 1))
        return 0;
    return 1;
}

static CRYPTO_THREAD_LOCAL thread_local_key;
static unsigned destructor_run_count = 0;
static int thread_local_thread_cb_ok = 0;

static void thread_local_destructor(void *arg)
{
    unsigned *count;

    if (arg == NULL)
        return;

    count = arg;

    (*count)++;
}

static void thread_local_thread_cb(void)
{
    void *ptr;

    ptr = CRYPTO_THREAD_get_local(&thread_local_key);
    if (!TEST_ptr_null(ptr)
        || !TEST_true(CRYPTO_THREAD_set_local(&thread_local_key,
                                              &destructor_run_count)))
        return;

    ptr = CRYPTO_THREAD_get_local(&thread_local_key);
    if (!TEST_ptr_eq(ptr, &destructor_run_count))
        return;

    thread_local_thread_cb_ok = 1;
}

static int test_thread_local(void)
{
    thread_t thread;
    void *ptr = NULL;

    if (!TEST_true(CRYPTO_THREAD_init_local(&thread_local_key,
                                            thread_local_destructor)))
        return 0;

    ptr = CRYPTO_THREAD_get_local(&thread_local_key);
    if (!TEST_ptr_null(ptr)
        || !TEST_true(run_thread(&thread, thread_local_thread_cb))
        || !TEST_true(wait_for_thread(thread))
        || !TEST_int_eq(thread_local_thread_cb_ok, 1))
        return 0;

#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)

    ptr = CRYPTO_THREAD_get_local(&thread_local_key);
    if (!TEST_ptr_null(ptr))
        return 0;

# if !defined(OPENSSL_SYS_WINDOWS)
    if (!TEST_int_eq(destructor_run_count, 1))
        return 0;
# endif
#endif

    if (!TEST_true(CRYPTO_THREAD_cleanup_local(&thread_local_key)))
        return 0;
    return 1;
}

static int test_atomic(void)
{
    int val = 0, ret = 0, testresult = 0;
    uint64_t val64 = 1, ret64 = 0;
    CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();

    if (!TEST_ptr(lock))
        return 0;

    if (CRYPTO_atomic_add(&val, 1, &ret, NULL)) {
        /* This succeeds therefore we're on a platform with lockless atomics */
        if (!TEST_int_eq(val, 1) || !TEST_int_eq(val, ret))
            goto err;
    } else {
        /* This failed therefore we're on a platform without lockless atomics */
        if (!TEST_int_eq(val, 0) || !TEST_int_eq(val, ret))
            goto err;
    }
    val = 0;
    ret = 0;

    if (!TEST_true(CRYPTO_atomic_add(&val, 1, &ret, lock)))
        goto err;
    if (!TEST_int_eq(val, 1) || !TEST_int_eq(val, ret))
        goto err;

    if (CRYPTO_atomic_or(&val64, 2, &ret64, NULL)) {
        /* This succeeds therefore we're on a platform with lockless atomics */
        if (!TEST_uint_eq((unsigned int)val64, 3)
                || !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
            goto err;
    } else {
        /* This failed therefore we're on a platform without lockless atomics */
        if (!TEST_uint_eq((unsigned int)val64, 1)
                || !TEST_int_eq((unsigned int)ret64, 0))
            goto err;
    }
    val64 = 1;
    ret64 = 0;

    if (!TEST_true(CRYPTO_atomic_or(&val64, 2, &ret64, lock)))
        goto err;

    if (!TEST_uint_eq((unsigned int)val64, 3)
            || !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
        goto err;

    ret64 = 0;
    if (CRYPTO_atomic_load(&val64, &ret64, NULL)) {
        /* This succeeds therefore we're on a platform with lockless atomics */
        if (!TEST_uint_eq((unsigned int)val64, 3)
                || !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
            goto err;
    } else {
        /* This failed therefore we're on a platform without lockless atomics */
        if (!TEST_uint_eq((unsigned int)val64, 3)
                || !TEST_int_eq((unsigned int)ret64, 0))
            goto err;
    }

    ret64 = 0;
    if (!TEST_true(CRYPTO_atomic_load(&val64, &ret64, lock)))
        goto err;

    if (!TEST_uint_eq((unsigned int)val64, 3)
            || !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
        goto err;

    testresult = 1;
 err:
    CRYPTO_THREAD_lock_free(lock);
    return testresult;
}

static OSSL_LIB_CTX *multi_libctx = NULL;
static int multi_success;

static void thread_general_worker(void)
{
    EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
    EVP_MD *md = EVP_MD_fetch(multi_libctx, "SHA2-256", NULL);
    EVP_CIPHER_CTX *cipherctx = EVP_CIPHER_CTX_new();
    EVP_CIPHER *ciph = EVP_CIPHER_fetch(multi_libctx, "AES-128-CBC", NULL);
    const char *message = "Hello World";
    size_t messlen = strlen(message);
    /* Should be big enough for encryption output too */
    unsigned char out[EVP_MAX_MD_SIZE];
    const unsigned char key[AES_BLOCK_SIZE] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
        0x0c, 0x0d, 0x0e, 0x0f
    };
    const unsigned char iv[AES_BLOCK_SIZE] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
        0x0c, 0x0d, 0x0e, 0x0f
    };
    unsigned int mdoutl;
    int ciphoutl;
    EVP_PKEY_CTX *pctx = NULL;
    EVP_PKEY *pkey = NULL;
    int testresult = 0;
    int i, isfips;

    isfips = OSSL_PROVIDER_available(multi_libctx, "fips");

    if (!TEST_ptr(mdctx)
            || !TEST_ptr(md)
            || !TEST_ptr(cipherctx)
            || !TEST_ptr(ciph))
        goto err;

    /* Do some work */
    for (i = 0; i < 5; i++) {
        if (!TEST_true(EVP_DigestInit_ex(mdctx, md, NULL))
                || !TEST_true(EVP_DigestUpdate(mdctx, message, messlen))
                || !TEST_true(EVP_DigestFinal(mdctx, out, &mdoutl)))
            goto err;
    }
    for (i = 0; i < 5; i++) {
        if (!TEST_true(EVP_EncryptInit_ex(cipherctx, ciph, NULL, key, iv))
                || !TEST_true(EVP_EncryptUpdate(cipherctx, out, &ciphoutl,
                                                (unsigned char *)message,
                                                messlen))
                || !TEST_true(EVP_EncryptFinal(cipherctx, out, &ciphoutl)))
            goto err;
    }

    pctx = EVP_PKEY_CTX_new_from_name(multi_libctx, "RSA", NULL);
    if (!TEST_ptr(pctx)
            || !TEST_int_gt(EVP_PKEY_keygen_init(pctx), 0)
               /*
                * We want the test to run quickly - not securely. Therefore we
                * use an insecure bit length where we can (512). In the FIPS
                * module though we must use a longer length.
                */
            || !TEST_int_gt(EVP_PKEY_CTX_set_rsa_keygen_bits(pctx,
                                                             isfips ? 2048 : 512),
                                                             0)
            || !TEST_int_gt(EVP_PKEY_keygen(pctx, &pkey), 0))
        goto err;

    testresult = 1;
 err:
    EVP_MD_CTX_free(mdctx);
    EVP_MD_free(md);
    EVP_CIPHER_CTX_free(cipherctx);
    EVP_CIPHER_free(ciph);
    EVP_PKEY_CTX_free(pctx);
    EVP_PKEY_free(pkey);
    if (!testresult)
        multi_success = 0;
}

static void thread_multi_simple_fetch(void)
{
    EVP_MD *md = EVP_MD_fetch(NULL, "SHA2-256", NULL);

    if (md != NULL)
        EVP_MD_free(md);
    else
        multi_success = 0;
}

static EVP_PKEY *shared_evp_pkey = NULL;

static void thread_shared_evp_pkey(void)
{
    char *msg = "Hello World";
    unsigned char ctbuf[256];
    unsigned char ptbuf[256];
    size_t ptlen = sizeof(ptbuf), ctlen = sizeof(ctbuf);
    EVP_PKEY_CTX *ctx = NULL;
    int success = 0;
    int i;

    for (i = 0; i < 1 + do_fips; i++) {
        if (i > 0)
            EVP_PKEY_CTX_free(ctx);
        ctx = EVP_PKEY_CTX_new_from_pkey(multi_libctx, shared_evp_pkey,
                                         i == 0 ? "provider=default"
                                                : "provider=fips");
        if (!TEST_ptr(ctx))
            goto err;

        if (!TEST_int_ge(EVP_PKEY_encrypt_init(ctx), 0)
                || !TEST_int_ge(EVP_PKEY_encrypt(ctx, ctbuf, &ctlen,
                                                (unsigned char *)msg, strlen(msg)),
                                                0))
            goto err;

        EVP_PKEY_CTX_free(ctx);
        ctx = EVP_PKEY_CTX_new_from_pkey(multi_libctx, shared_evp_pkey, NULL);

        if (!TEST_ptr(ctx))
            goto err;

        if (!TEST_int_ge(EVP_PKEY_decrypt_init(ctx), 0)
                || !TEST_int_ge(EVP_PKEY_decrypt(ctx, ptbuf, &ptlen, ctbuf, ctlen),
                                                0)
                || !TEST_mem_eq(msg, strlen(msg), ptbuf, ptlen))
            goto err;
    }

    success = 1;

 err:
    EVP_PKEY_CTX_free(ctx);
    if (!success)
        multi_success = 0;
}

/*
 * Do work in multiple worker threads at the same time.
 * Test 0: General worker, using the default provider
 * Test 1: General worker, using the fips provider
 * Test 2: Simple fetch worker
 * Test 3: Worker using a shared EVP_PKEY
 */
static int test_multi(int idx)
{
    thread_t thread1, thread2;
    int testresult = 0;
    OSSL_PROVIDER *prov = NULL, *prov2 = NULL;
    void (*worker)(void);

    if (idx == 1 && !do_fips)
        return TEST_skip("FIPS not supported");

    multi_success = 1;
    multi_libctx = OSSL_LIB_CTX_new();
    if (!TEST_ptr(multi_libctx))
        goto err;
    prov = OSSL_PROVIDER_load(multi_libctx, (idx == 1) ? "fips" : "default");
    if (!TEST_ptr(prov))
        goto err;

    switch (idx) {
    case 0:
    case 1:
        worker = thread_general_worker;
        break;
    case 2:
        worker = thread_multi_simple_fetch;
        break;
    case 3:
        /*
         * If available we have both the default and fips providers for this
         * test
         */
        if (do_fips
                && !TEST_ptr(prov2 = OSSL_PROVIDER_load(multi_libctx, "fips")))
            goto err;
        if (!TEST_ptr(shared_evp_pkey = load_pkey_pem(privkey, multi_libctx)))
            goto err;
        worker = thread_shared_evp_pkey;
        break;
    default:
        TEST_error("Invalid test index");
        goto err;
    }

    if (!TEST_true(run_thread(&thread1, worker))
            || !TEST_true(run_thread(&thread2, worker)))
        goto err;

    worker();

    if (!TEST_true(wait_for_thread(thread1))
            || !TEST_true(wait_for_thread(thread2))
            || !TEST_true(multi_success))
        goto err;

    testresult = 1;

 err:
    OSSL_PROVIDER_unload(prov);
    OSSL_PROVIDER_unload(prov2);
    OSSL_LIB_CTX_free(multi_libctx);
    EVP_PKEY_free(shared_evp_pkey);
    shared_evp_pkey = NULL;
    return testresult;
}

/*
 * This test attempts to load several providers at the same time, and if
 * run with a thread sanitizer, should crash if the core provider code
 * doesn't synchronize well enough.
 */
#define MULTI_LOAD_THREADS 3
static void test_multi_load_worker(void)
{
    OSSL_PROVIDER *prov;

    TEST_ptr(prov = OSSL_PROVIDER_load(NULL, "default"));
    TEST_true(OSSL_PROVIDER_unload(prov));
}

static int test_multi_load(void)
{
    thread_t threads[MULTI_LOAD_THREADS];
    int i;

    for (i = 0; i < MULTI_LOAD_THREADS; i++)
        TEST_true(run_thread(&threads[i], test_multi_load_worker));

    for (i = 0; i < MULTI_LOAD_THREADS; i++)
        TEST_true(wait_for_thread(threads[i]));

    return 1;
}

typedef enum OPTION_choice {
    OPT_ERR = -1,
    OPT_EOF = 0,
    OPT_FIPS,
    OPT_TEST_ENUM
} OPTION_CHOICE;

const OPTIONS *test_get_options(void)
{
    static const OPTIONS options[] = {
        OPT_TEST_OPTIONS_DEFAULT_USAGE,
        { "fips", OPT_FIPS, '-', "Test the FIPS provider" },
        { NULL }
    };
    return options;
}

int setup_tests(void)
{
    OPTION_CHOICE o;
    char *datadir;

    while ((o = opt_next()) != OPT_EOF) {
        switch (o) {
        case OPT_FIPS:
            do_fips = 1;
            break;
        case OPT_TEST_CASES:
            break;
        default:
            return 0;
        }
    }

    if (!TEST_ptr(datadir = test_get_argument(0)))
        return 0;

    privkey = test_mk_file_path(datadir, "rsakey.pem");
    if (!TEST_ptr(privkey))
        return 0;

    ADD_TEST(test_lock);
    ADD_TEST(test_once);
    ADD_TEST(test_thread_local);
    ADD_TEST(test_atomic);
    ADD_TEST(test_multi_load);
    ADD_ALL_TESTS(test_multi, 4);
    return 1;
}

void cleanup_tests(void)
{
    OPENSSL_free(privkey);
}
Commit	Line	Data
440e5d80	1	/*
4333b89f	2	* Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
71a04cfc	3	*
909f1a2e	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
440e5d80 RS	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
71a04cfc AG	8	*/
71a04cfc AG	9
f1f5ee17 AP	10	#if defined(_WIN32)
	11	# include <windows.h>
	12	#endif
	13
ae95a40e	14	#include <string.h>
71a04cfc	15	#include <openssl/crypto.h>
ae95a40e MC	16	#include <openssl/evp.h>
	17	#include <openssl/aes.h>
	18	#include <openssl/rsa.h>
ee25dd45	19	#include "testutil.h"
71a04cfc	20
ae95a40e	21	static int do_fips = 0;
a0134d29	22	static char *privkey;
ae95a40e	23
71a04cfc AG	24	#if !defined(OPENSSL_THREADS) \|\| defined(CRYPTO_TDEBUG)
	25
	26	typedef unsigned int thread_t;
	27
	28	static int run_thread(thread_t t, void (f)(void))
	29	{
	30	f();
	31	return 1;
	32	}
	33
	34	static int wait_for_thread(thread_t thread)
	35	{
	36	return 1;
	37	}
	38
	39	#elif defined(OPENSSL_SYS_WINDOWS)
	40
	41	typedef HANDLE thread_t;
	42
	43	static DWORD WINAPI thread_run(LPVOID arg)
	44	{
	45	void (*f)(void);
	46
	47	(void *) (&f) = arg;
	48
	49	f();
	50	return 0;
	51	}
	52
	53	static int run_thread(thread_t t, void (f)(void))
	54	{
	55	t = CreateThread(NULL, 0, thread_run, (void **) &f, 0, NULL);
	56	return *t != NULL;
	57	}
	58
	59	static int wait_for_thread(thread_t thread)
	60	{
	61	return WaitForSingleObject(thread, INFINITE) == 0;
	62	}
	63
	64	#else
	65
	66	typedef pthread_t thread_t;
	67
	68	static void thread_run(void arg)
	69	{
	70	void (*f)(void);
	71
	72	(void *) (&f) = arg;
	73
	74	f();
	75	return NULL;
	76	}
	77
	78	static int run_thread(thread_t t, void (f)(void))
	79	{
	80	return pthread_create(t, NULL, thread_run, (void *) &f) == 0;
	81	}
	82
	83	static int wait_for_thread(thread_t thread)
	84	{
	85	return pthread_join(thread, NULL) == 0;
	86	}
	87
88	#endif
89
90	static int test_lock(void)
91	{
92	CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();
93
ee25dd45 P	94	if (!TEST_true(CRYPTO_THREAD_read_lock(lock))
ee25dd45 P	95	\|\| !TEST_true(CRYPTO_THREAD_unlock(lock)))
71a04cfc	96	return 0;
71a04cfc AG	97
	98	CRYPTO_THREAD_lock_free(lock);
	99
	100	return 1;
	101	}
	102
	103	static CRYPTO_ONCE once_run = CRYPTO_ONCE_STATIC_INIT;
	104	static unsigned once_run_count = 0;
	105
	106	static void once_do_run(void)
	107	{
	108	once_run_count++;
	109	}
	110
	111	static void once_run_thread_cb(void)
	112	{
	113	CRYPTO_THREAD_run_once(&once_run, once_do_run);
	114	}
	115
	116	static int test_once(void)
	117	{
	118	thread_t thread;
71a04cfc	119
ee25dd45 P	120	if (!TEST_true(run_thread(&thread, once_run_thread_cb))
	121	\|\| !TEST_true(wait_for_thread(thread))
	122	\|\| !CRYPTO_THREAD_run_once(&once_run, once_do_run)
	123	\|\| !TEST_int_eq(once_run_count, 1))
71a04cfc	124	return 0;
71a04cfc AG	125	return 1;
	126	}
	127
	128	static CRYPTO_THREAD_LOCAL thread_local_key;
	129	static unsigned destructor_run_count = 0;
	130	static int thread_local_thread_cb_ok = 0;
	131
	132	static void thread_local_destructor(void *arg)
	133	{
	134	unsigned *count;
	135
	136	if (arg == NULL)
	137	return;
	138
	139	count = arg;
	140
	141	(*count)++;
	142	}
	143
	144	static void thread_local_thread_cb(void)
	145	{
	146	void *ptr;
	147
	148	ptr = CRYPTO_THREAD_get_local(&thread_local_key);
ee25dd45 P	149	if (!TEST_ptr_null(ptr)
	150	\|\| !TEST_true(CRYPTO_THREAD_set_local(&thread_local_key,
	151	&destructor_run_count)))
71a04cfc	152	return;
71a04cfc AG	153
71a04cfc AG	154	ptr = CRYPTO_THREAD_get_local(&thread_local_key);
ee25dd45	155	if (!TEST_ptr_eq(ptr, &destructor_run_count))
71a04cfc	156	return;
71a04cfc AG	157
	158	thread_local_thread_cb_ok = 1;
	159	}
	160
	161	static int test_thread_local(void)
	162	{
	163	thread_t thread;
	164	void *ptr = NULL;
	165
ee25dd45 P	166	if (!TEST_true(CRYPTO_THREAD_init_local(&thread_local_key,
ee25dd45 P	167	thread_local_destructor)))
71a04cfc	168	return 0;
71a04cfc AG	169
71a04cfc AG	170	ptr = CRYPTO_THREAD_get_local(&thread_local_key);
ee25dd45 P	171	if (!TEST_ptr_null(ptr)
	172	\|\| !TEST_true(run_thread(&thread, thread_local_thread_cb))
	173	\|\| !TEST_true(wait_for_thread(thread))
	174	\|\| !TEST_int_eq(thread_local_thread_cb_ok, 1))
71a04cfc	175	return 0;
71a04cfc AG	176
	177	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
	178
	179	ptr = CRYPTO_THREAD_get_local(&thread_local_key);
ee25dd45	180	if (!TEST_ptr_null(ptr))
71a04cfc	181	return 0;
71a04cfc AG	182
71a04cfc AG	183	# if !defined(OPENSSL_SYS_WINDOWS)
ee25dd45	184	if (!TEST_int_eq(destructor_run_count, 1))
71a04cfc	185	return 0;
71a04cfc	186	# endif
71a04cfc AG	187	#endif
71a04cfc AG	188
ee25dd45	189	if (!TEST_true(CRYPTO_THREAD_cleanup_local(&thread_local_key)))
71a04cfc	190	return 0;
71a04cfc AG	191	return 1;
	192	}
	193
ea08f8b2 MC	194	static int test_atomic(void)
	195	{
	196	int val = 0, ret = 0, testresult = 0;
	197	uint64_t val64 = 1, ret64 = 0;
	198	CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();
	199
	200	if (!TEST_ptr(lock))
	201	return 0;
	202
	203	if (CRYPTO_atomic_add(&val, 1, &ret, NULL)) {
	204	/* This succeeds therefore we're on a platform with lockless atomics */
	205	if (!TEST_int_eq(val, 1) \|\| !TEST_int_eq(val, ret))
	206	goto err;
	207	} else {
	208	/* This failed therefore we're on a platform without lockless atomics */
	209	if (!TEST_int_eq(val, 0) \|\| !TEST_int_eq(val, ret))
	210	goto err;
	211	}
	212	val = 0;
	213	ret = 0;
	214
	215	if (!TEST_true(CRYPTO_atomic_add(&val, 1, &ret, lock)))
	216	goto err;
	217	if (!TEST_int_eq(val, 1) \|\| !TEST_int_eq(val, ret))
	218	goto err;
	219
	220	if (CRYPTO_atomic_or(&val64, 2, &ret64, NULL)) {
	221	/* This succeeds therefore we're on a platform with lockless atomics */
	222	if (!TEST_uint_eq((unsigned int)val64, 3)
	223	\|\| !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
	224	goto err;
	225	} else {
	226	/* This failed therefore we're on a platform without lockless atomics */
	227	if (!TEST_uint_eq((unsigned int)val64, 1)
	228	\|\| !TEST_int_eq((unsigned int)ret64, 0))
	229	goto err;
	230	}
	231	val64 = 1;
	232	ret64 = 0;
	233
	234	if (!TEST_true(CRYPTO_atomic_or(&val64, 2, &ret64, lock)))
	235	goto err;
	236
	237	if (!TEST_uint_eq((unsigned int)val64, 3)
	238	\|\| !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
	239	goto err;
	240
	241	ret64 = 0;
	242	if (CRYPTO_atomic_load(&val64, &ret64, NULL)) {
	243	/* This succeeds therefore we're on a platform with lockless atomics */
	244	if (!TEST_uint_eq((unsigned int)val64, 3)
	245	\|\| !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
	246	goto err;
	247	} else {
	248	/* This failed therefore we're on a platform without lockless atomics */
	249	if (!TEST_uint_eq((unsigned int)val64, 3)
	250	\|\| !TEST_int_eq((unsigned int)ret64, 0))
	251	goto err;
	252	}
	253
	254	ret64 = 0;
	255	if (!TEST_true(CRYPTO_atomic_load(&val64, &ret64, lock)))
	256	goto err;
	257
258	if (!TEST_uint_eq((unsigned int)val64, 3)
259	\|\| !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
260	goto err;
261
262	testresult = 1;
263	err:
ea08f8b2 MC	264	CRYPTO_THREAD_lock_free(lock);
	265	return testresult;
	266	}
	267
ae95a40e MC	268	static OSSL_LIB_CTX *multi_libctx = NULL;
	269	static int multi_success;
	270
b457c8f5	271	static void thread_general_worker(void)
ae95a40e MC	272	{
	273	EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
	274	EVP_MD *md = EVP_MD_fetch(multi_libctx, "SHA2-256", NULL);
	275	EVP_CIPHER_CTX *cipherctx = EVP_CIPHER_CTX_new();
	276	EVP_CIPHER *ciph = EVP_CIPHER_fetch(multi_libctx, "AES-128-CBC", NULL);
	277	const char *message = "Hello World";
	278	size_t messlen = strlen(message);
	279	/* Should be big enough for encryption output too */
	280	unsigned char out[EVP_MAX_MD_SIZE];
	281	const unsigned char key[AES_BLOCK_SIZE] = {
	282	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
	283	0x0c, 0x0d, 0x0e, 0x0f
	284	};
	285	const unsigned char iv[AES_BLOCK_SIZE] = {
	286	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
	287	0x0c, 0x0d, 0x0e, 0x0f
	288	};
	289	unsigned int mdoutl;
	290	int ciphoutl;
	291	EVP_PKEY_CTX *pctx = NULL;
	292	EVP_PKEY *pkey = NULL;
	293	int testresult = 0;
	294	int i, isfips;
	295
	296	isfips = OSSL_PROVIDER_available(multi_libctx, "fips");
	297
	298	if (!TEST_ptr(mdctx)
	299	\|\| !TEST_ptr(md)
	300	\|\| !TEST_ptr(cipherctx)
	301	\|\| !TEST_ptr(ciph))
	302	goto err;
	303
	304	/* Do some work */
	305	for (i = 0; i < 5; i++) {
	306	if (!TEST_true(EVP_DigestInit_ex(mdctx, md, NULL))
	307	\|\| !TEST_true(EVP_DigestUpdate(mdctx, message, messlen))
	308	\|\| !TEST_true(EVP_DigestFinal(mdctx, out, &mdoutl)))
	309	goto err;
	310	}
	311	for (i = 0; i < 5; i++) {
	312	if (!TEST_true(EVP_EncryptInit_ex(cipherctx, ciph, NULL, key, iv))
	313	\|\| !TEST_true(EVP_EncryptUpdate(cipherctx, out, &ciphoutl,
	314	(unsigned char *)message,
	315	messlen))
	316	\|\| !TEST_true(EVP_EncryptFinal(cipherctx, out, &ciphoutl)))
	317	goto err;
	318	}
	319
	320	pctx = EVP_PKEY_CTX_new_from_name(multi_libctx, "RSA", NULL);
	321	if (!TEST_ptr(pctx)
	322	\|\| !TEST_int_gt(EVP_PKEY_keygen_init(pctx), 0)
	323	/*
	324	* We want the test to run quickly - not securely. Therefore we
	325	* use an insecure bit length where we can (512). In the FIPS
	326	* module though we must use a longer length.
	327	*/
	328	\|\| !TEST_int_gt(EVP_PKEY_CTX_set_rsa_keygen_bits(pctx,
	329	isfips ? 2048 : 512),
	330	0)
	331	\|\| !TEST_int_gt(EVP_PKEY_keygen(pctx, &pkey), 0))
	332	goto err;
	333
	334	testresult = 1;
	335	err:
336	EVP_MD_CTX_free(mdctx);
337	EVP_MD_free(md);
338	EVP_CIPHER_CTX_free(cipherctx);
339	EVP_CIPHER_free(ciph);
340	EVP_PKEY_CTX_free(pctx);
341	EVP_PKEY_free(pkey);
342	if (!testresult)
343	multi_success = 0;
344	}
345
b457c8f5 MC	346	static void thread_multi_simple_fetch(void)
	347	{
	348	EVP_MD *md = EVP_MD_fetch(NULL, "SHA2-256", NULL);
	349
	350	if (md != NULL)
	351	EVP_MD_free(md);
	352	else
	353	multi_success = 0;
	354	}
	355
a0134d29 MC	356	static EVP_PKEY *shared_evp_pkey = NULL;
	357
	358	static void thread_shared_evp_pkey(void)
	359	{
	360	char *msg = "Hello World";
	361	unsigned char ctbuf[256];
	362	unsigned char ptbuf[256];
	363	size_t ptlen = sizeof(ptbuf), ctlen = sizeof(ctbuf);
	364	EVP_PKEY_CTX *ctx = NULL;
	365	int success = 0;
	366	int i;
	367
	368	for (i = 0; i < 1 + do_fips; i++) {
	369	if (i > 0)
	370	EVP_PKEY_CTX_free(ctx);
	371	ctx = EVP_PKEY_CTX_new_from_pkey(multi_libctx, shared_evp_pkey,
	372	i == 0 ? "provider=default"
	373	: "provider=fips");
	374	if (!TEST_ptr(ctx))
	375	goto err;
	376
	377	if (!TEST_int_ge(EVP_PKEY_encrypt_init(ctx), 0)
	378	\|\| !TEST_int_ge(EVP_PKEY_encrypt(ctx, ctbuf, &ctlen,
	379	(unsigned char *)msg, strlen(msg)),
	380	0))
	381	goto err;
	382
	383	EVP_PKEY_CTX_free(ctx);
	384	ctx = EVP_PKEY_CTX_new_from_pkey(multi_libctx, shared_evp_pkey, NULL);
	385
	386	if (!TEST_ptr(ctx))
	387	goto err;
	388
	389	if (!TEST_int_ge(EVP_PKEY_decrypt_init(ctx), 0)
	390	\|\| !TEST_int_ge(EVP_PKEY_decrypt(ctx, ptbuf, &ptlen, ctbuf, ctlen),
	391	0)
	392	\|\| !TEST_mem_eq(msg, strlen(msg), ptbuf, ptlen))
	393	goto err;
	394	}
	395
	396	success = 1;
	397
	398	err:
	399	EVP_PKEY_CTX_free(ctx);
	400	if (!success)
	401	multi_success = 0;
	402	}
	403
ae95a40e MC	404	/*
ae95a40e MC	405	* Do work in multiple worker threads at the same time.
b457c8f5 MC	406	* Test 0: General worker, using the default provider
	407	* Test 1: General worker, using the fips provider
	408	* Test 2: Simple fetch worker
a0134d29	409	* Test 3: Worker using a shared EVP_PKEY
ae95a40e MC	410	*/
	411	static int test_multi(int idx)
	412	{
	413	thread_t thread1, thread2;
	414	int testresult = 0;
a0134d29	415	OSSL_PROVIDER prov = NULL, prov2 = NULL;
b457c8f5	416	void (*worker)(void);
ae95a40e MC	417
	418	if (idx == 1 && !do_fips)
	419	return TEST_skip("FIPS not supported");
	420
	421	multi_success = 1;
	422	multi_libctx = OSSL_LIB_CTX_new();
	423	if (!TEST_ptr(multi_libctx))
	424	goto err;
b457c8f5	425	prov = OSSL_PROVIDER_load(multi_libctx, (idx == 1) ? "fips" : "default");
ae95a40e MC	426	if (!TEST_ptr(prov))
	427	goto err;
	428
b457c8f5 MC	429	switch (idx) {
	430	case 0:
	431	case 1:
	432	worker = thread_general_worker;
	433	break;
	434	case 2:
	435	worker = thread_multi_simple_fetch;
	436	break;
a0134d29 MC	437	case 3:
	438	/*
	439	* If available we have both the default and fips providers for this
	440	* test
	441	*/
	442	if (do_fips
	443	&& !TEST_ptr(prov2 = OSSL_PROVIDER_load(multi_libctx, "fips")))
	444	goto err;
	445	if (!TEST_ptr(shared_evp_pkey = load_pkey_pem(privkey, multi_libctx)))
	446	goto err;
	447	worker = thread_shared_evp_pkey;
	448	break;
b457c8f5 MC	449	default:
	450	TEST_error("Invalid test index");
	451	goto err;
	452	}
	453
	454	if (!TEST_true(run_thread(&thread1, worker))
	455	\|\| !TEST_true(run_thread(&thread2, worker)))
ae95a40e MC	456	goto err;
ae95a40e MC	457
b457c8f5	458	worker();
ae95a40e MC	459
	460	if (!TEST_true(wait_for_thread(thread1))
	461	\|\| !TEST_true(wait_for_thread(thread2))
	462	\|\| !TEST_true(multi_success))
	463	goto err;
	464
	465	testresult = 1;
	466
	467	err:
	468	OSSL_PROVIDER_unload(prov);
a0134d29	469	OSSL_PROVIDER_unload(prov2);
ae95a40e	470	OSSL_LIB_CTX_free(multi_libctx);
a0134d29 MC	471	EVP_PKEY_free(shared_evp_pkey);
a0134d29 MC	472	shared_evp_pkey = NULL;
ae95a40e MC	473	return testresult;
	474	}
	475
2f17e978 RL	476	/*
	477	* This test attempts to load several providers at the same time, and if
	478	* run with a thread sanitizer, should crash if the core provider code
	479	* doesn't synchronize well enough.
	480	*/
	481	#define MULTI_LOAD_THREADS 3
	482	static void test_multi_load_worker(void)
	483	{
	484	OSSL_PROVIDER *prov;
	485
	486	TEST_ptr(prov = OSSL_PROVIDER_load(NULL, "default"));
	487	TEST_true(OSSL_PROVIDER_unload(prov));
	488	}
	489
	490	static int test_multi_load(void)
	491	{
	492	thread_t threads[MULTI_LOAD_THREADS];
	493	int i;
	494
	495	for (i = 0; i < MULTI_LOAD_THREADS; i++)
	496	TEST_true(run_thread(&threads[i], test_multi_load_worker));
	497
	498	for (i = 0; i < MULTI_LOAD_THREADS; i++)
	499	TEST_true(wait_for_thread(threads[i]));
	500
	501	return 1;
	502	}
	503
ae95a40e MC	504	typedef enum OPTION_choice {
	505	OPT_ERR = -1,
	506	OPT_EOF = 0,
	507	OPT_FIPS,
	508	OPT_TEST_ENUM
	509	} OPTION_CHOICE;
	510
	511	const OPTIONS *test_get_options(void)
	512	{
	513	static const OPTIONS options[] = {
	514	OPT_TEST_OPTIONS_DEFAULT_USAGE,
	515	{ "fips", OPT_FIPS, '-', "Test the FIPS provider" },
	516	{ NULL }
	517	};
	518	return options;
	519	}
	520
ad887416	521	int setup_tests(void)
71a04cfc	522	{
ae95a40e	523	OPTION_CHOICE o;
a0134d29	524	char *datadir;
ae95a40e MC	525
	526	while ((o = opt_next()) != OPT_EOF) {
	527	switch (o) {
	528	case OPT_FIPS:
	529	do_fips = 1;
	530	break;
	531	case OPT_TEST_CASES:
	532	break;
	533	default:
	534	return 0;
	535	}
	536	}
	537
a0134d29 MC	538	if (!TEST_ptr(datadir = test_get_argument(0)))
	539	return 0;
	540
	541	privkey = test_mk_file_path(datadir, "rsakey.pem");
	542	if (!TEST_ptr(privkey))
	543	return 0;
	544
ee25dd45 P	545	ADD_TEST(test_lock);
	546	ADD_TEST(test_once);
	547	ADD_TEST(test_thread_local);
ea08f8b2	548	ADD_TEST(test_atomic);
2f17e978	549	ADD_TEST(test_multi_load);
a0134d29	550	ADD_ALL_TESTS(test_multi, 4);
ad887416	551	return 1;
71a04cfc	552	}
a0134d29 MC	553
	554	void cleanup_tests(void)
	555	{
	556	OPENSSL_free(privkey);
	557	}