[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;

#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;
}

/*
 * 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
 */
static int test_multi(int idx)
{
    thread_t thread1, thread2;
    int testresult = 0;
    OSSL_PROVIDER *prov = 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;
    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_LIB_CTX_free(multi_libctx);
    return testresult;
}

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;

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

    ADD_TEST(test_lock);
    ADD_TEST(test_once);
    ADD_TEST(test_thread_local);
    ADD_TEST(test_atomic);
    ADD_ALL_TESTS(test_multi, 3);
    return 1;
}
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 MC	21	static int do_fips = 0;
ae95a40e MC	22
71a04cfc AG	23	#if !defined(OPENSSL_THREADS) \|\| defined(CRYPTO_TDEBUG)
	24
	25	typedef unsigned int thread_t;
	26
	27	static int run_thread(thread_t t, void (f)(void))
	28	{
	29	f();
	30	return 1;
	31	}
	32
	33	static int wait_for_thread(thread_t thread)
	34	{
	35	return 1;
	36	}
	37
	38	#elif defined(OPENSSL_SYS_WINDOWS)
	39
	40	typedef HANDLE thread_t;
	41
	42	static DWORD WINAPI thread_run(LPVOID arg)
	43	{
	44	void (*f)(void);
	45
	46	(void *) (&f) = arg;
	47
	48	f();
	49	return 0;
	50	}
	51
	52	static int run_thread(thread_t t, void (f)(void))
	53	{
	54	t = CreateThread(NULL, 0, thread_run, (void **) &f, 0, NULL);
	55	return *t != NULL;
	56	}
	57
	58	static int wait_for_thread(thread_t thread)
	59	{
	60	return WaitForSingleObject(thread, INFINITE) == 0;
	61	}
	62
	63	#else
	64
	65	typedef pthread_t thread_t;
	66
	67	static void thread_run(void arg)
	68	{
	69	void (*f)(void);
	70
	71	(void *) (&f) = arg;
	72
	73	f();
	74	return NULL;
	75	}
	76
	77	static int run_thread(thread_t t, void (f)(void))
	78	{
	79	return pthread_create(t, NULL, thread_run, (void *) &f) == 0;
	80	}
	81
	82	static int wait_for_thread(thread_t thread)
	83	{
	84	return pthread_join(thread, NULL) == 0;
	85	}
	86
