/src/openssl31/providers/implementations/rands/test_rng.c

Source (jump to first uncovered line)
/*
 * Copyright 2020-2023 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
 */

#include <string.h>
#include <stdlib.h>
#include <openssl/core_dispatch.h>
#include <openssl/e_os2.h>
#include <openssl/params.h>
#include <openssl/core_names.h>
#include <openssl/evp.h>
#include <openssl/err.h>
#include <openssl/randerr.h>
#include "prov/providercommon.h"
#include "prov/provider_ctx.h"
#include "prov/provider_util.h"
#include "prov/implementations.h"

static OSSL_FUNC_rand_newctx_fn test_rng_new;
static OSSL_FUNC_rand_freectx_fn test_rng_free;
static OSSL_FUNC_rand_instantiate_fn test_rng_instantiate;
static OSSL_FUNC_rand_uninstantiate_fn test_rng_uninstantiate;
static OSSL_FUNC_rand_generate_fn test_rng_generate;
static OSSL_FUNC_rand_reseed_fn test_rng_reseed;
static OSSL_FUNC_rand_nonce_fn test_rng_nonce;
static OSSL_FUNC_rand_settable_ctx_params_fn test_rng_settable_ctx_params;
static OSSL_FUNC_rand_set_ctx_params_fn test_rng_set_ctx_params;
static OSSL_FUNC_rand_gettable_ctx_params_fn test_rng_gettable_ctx_params;
static OSSL_FUNC_rand_get_ctx_params_fn test_rng_get_ctx_params;
static OSSL_FUNC_rand_verify_zeroization_fn test_rng_verify_zeroization;
static OSSL_FUNC_rand_enable_locking_fn test_rng_enable_locking;
static OSSL_FUNC_rand_lock_fn test_rng_lock;
static OSSL_FUNC_rand_unlock_fn test_rng_unlock;
static OSSL_FUNC_rand_get_seed_fn test_rng_get_seed;

typedef struct {
    void *provctx;
    unsigned int generate;
    int state;
    unsigned int strength;
    size_t max_request;
    unsigned char *entropy, *nonce;
    size_t entropy_len, entropy_pos, nonce_len;
    CRYPTO_RWLOCK *lock;
    uint32_t seed;
} PROV_TEST_RNG;

static void *test_rng_new(void *provctx, void *parent,
                          const OSSL_DISPATCH *parent_dispatch)
{
    PROV_TEST_RNG *t;

    t = OPENSSL_zalloc(sizeof(*t));
    if (t == NULL)
        return NULL;

    t->max_request = INT_MAX;
    t->provctx = provctx;
    t->state = EVP_RAND_STATE_UNINITIALISED;
    return t;
}

static void test_rng_free(void *vtest)
{
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;

    if (t == NULL)
        return;
    OPENSSL_free(t->entropy);
    OPENSSL_free(t->nonce);
    CRYPTO_THREAD_lock_free(t->lock);
    OPENSSL_free(t);
}

static int test_rng_instantiate(void *vtest, unsigned int strength,
                                int prediction_resistance,
                                const unsigned char *pstr, size_t pstr_len,
                                const OSSL_PARAM params[])
{
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;

    if (!test_rng_set_ctx_params(t, params) || strength > t->strength)
        return 0;

    t->state = EVP_RAND_STATE_READY;
    t->entropy_pos = 0;
    t->seed = 221953166;    /* Value doesn't matter, so long as it isn't zero */

    return 1;
}

static int test_rng_uninstantiate(void *vtest)
{
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;

    t->entropy_pos = 0;
    t->state = EVP_RAND_STATE_UNINITIALISED;
    return 1;
}

static unsigned char gen_byte(PROV_TEST_RNG *t)
{
    uint32_t n;

    /*
     * Implement the 32 bit xorshift as suggested by George Marsaglia in:
     *      https://doi.org/10.18637/jss.v008.i14
     *
     * This is a very fast PRNG so there is no need to extract bytes one at a
     * time and use the entire value each time.
     */
    n = t->seed;
    n ^= n << 13;
    n ^= n >> 17;
    n ^= n << 5;
    t->seed = n;

    return n & 0xff;
}