87	#endif
88
89	static int test_lock(void)
90	{
91	CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();
92
ee25dd45 P	93	if (!TEST_true(CRYPTO_THREAD_read_lock(lock))
ee25dd45 P	94	\|\| !TEST_true(CRYPTO_THREAD_unlock(lock)))
71a04cfc	95	return 0;
71a04cfc AG	96
	97	CRYPTO_THREAD_lock_free(lock);
	98
	99	return 1;
	100	}
	101
	102	static CRYPTO_ONCE once_run = CRYPTO_ONCE_STATIC_INIT;
	103	static unsigned once_run_count = 0;
	104
	105	static void once_do_run(void)
	106	{
	107	once_run_count++;
	108	}
	109
	110	static void once_run_thread_cb(void)
	111	{
	112	CRYPTO_THREAD_run_once(&once_run, once_do_run);
	113	}
	114
	115	static int test_once(void)
	116	{
	117	thread_t thread;
71a04cfc	118
ee25dd45 P	119	if (!TEST_true(run_thread(&thread, once_run_thread_cb))
	120	\|\| !TEST_true(wait_for_thread(thread))
	121	\|\| !CRYPTO_THREAD_run_once(&once_run, once_do_run)
	122	\|\| !TEST_int_eq(once_run_count, 1))
71a04cfc	123	return 0;
71a04cfc AG	124	return 1;
	125	}
	126
	127	static CRYPTO_THREAD_LOCAL thread_local_key;
	128	static unsigned destructor_run_count = 0;
	129	static int thread_local_thread_cb_ok = 0;
	130
	131	static void thread_local_destructor(void *arg)
	132	{
	133	unsigned *count;
	134
	135	if (arg == NULL)
	136	return;
	137
	138	count = arg;
	139
	140	(*count)++;
	141	}
	142
	143	static void thread_local_thread_cb(void)
	144	{
	145	void *ptr;
	146
	147	ptr = CRYPTO_THREAD_get_local(&thread_local_key);
ee25dd45 P	148	if (!TEST_ptr_null(ptr)
	149	\|\| !TEST_true(CRYPTO_THREAD_set_local(&thread_local_key,
	150	&destructor_run_count)))
71a04cfc	151	return;
71a04cfc AG	152
71a04cfc AG	153	ptr = CRYPTO_THREAD_get_local(&thread_local_key);
ee25dd45	154	if (!TEST_ptr_eq(ptr, &destructor_run_count))
71a04cfc	155	return;
71a04cfc AG	156
	157	thread_local_thread_cb_ok = 1;
	158	}
	159
	160	static int test_thread_local(void)
	161	{
	162	thread_t thread;
	163	void *ptr = NULL;
	164
ee25dd45 P	165	if (!TEST_true(CRYPTO_THREAD_init_local(&thread_local_key,
ee25dd45 P	166	thread_local_destructor)))
71a04cfc	167	return 0;
71a04cfc AG	168
71a04cfc AG	169	ptr = CRYPTO_THREAD_get_local(&thread_local_key);
ee25dd45 P	170	if (!TEST_ptr_null(ptr)
	171	\|\| !TEST_true(run_thread(&thread, thread_local_thread_cb))
	172	\|\| !TEST_true(wait_for_thread(thread))
	173	\|\| !TEST_int_eq(thread_local_thread_cb_ok, 1))
71a04cfc	174	return 0;
71a04cfc AG	175
	176	#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
	177
	178	ptr = CRYPTO_THREAD_get_local(&thread_local_key);
ee25dd45	179	if (!TEST_ptr_null(ptr))
71a04cfc	180	return 0;
71a04cfc AG	181
71a04cfc AG	182	# if !defined(OPENSSL_SYS_WINDOWS)
ee25dd45	183	if (!TEST_int_eq(destructor_run_count, 1))
71a04cfc	184	return 0;
71a04cfc	185	# endif
71a04cfc AG	186	#endif
71a04cfc AG	187
ee25dd45	188	if (!TEST_true(CRYPTO_THREAD_cleanup_local(&thread_local_key)))
71a04cfc	189	return 0;
71a04cfc AG	190	return 1;
	191	}
	192