static int test_rng_generate(void *vtest, unsigned char *out, size_t outlen,
                             unsigned int strength, int prediction_resistance,
                             const unsigned char *adin, size_t adin_len)
{
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
    size_t i;

    if (strength > t->strength)
        return 0;
    if (t->generate) {
        for (i = 0; i < outlen; i++)
            out[i] = gen_byte(t);
    } else {
        if (t->entropy_len - t->entropy_pos < outlen)
            return 0;

        memcpy(out, t->entropy + t->entropy_pos, outlen);
        t->entropy_pos += outlen;
    }
    return 1;
}

static int test_rng_reseed(ossl_unused void *vtest,
                           ossl_unused int prediction_resistance,
                           ossl_unused const unsigned char *ent,
                           ossl_unused size_t ent_len,
                           ossl_unused const unsigned char *adin,
                           ossl_unused size_t adin_len)
{
    return 1;
}

static size_t test_rng_nonce(void *vtest, unsigned char *out,
                             unsigned int strength, size_t min_noncelen,
                             ossl_unused size_t max_noncelen)
{
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
    size_t i;

    if (strength > t->strength)
        return 0;

    if (t->generate) {
        for (i = 0; i < min_noncelen; i++)
            out[i] = gen_byte(t);
        return min_noncelen;
    }

    if (t->nonce == NULL)
        return 0;
    if (out != NULL)
        memcpy(out, t->nonce, t->nonce_len);
    return t->nonce_len;
}

static int test_rng_get_ctx_params(void *vtest, OSSL_PARAM params[])
{
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
    OSSL_PARAM *p;

    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STATE);
    if (p != NULL && !OSSL_PARAM_set_int(p, t->state))
        return 0;

    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STRENGTH);
    if (p != NULL && !OSSL_PARAM_set_int(p, t->strength))
        return 0;

    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST);
    if (p != NULL && !OSSL_PARAM_set_size_t(p, t->max_request))
        return 0;

    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_GENERATE);
    if (p != NULL && OSSL_PARAM_set_uint(p, t->generate))
        return 0;
    return 1;
}

static const OSSL_PARAM *test_rng_gettable_ctx_params(ossl_unused void *vtest,
                                                      ossl_unused void *provctx)
{
    static const OSSL_PARAM known_gettable_ctx_params[] = {
        OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
        OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
        OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
        OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
        OSSL_PARAM_END
    };
    return known_gettable_ctx_params;
}

static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[])
{
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
    const OSSL_PARAM *p;
    void *ptr = NULL;
    size_t size = 0;

    if (params == NULL)
        return 1;

    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_STRENGTH);
    if (p != NULL && !OSSL_PARAM_get_uint(p, &t->strength))
        return 0;

    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_ENTROPY);
    if (p != NULL) {
        if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
            return 0;
        OPENSSL_free(t->entropy);
        t->entropy = ptr;
        t->entropy_len = size;
        t->entropy_pos = 0;
        ptr = NULL;
    }

    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_NONCE);
    if (p != NULL) {
        if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
            return 0;
        OPENSSL_free(t->nonce);
        t->nonce = ptr;
        t->nonce_len = size;
    }

    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_MAX_REQUEST);
    if (p != NULL && !OSSL_PARAM_get_size_t(p, &t->max_request))
        return 0;

    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_GENERATE);
    if (p != NULL && !OSSL_PARAM_get_uint(p, &t->generate))
        return 0;
    return 1;
}

static const OSSL_PARAM *test_rng_settable_ctx_params(ossl_unused void *vtest,
                                                      ossl_unused void *provctx)
{
    static const OSSL_PARAM known_settable_ctx_params[] = {
        OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, NULL, 0),
        OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_NONCE, NULL, 0),
        OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
        OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
        OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
        OSSL_PARAM_END
    };
    return known_settable_ctx_params;
}

static int test_rng_verify_zeroization(ossl_unused void *vtest)
{
    return 1;
}

static size_t test_rng_get_seed(void *vtest, unsigned char **pout,
                                int entropy, size_t min_len, size_t max_len,
                                ossl_unused int prediction_resistance,
                                ossl_unused const unsigned char *adin,
                                ossl_unused size_t adin_len)
{
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;

    *pout = t->entropy;
    return  t->entropy_len > max_len ? max_len : t->entropy_len;
}

static int test_rng_enable_locking(void *vtest)
{
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;

    if (t != NULL && t->lock == NULL) {
        t->lock = CRYPTO_THREAD_lock_new();
        if (t->lock == NULL) {
            ERR_raise(ERR_LIB_PROV, RAND_R_FAILED_TO_CREATE_LOCK);
            return 0;
        }
    }
    return 1;
}

static int test_rng_lock(void *vtest)
{
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;

    if (t == NULL || t->lock == NULL)
        return 1;
    return CRYPTO_THREAD_write_lock(t->lock);
}

static void test_rng_unlock(void *vtest)
{
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;

    if (t != NULL && t->lock != NULL)
        CRYPTO_THREAD_unlock(t->lock);
}

const OSSL_DISPATCH ossl_test_rng_functions[] = {
    { OSSL_FUNC_RAND_NEWCTX, (void(*)(void))test_rng_new },
    { OSSL_FUNC_RAND_FREECTX, (void(*)(void))test_rng_free },
    { OSSL_FUNC_RAND_INSTANTIATE,
      (void(*)(void))test_rng_instantiate },
    { OSSL_FUNC_RAND_UNINSTANTIATE,
      (void(*)(void))test_rng_uninstantiate },
    { OSSL_FUNC_RAND_GENERATE, (void(*)(void))test_rng_generate },
    { OSSL_FUNC_RAND_RESEED, (void(*)(void))test_rng_reseed },
    { OSSL_FUNC_RAND_NONCE, (void(*)(void))test_rng_nonce },
    { OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))test_rng_enable_locking },
    { OSSL_FUNC_RAND_LOCK, (void(*)(void))test_rng_lock },
    { OSSL_FUNC_RAND_UNLOCK, (void(*)(void))test_rng_unlock },
    { OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS,
      (void(*)(void))test_rng_settable_ctx_params },
    { OSSL_FUNC_RAND_SET_CTX_PARAMS, (void(*)(void))test_rng_set_ctx_params },
    { OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS,
      (void(*)(void))test_rng_gettable_ctx_params },
    { OSSL_FUNC_RAND_GET_CTX_PARAMS, (void(*)(void))test_rng_get_ctx_params },
    { OSSL_FUNC_RAND_VERIFY_ZEROIZATION,
      (void(*)(void))test_rng_verify_zeroization },
    { OSSL_FUNC_RAND_GET_SEED, (void(*)(void))test_rng_get_seed },
    { 0, NULL }
};

Coverage Report