ea08f8b2 MC	193	static int test_atomic(void)
	194	{
	195	int val = 0, ret = 0, testresult = 0;
	196	uint64_t val64 = 1, ret64 = 0;
	197	CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();
	198
	199	if (!TEST_ptr(lock))
	200	return 0;
	201
	202	if (CRYPTO_atomic_add(&val, 1, &ret, NULL)) {
	203	/* This succeeds therefore we're on a platform with lockless atomics */
	204	if (!TEST_int_eq(val, 1) \|\| !TEST_int_eq(val, ret))
	205	goto err;
	206	} else {
	207	/* This failed therefore we're on a platform without lockless atomics */
	208	if (!TEST_int_eq(val, 0) \|\| !TEST_int_eq(val, ret))
	209	goto err;
	210	}
	211	val = 0;
	212	ret = 0;
	213
	214	if (!TEST_true(CRYPTO_atomic_add(&val, 1, &ret, lock)))
	215	goto err;
	216	if (!TEST_int_eq(val, 1) \|\| !TEST_int_eq(val, ret))
	217	goto err;
	218
	219	if (CRYPTO_atomic_or(&val64, 2, &ret64, NULL)) {
	220	/* This succeeds therefore we're on a platform with lockless atomics */
	221	if (!TEST_uint_eq((unsigned int)val64, 3)
	222	\|\| !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
	223	goto err;
	224	} else {
	225	/* This failed therefore we're on a platform without lockless atomics */
	226	if (!TEST_uint_eq((unsigned int)val64, 1)
	227	\|\| !TEST_int_eq((unsigned int)ret64, 0))
	228	goto err;
	229	}
	230	val64 = 1;
	231	ret64 = 0;
	232
	233	if (!TEST_true(CRYPTO_atomic_or(&val64, 2, &ret64, lock)))
	234	goto err;
	235
	236	if (!TEST_uint_eq((unsigned int)val64, 3)
	237	\|\| !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
	238	goto err;
	239
	240	ret64 = 0;
	241	if (CRYPTO_atomic_load(&val64, &ret64, NULL)) {
	242	/* This succeeds therefore we're on a platform with lockless atomics */
	243	if (!TEST_uint_eq((unsigned int)val64, 3)
	244	\|\| !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
	245	goto err;
	246	} else {
	247	/* This failed therefore we're on a platform without lockless atomics */
	248	if (!TEST_uint_eq((unsigned int)val64, 3)
	249	\|\| !TEST_int_eq((unsigned int)ret64, 0))
	250	goto err;
	251	}
	252
	253	ret64 = 0;
	254	if (!TEST_true(CRYPTO_atomic_load(&val64, &ret64, lock)))
	255	goto err;
	256
257	if (!TEST_uint_eq((unsigned int)val64, 3)
258	\|\| !TEST_uint_eq((unsigned int)val64, (unsigned int)ret64))
259	goto err;
260
261	testresult = 1;
262	err:
ea08f8b2 MC	263	CRYPTO_THREAD_lock_free(lock);
	264	return testresult;
	265	}
	266
ae95a40e MC	267	static OSSL_LIB_CTX *multi_libctx = NULL;
	268	static int multi_success;
	269
b457c8f5	270	static void thread_general_worker(void)
ae95a40e MC	271	{
	272	EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
	273	EVP_MD *md = EVP_MD_fetch(multi_libctx, "SHA2-256", NULL);
	274	EVP_CIPHER_CTX *cipherctx = EVP_CIPHER_CTX_new();
	275	EVP_CIPHER *ciph = EVP_CIPHER_fetch(multi_libctx, "AES-128-CBC", NULL);
	276	const char *message = "Hello World";
	277	size_t messlen = strlen(message);
	278	/* Should be big enough for encryption output too */
	279	unsigned char out[EVP_MAX_MD_SIZE];
	280	const unsigned char key[AES_BLOCK_SIZE] = {
	281	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
	282	0x0c, 0x0d, 0x0e, 0x0f
	283	};
	284	const unsigned char iv[AES_BLOCK_SIZE] = {
	285	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
	286	0x0c, 0x0d, 0x0e, 0x0f
	287	};
	288	unsigned int mdoutl;
	289	int ciphoutl;
	290	EVP_PKEY_CTX *pctx = NULL;
	291	EVP_PKEY *pkey = NULL;
	292	int testresult = 0;
	293	int i, isfips;
	294
	295	isfips = OSSL_PROVIDER_available(multi_libctx, "fips");
	296
	297	if (!TEST_ptr(mdctx)
	298	\|\| !TEST_ptr(md)
	299	\|\| !TEST_ptr(cipherctx)
	300	\|\| !TEST_ptr(ciph))
	301	goto err;
	302
	303	/* Do some work */
	304	for (i = 0; i < 5; i++) {
	305	if (!TEST_true(EVP_DigestInit_ex(mdctx, md, NULL))
	306	\|\| !TEST_true(EVP_DigestUpdate(mdctx, message, messlen))
	307	\|\| !TEST_true(EVP_DigestFinal(mdctx, out, &mdoutl)))
	308	goto err;
	309	}
	310	for (i = 0; i < 5; i++) {
	311	if (!TEST_true(EVP_EncryptInit_ex(cipherctx, ciph, NULL, key, iv))
	312	\|\| !TEST_true(EVP_EncryptUpdate(cipherctx, out, &ciphoutl,
	313	(unsigned char *)message,
	314	messlen))
	315	\|\| !TEST_true(EVP_EncryptFinal(cipherctx, out, &ciphoutl)))
	316	goto err;
	317	}
	318
	319	pctx = EVP_PKEY_CTX_new_from_name(multi_libctx, "RSA", NULL);
	320	if (!TEST_ptr(pctx)
	321	\|\| !TEST_int_gt(EVP_PKEY_keygen_init(pctx), 0)
	322	/*
	323	* We want the test to run quickly - not securely. Therefore we
	324	* use an insecure bit length where we can (512). In the FIPS
	325	* module though we must use a longer length.
	326	*/
	327	\|\| !TEST_int_gt(EVP_PKEY_CTX_set_rsa_keygen_bits(pctx,
	328	isfips ? 2048 : 512),
	329	0)
	330	\|\| !TEST_int_gt(EVP_PKEY_keygen(pctx, &pkey), 0))
	331	goto err;
	332
	333	testresult = 1;
	334	err:
335	EVP_MD_CTX_free(mdctx);
336	EVP_MD_free(md);
337	EVP_CIPHER_CTX_free(cipherctx);
338	EVP_CIPHER_free(ciph);
339	EVP_PKEY_CTX_free(pctx);
340	EVP_PKEY_free(pkey);
341	if (!testresult)
342	multi_success = 0;
343	}
344
b457c8f5 MC	345	static void thread_multi_simple_fetch(void)
	346	{
	347	EVP_MD *md = EVP_MD_fetch(NULL, "SHA2-256", NULL);
	348
	349	if (md != NULL)
	350	EVP_MD_free(md);
	351	else
	352	multi_success = 0;
	353	}
	354
ae95a40e MC	355	/*
ae95a40e MC	356	* Do work in multiple worker threads at the same time.
b457c8f5 MC	357	* Test 0: General worker, using the default provider
	358	* Test 1: General worker, using the fips provider
	359	* Test 2: Simple fetch worker
ae95a40e MC	360	*/
	361	static int test_multi(int idx)
	362	{
	363	thread_t thread1, thread2;
	364	int testresult = 0;
	365	OSSL_PROVIDER *prov = NULL;
b457c8f5	366	void (*worker)(void);
ae95a40e MC	367
	368	if (idx == 1 && !do_fips)
	369	return TEST_skip("FIPS not supported");
	370
	371	multi_success = 1;
	372	multi_libctx = OSSL_LIB_CTX_new();
	373	if (!TEST_ptr(multi_libctx))
	374	goto err;
b457c8f5	375	prov = OSSL_PROVIDER_load(multi_libctx, (idx == 1) ? "fips" : "default");
ae95a40e MC	376	if (!TEST_ptr(prov))
	377	goto err;
	378
b457c8f5 MC	379	switch (idx) {
	380	case 0:
	381	case 1:
	382	worker = thread_general_worker;
	383	break;
	384	case 2:
	385	worker = thread_multi_simple_fetch;
	386	break;
	387	default:
	388	TEST_error("Invalid test index");
	389	goto err;
	390	}
	391
	392	if (!TEST_true(run_thread(&thread1, worker))
	393	\|\| !TEST_true(run_thread(&thread2, worker)))
ae95a40e MC	394	goto err;
ae95a40e MC	395
b457c8f5	396	worker();
ae95a40e MC	397
	398	if (!TEST_true(wait_for_thread(thread1))
	399	\|\| !TEST_true(wait_for_thread(thread2))
	400	\|\| !TEST_true(multi_success))
	401	goto err;
	402
	403	testresult = 1;
	404
	405	err:
	406	OSSL_PROVIDER_unload(prov);
	407	OSSL_LIB_CTX_free(multi_libctx);
	408	return testresult;
	409	}
	410
	411	typedef enum OPTION_choice {
	412	OPT_ERR = -1,
	413	OPT_EOF = 0,
	414	OPT_FIPS,
	415	OPT_TEST_ENUM
	416	} OPTION_CHOICE;
	417
	418	const OPTIONS *test_get_options(void)
	419	{
	420	static const OPTIONS options[] = {
	421	OPT_TEST_OPTIONS_DEFAULT_USAGE,
	422	{ "fips", OPT_FIPS, '-', "Test the FIPS provider" },
	423	{ NULL }
	424	};
	425	return options;
	426	}
	427
ad887416	428	int setup_tests(void)
71a04cfc	429	{
ae95a40e MC	430	OPTION_CHOICE o;
	431
	432	while ((o = opt_next()) != OPT_EOF) {
	433	switch (o) {
	434	case OPT_FIPS:
	435	do_fips = 1;
	436	break;
	437	case OPT_TEST_CASES:
	438	break;
	439	default:
	440	return 0;
	441	}
	442	}
	443
ee25dd45 P	444	ADD_TEST(test_lock);
	445	ADD_TEST(test_once);
	446	ADD_TEST(test_thread_local);
ea08f8b2	447	ADD_TEST(test_atomic);
b457c8f5	448	ADD_ALL_TESTS(test_multi, 3);
ad887416	449	return 1;
71a04cfc	450	}