Created: 2025-06-13 06:58

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 2020-2023 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (the "License"). You may not use
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
8		*/
9
10		#include <string.h>
11		#include <stdlib.h>
12		#include <openssl/core_dispatch.h>
13		#include <openssl/e_os2.h>
14		#include <openssl/params.h>
15		#include <openssl/core_names.h>
16		#include <openssl/evp.h>
17		#include <openssl/err.h>
18		#include <openssl/randerr.h>
19		#include "prov/providercommon.h"
20		#include "prov/provider_ctx.h"
21		#include "prov/provider_util.h"
22		#include "prov/implementations.h"
23
24		static OSSL_FUNC_rand_newctx_fn test_rng_new;
25		static OSSL_FUNC_rand_freectx_fn test_rng_free;
26		static OSSL_FUNC_rand_instantiate_fn test_rng_instantiate;
27		static OSSL_FUNC_rand_uninstantiate_fn test_rng_uninstantiate;
28		static OSSL_FUNC_rand_generate_fn test_rng_generate;
29		static OSSL_FUNC_rand_reseed_fn test_rng_reseed;
30		static OSSL_FUNC_rand_nonce_fn test_rng_nonce;
31		static OSSL_FUNC_rand_settable_ctx_params_fn test_rng_settable_ctx_params;
32		static OSSL_FUNC_rand_set_ctx_params_fn test_rng_set_ctx_params;
33		static OSSL_FUNC_rand_gettable_ctx_params_fn test_rng_gettable_ctx_params;
34		static OSSL_FUNC_rand_get_ctx_params_fn test_rng_get_ctx_params;
35		static OSSL_FUNC_rand_verify_zeroization_fn test_rng_verify_zeroization;
36		static OSSL_FUNC_rand_enable_locking_fn test_rng_enable_locking;
37		static OSSL_FUNC_rand_lock_fn test_rng_lock;
38		static OSSL_FUNC_rand_unlock_fn test_rng_unlock;
39		static OSSL_FUNC_rand_get_seed_fn test_rng_get_seed;
40
41		typedef struct {
42		void *provctx;
43		unsigned int generate;
44		int state;
45		unsigned int strength;
46		size_t max_request;
47		unsigned char entropy, nonce;
48		size_t entropy_len, entropy_pos, nonce_len;
49		CRYPTO_RWLOCK *lock;
50		uint32_t seed;
51		} PROV_TEST_RNG;
52
53		static void test_rng_new(void provctx, void *parent,
54		const OSSL_DISPATCH *parent_dispatch)
55	60	{
56	60	PROV_TEST_RNG *t;
57
58	60	t = OPENSSL_zalloc(sizeof(*t));
59	60	if (t == NULL)
60	0	return NULL;
61
62	60	t->max_request = INT_MAX;
63	60	t->provctx = provctx;
64	60	t->state = EVP_RAND_STATE_UNINITIALISED;
65	60	return t;
66	60	}
67
68		static void test_rng_free(void *vtest)
69	60	{
70	60	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
71
72	60	if (t == NULL)
73	0	return;
74	60	OPENSSL_free(t->entropy);
75	60	OPENSSL_free(t->nonce);
76	60	CRYPTO_THREAD_lock_free(t->lock);
77	60	OPENSSL_free(t);
78	60	}
79
80		static int test_rng_instantiate(void *vtest, unsigned int strength,
81		int prediction_resistance,
82		const unsigned char *pstr, size_t pstr_len,
83		const OSSL_PARAM params[])
84	0	{
85	0	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
86
87	0	if (!test_rng_set_ctx_params(t, params) \|\| strength > t->strength)
88	0	return 0;
89
90	0	t->state = EVP_RAND_STATE_READY;
91	0	t->entropy_pos = 0;
92	0	t->seed = 221953166; /* Value doesn't matter, so long as it isn't zero */
93
94	0	return 1;
95	0	}
96
97		static int test_rng_uninstantiate(void *vtest)
98	0	{
99	0	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
100
101	0	t->entropy_pos = 0;
102	0	t->state = EVP_RAND_STATE_UNINITIALISED;
103	0	return 1;
104	0	}
105
106		static unsigned char gen_byte(PROV_TEST_RNG *t)
107	49.1k	{
108	49.1k	uint32_t n;
109
110		/*
111		* Implement the 32 bit xorshift as suggested by George Marsaglia in:
112		* https://doi.org/10.18637/jss.v008.i14
113		*
114		* This is a very fast PRNG so there is no need to extract bytes one at a
115		* time and use the entire value each time.
116		*/
117	49.1k	n = t->seed;
118	49.1k	n ^= n << 13;
119	49.1k	n ^= n >> 17;
120	49.1k	n ^= n << 5;
121	49.1k	t->seed = n;
122
123	49.1k	return n & 0xff;
124	49.1k	}
125
126		static int test_rng_generate(void vtest, unsigned char out, size_t outlen,
127		unsigned int strength, int prediction_resistance,
128		const unsigned char *adin, size_t adin_len)
129	10.2k	{
130	10.2k	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
131	10.2k	size_t i;
132
133	10.2k	if (strength > t->strength)
134	0	return 0;
135	10.2k	if (t->generate) {
136	53.8k	for (i = 0; i < outlen; i++)
137	49.1k	out[i] = gen_byte(t);
138	5.53k	} else {
139	5.53k	if (t->entropy_len - t->entropy_pos < outlen)
140	23	return 0;
141
142	5.50k	memcpy(out, t->entropy + t->entropy_pos, outlen);
143	5.50k	t->entropy_pos += outlen;
144	5.50k	}
145	10.2k	return 1;
146	10.2k	}
147
148		static int test_rng_reseed(ossl_unused void *vtest,
149		ossl_unused int prediction_resistance,
150		ossl_unused const unsigned char *ent,
151		ossl_unused size_t ent_len,
152		ossl_unused const unsigned char *adin,
153		ossl_unused size_t adin_len)
154	29	{
155	29	return 1;
156	29	}
157
158		static size_t test_rng_nonce(void vtest, unsigned char out,
159		unsigned int strength, size_t min_noncelen,
160		ossl_unused size_t max_noncelen)
161	0	{
162	0	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
163	0	size_t i;
164
165	0	if (strength > t->strength)
166	0	return 0;
167
168	0	if (t->generate) {
169	0	for (i = 0; i < min_noncelen; i++)
170	0	out[i] = gen_byte(t);
171	0	return min_noncelen;
172	0	}
173
174	0	if (t->nonce == NULL)
175	0	return 0;
176	0	if (out != NULL)
177	0	memcpy(out, t->nonce, t->nonce_len);
178	0	return t->nonce_len;
179	0	}
180
181		static int test_rng_get_ctx_params(void *vtest, OSSL_PARAM params[])
182	0	{
183	0	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
184	0	OSSL_PARAM *p;
185
186	0	p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STATE);
187	0	if (p != NULL && !OSSL_PARAM_set_int(p, t->state))
188	0	return 0;
189
190	0	p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STRENGTH);
191	0	if (p != NULL && !OSSL_PARAM_set_int(p, t->strength))
192	0	return 0;
193
194	0	p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST);
195	0	if (p != NULL && !OSSL_PARAM_set_size_t(p, t->max_request))
196	0	return 0;
197
198	0	p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_GENERATE);
199	0	if (p != NULL && OSSL_PARAM_set_uint(p, t->generate))
200	0	return 0;
201	0	return 1;
202	0	}
203
204		static const OSSL_PARAM test_rng_gettable_ctx_params(ossl_unused void vtest,
205		ossl_unused void *provctx)
206	0	{
207	0	static const OSSL_PARAM known_gettable_ctx_params[] = {
208	0	OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
209	0	OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
210	0	OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
211	0	OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
212	0	OSSL_PARAM_END
213	0	};
214	0	return known_gettable_ctx_params;
215	0	}
216
217		static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[])
218		{
219		PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
220		const OSSL_PARAM *p;
221		void *ptr = NULL;
222		size_t size = 0;
223
224		if (params == NULL)
225		return 1;
226
227		p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_STRENGTH);
228		if (p != NULL && !OSSL_PARAM_get_uint(p, &t->strength))
229		return 0;
230
231		p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_ENTROPY);
232		if (p != NULL) {
233		if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
234		return 0;
235		OPENSSL_free(t->entropy);
236		t->entropy = ptr;
237		t->entropy_len = size;
238		t->entropy_pos = 0;
239		ptr = NULL;
240		}
241
242		p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_NONCE);
243		if (p != NULL) {
244		if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
245		return 0;
246		OPENSSL_free(t->nonce);
247		t->nonce = ptr;
248		t->nonce_len = size;
249		}
250
251		p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_MAX_REQUEST);
252		if (p != NULL && !OSSL_PARAM_get_size_t(p, &t->max_request))
253		return 0;
254
255		p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_GENERATE);
256		if (p != NULL && !OSSL_PARAM_get_uint(p, &t->generate))
257		return 0;
258		return 1;
259		}
260
261		static const OSSL_PARAM test_rng_settable_ctx_params(ossl_unused void vtest,
262		ossl_unused void *provctx)
263	60	{
264	60	static const OSSL_PARAM known_settable_ctx_params[] = {
265	60	OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, NULL, 0),
266	60	OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_NONCE, NULL, 0),
267	60	OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
268	60	OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
269	60	OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
270	60	OSSL_PARAM_END
271	60	};
272	60	return known_settable_ctx_params;
273	60	}
274
275		static int test_rng_verify_zeroization(ossl_unused void *vtest)
276	0	{
277	0	return 1;
278	0	}
279
280		static size_t test_rng_get_seed(void vtest, unsigned char *pout,
281		int entropy, size_t min_len, size_t max_len,
282		ossl_unused int prediction_resistance,
283		ossl_unused const unsigned char *adin,
284		ossl_unused size_t adin_len)
285	0	{
286	0	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
287
288	0	*pout = t->entropy;
289	0	return t->entropy_len > max_len ? max_len : t->entropy_len;
290	0	}
291
292		static int test_rng_enable_locking(void *vtest)
293	0	{
294	0	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
295
296	0	if (t != NULL && t->lock == NULL) {
297	0	t->lock = CRYPTO_THREAD_lock_new();
298	0	if (t->lock == NULL) {
299	0	ERR_raise(ERR_LIB_PROV, RAND_R_FAILED_TO_CREATE_LOCK);
300	0	return 0;
301	0	}
302	0	}
303	0	return 1;
304	0	}
305
306		static int test_rng_lock(void *vtest)
307	149	{
308	149	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
309
310	149	if (t == NULL \|\| t->lock == NULL)
311	149	return 1;
312	0	return CRYPTO_THREAD_write_lock(t->lock);
313	149	}
314
315		static void test_rng_unlock(void *vtest)
316	149	{
317	149	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
318
319	149	if (t != NULL && t->lock != NULL)
320	0	CRYPTO_THREAD_unlock(t->lock);
321	149	}
322
323		const OSSL_DISPATCH ossl_test_rng_functions[] = {
324		{ OSSL_FUNC_RAND_NEWCTX, (void(*)(void))test_rng_new },
325		{ OSSL_FUNC_RAND_FREECTX, (void(*)(void))test_rng_free },
326		{ OSSL_FUNC_RAND_INSTANTIATE,
327		(void(*)(void))test_rng_instantiate },
328		{ OSSL_FUNC_RAND_UNINSTANTIATE,
329		(void(*)(void))test_rng_uninstantiate },
330		{ OSSL_FUNC_RAND_GENERATE, (void(*)(void))test_rng_generate },
331		{ OSSL_FUNC_RAND_RESEED, (void(*)(void))test_rng_reseed },
332		{ OSSL_FUNC_RAND_NONCE, (void(*)(void))test_rng_nonce },
333		{ OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))test_rng_enable_locking },
334		{ OSSL_FUNC_RAND_LOCK, (void(*)(void))test_rng_lock },
335		{ OSSL_FUNC_RAND_UNLOCK, (void(*)(void))test_rng_unlock },
336		{ OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS,
337		(void(*)(void))test_rng_settable_ctx_params },
338		{ OSSL_FUNC_RAND_SET_CTX_PARAMS, (void(*)(void))test_rng_set_ctx_params },
339		{ OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS,
340		(void(*)(void))test_rng_gettable_ctx_params },
341		{ OSSL_FUNC_RAND_GET_CTX_PARAMS, (void(*)(void))test_rng_get_ctx_params },
342		{ OSSL_FUNC_RAND_VERIFY_ZEROIZATION,
343		(void(*)(void))test_rng_verify_zeroization },
344		{ OSSL_FUNC_RAND_GET_SEED, (void(*)(void))test_rng_get_seed },
345		{ 0, NULL }
346		};