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

Source
/*
 * Copyright 2020-2025 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
 */
/* clang-format off */

/* clang-format on */

#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/proverr.h>
#include <openssl/randerr.h>
#include "internal/common.h"
#include "prov/securitycheck.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,
    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;
    i = t->nonce_len > max_noncelen ? max_noncelen : t->nonce_len;
    if (out != NULL)
        memcpy(out, t->nonce, i);
    return i;
}

/* clang-format off */
/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef test_rng_get_ctx_params_list
static const OSSL_PARAM test_rng_get_ctx_params_list[] = {
    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),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef test_rng_get_ctx_params_st
struct test_rng_get_ctx_params_st {
    OSSL_PARAM *gen;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind;
# endif
    OSSL_PARAM *maxreq;
    OSSL_PARAM *state;
    OSSL_PARAM *str;
};
#endif

#ifndef test_rng_get_ctx_params_decoder
static int test_rng_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct test_rng_get_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'f':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
                    /* OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR */
                    if (ossl_unlikely(r->ind != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ind = (OSSL_PARAM *)p;
                }
# endif
                break;
            case 'g':
                if (ossl_likely(strcmp("enerate", s + 1) == 0)) {
                    /* OSSL_RAND_PARAM_GENERATE */
                    if (ossl_unlikely(r->gen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->gen = (OSSL_PARAM *)p;
                }
                break;
            case 'm':
                if (ossl_likely(strcmp("ax_request", s + 1) == 0)) {
                    /* OSSL_RAND_PARAM_MAX_REQUEST */
                    if (ossl_unlikely(r->maxreq != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->maxreq = (OSSL_PARAM *)p;
                }
                break;
            case 's':
                switch(s[1]) {
                default:
                    break;
                case 't':
                    switch(s[2]) {
                    default:
                        break;
                    case 'a':
                        if (ossl_likely(strcmp("te", s + 3) == 0)) {
                            /* OSSL_RAND_PARAM_STATE */
                            if (ossl_unlikely(r->state != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->state = (OSSL_PARAM *)p;
                        }
                        break;
                    case 'r':
                        if (ossl_likely(strcmp("ength", s + 3) == 0)) {
                            /* OSSL_RAND_PARAM_STRENGTH */
                            if (ossl_unlikely(r->str != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->str = (OSSL_PARAM *)p;
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */
/* clang-format on */

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

    if (t == NULL || !test_rng_get_ctx_params_decoder(params, &p))
        return 0;

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

    if (p.str != NULL && !OSSL_PARAM_set_uint(p.str, t->strength))
        return 0;

    if (p.maxreq != NULL && !OSSL_PARAM_set_size_t(p.maxreq, t->max_request))
        return 0;

    if (p.gen != NULL && !OSSL_PARAM_set_uint(p.gen, t->generate))
        return 0;

#ifdef FIPS_MODULE
    if (p.ind != NULL && !OSSL_PARAM_set_int(p.ind, 0))
        return 0;
#endif /* FIPS_MODULE */

    return 1;
}

static const OSSL_PARAM *test_rng_gettable_ctx_params(ossl_unused void *vtest,
    ossl_unused void *provctx)
{
    return test_rng_get_ctx_params_list;
}

/* clang-format off */
/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef test_rng_set_ctx_params_list
static const OSSL_PARAM test_rng_set_ctx_params_list[] = {
    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
};
#endif

#ifndef test_rng_set_ctx_params_st
struct test_rng_set_ctx_params_st {
    OSSL_PARAM *ent;
    OSSL_PARAM *gen;
    OSSL_PARAM *maxreq;
    OSSL_PARAM *nonce;
    OSSL_PARAM *str;
};
#endif

#ifndef test_rng_set_ctx_params_decoder
static int test_rng_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct test_rng_set_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'g':
                if (ossl_likely(strcmp("enerate", s + 1) == 0)) {
                    /* OSSL_RAND_PARAM_GENERATE */
                    if (ossl_unlikely(r->gen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->gen = (OSSL_PARAM *)p;
                }
                break;
            case 'm':
                if (ossl_likely(strcmp("ax_request", s + 1) == 0)) {
                    /* OSSL_RAND_PARAM_MAX_REQUEST */
                    if (ossl_unlikely(r->maxreq != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->maxreq = (OSSL_PARAM *)p;
                }
                break;
            case 's':
                if (ossl_likely(strcmp("trength", s + 1) == 0)) {
                    /* OSSL_RAND_PARAM_STRENGTH */
                    if (ossl_unlikely(r->str != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->str = (OSSL_PARAM *)p;
                }
                break;
            case 't':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    switch(s[2]) {
                    default:
                        break;
                    case 's':
                        switch(s[3]) {
                        default:
                            break;
                        case 't':
                            switch(s[4]) {
                            default:
                                break;
                            case '_':
                                switch(s[5]) {
                                default:
                                    break;
                                case 'e':
                                    if (ossl_likely(strcmp("ntropy", s + 6) == 0)) {
                                        /* OSSL_RAND_PARAM_TEST_ENTROPY */
                                        if (ossl_unlikely(r->ent != NULL)) {
                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                           "param %s is repeated", s);
                                            return 0;
                                        }
                                        r->ent = (OSSL_PARAM *)p;
                                    }
                                    break;
                                case 'n':
                                    if (ossl_likely(strcmp("once", s + 6) == 0)) {
                                        /* OSSL_RAND_PARAM_TEST_NONCE */
                                        if (ossl_unlikely(r->nonce != NULL)) {
                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                           "param %s is repeated", s);
                                            return 0;
                                        }
                                        r->nonce = (OSSL_PARAM *)p;
                                    }
                                }
                            }
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */
/* clang-format on */

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

    if (t == NULL || !test_rng_set_ctx_params_decoder(params, &p))
        return 0;

    if (p.str != NULL && !OSSL_PARAM_get_uint(p.str, &t->strength))
        return 0;

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

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

    if (p.maxreq != NULL && !OSSL_PARAM_get_size_t(p.maxreq, &t->max_request))
        return 0;

    if (p.gen != NULL && !OSSL_PARAM_get_uint(p.gen, &t->generate))
        return 0;
    return 1;
}

static const OSSL_PARAM *test_rng_settable_ctx_params(ossl_unused void *vtest,
    ossl_unused void *provctx)
{
    return test_rng_set_ctx_params_list;
}

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 },
    OSSL_DISPATCH_END
};

Coverage Report

Created: 2025-12-31 06:58

Line	Count	Source
1		/*
2		* Copyright 2020-2025 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		/* clang-format off */
10
11		/* clang-format on */
12
13		#include <string.h>
14		#include <stdlib.h>
15		#include <openssl/core_dispatch.h>
16		#include <openssl/e_os2.h>
17		#include <openssl/params.h>
18		#include <openssl/core_names.h>
19		#include <openssl/evp.h>
20		#include <openssl/err.h>
21		#include <openssl/proverr.h>
22		#include <openssl/randerr.h>
23		#include "internal/common.h"
24		#include "prov/securitycheck.h"
25		#include "prov/providercommon.h"
26		#include "prov/provider_ctx.h"
27		#include "prov/provider_util.h"
28		#include "prov/implementations.h"
29
30		static OSSL_FUNC_rand_newctx_fn test_rng_new;
31		static OSSL_FUNC_rand_freectx_fn test_rng_free;
32		static OSSL_FUNC_rand_instantiate_fn test_rng_instantiate;
33		static OSSL_FUNC_rand_uninstantiate_fn test_rng_uninstantiate;
34		static OSSL_FUNC_rand_generate_fn test_rng_generate;
35		static OSSL_FUNC_rand_reseed_fn test_rng_reseed;
36		static OSSL_FUNC_rand_nonce_fn test_rng_nonce;
37		static OSSL_FUNC_rand_settable_ctx_params_fn test_rng_settable_ctx_params;
38		static OSSL_FUNC_rand_set_ctx_params_fn test_rng_set_ctx_params;
39		static OSSL_FUNC_rand_gettable_ctx_params_fn test_rng_gettable_ctx_params;
40		static OSSL_FUNC_rand_get_ctx_params_fn test_rng_get_ctx_params;
41		static OSSL_FUNC_rand_verify_zeroization_fn test_rng_verify_zeroization;
42		static OSSL_FUNC_rand_enable_locking_fn test_rng_enable_locking;
43		static OSSL_FUNC_rand_lock_fn test_rng_lock;
44		static OSSL_FUNC_rand_unlock_fn test_rng_unlock;
45		static OSSL_FUNC_rand_get_seed_fn test_rng_get_seed;
46
47		typedef struct {
48		void *provctx;
49		unsigned int generate;
50		int state;
51		unsigned int strength;
52		size_t max_request;
53		unsigned char entropy, nonce;
54		size_t entropy_len, entropy_pos, nonce_len;
55		CRYPTO_RWLOCK *lock;
56		uint32_t seed;
57		} PROV_TEST_RNG;
58
59		static void test_rng_new(void provctx, void *parent,
60		const OSSL_DISPATCH *parent_dispatch)
61	229	{
62	229	PROV_TEST_RNG *t;
63
64	229	t = OPENSSL_zalloc(sizeof(*t));
65	229	if (t == NULL)
66	0	return NULL;
67
68	229	t->max_request = INT_MAX;
69	229	t->provctx = provctx;
70	229	t->state = EVP_RAND_STATE_UNINITIALISED;
71	229	return t;
72	229	}
73
74		static void test_rng_free(void *vtest)
75	229	{
76	229	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
77
78	229	if (t == NULL)
79	0	return;
80	229	OPENSSL_free(t->entropy);
81	229	OPENSSL_free(t->nonce);
82	229	CRYPTO_THREAD_lock_free(t->lock);
83	229	OPENSSL_free(t);
84	229	}
85
86		static int test_rng_instantiate(void *vtest, unsigned int strength,
87		int prediction_resistance,
88		const unsigned char *pstr, size_t pstr_len,
89		const OSSL_PARAM params[])
90	0	{
91	0	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
92
93	0	if (!test_rng_set_ctx_params(t, params) \|\| strength > t->strength)
94	0	return 0;
95
96	0	t->state = EVP_RAND_STATE_READY;
97	0	t->entropy_pos = 0;
98	0	t->seed = 221953166; /* Value doesn't matter, so long as it isn't zero */
99
100	0	return 1;
101	0	}
102
103		static int test_rng_uninstantiate(void *vtest)
104	0	{
105	0	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
106
107	0	t->entropy_pos = 0;
108	0	t->state = EVP_RAND_STATE_UNINITIALISED;
109	0	return 1;
110	0	}
111
112		static unsigned char gen_byte(PROV_TEST_RNG *t)
113	212k	{
114	212k	uint32_t n;
115
116		/*
117		* Implement the 32 bit xorshift as suggested by George Marsaglia in:
118		* https://doi.org/10.18637/jss.v008.i14
119		*
120		* This is a very fast PRNG so there is no need to extract bytes one at a
121		* time and use the entire value each time.
122		*/
123	212k	n = t->seed;
124	212k	n ^= n << 13;
125	212k	n ^= n >> 17;
126	212k	n ^= n << 5;
127	212k	t->seed = n;
128
129	212k	return n & 0xff;
130	212k	}
131
132		static int test_rng_generate(void vtest, unsigned char out, size_t outlen,
133		unsigned int strength, int prediction_resistance,
134		const unsigned char *adin, size_t adin_len)
135	47.0k	{
136	47.0k	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
137	47.0k	size_t i;
138
139	47.0k	if (strength > t->strength)
140	0	return 0;
141	47.0k	if (t->generate) {
142	232k	for (i = 0; i < outlen; i++)
143	212k	out[i] = gen_byte(t);
144	27.4k	} else {
145	27.4k	if (t->entropy_len - t->entropy_pos < outlen)
146	99	return 0;
147
148	27.3k	memcpy(out, t->entropy + t->entropy_pos, outlen);
149	27.3k	t->entropy_pos += outlen;
150	27.3k	}
151	46.9k	return 1;
152	47.0k	}
153
154		static int test_rng_reseed(ossl_unused void *vtest,
155		ossl_unused int prediction_resistance,
156		ossl_unused const unsigned char *ent,
157		ossl_unused size_t ent_len,
158		ossl_unused const unsigned char *adin,
159		ossl_unused size_t adin_len)
160	92	{
161	92	return 1;
162	92	}
163
164		static size_t test_rng_nonce(void vtest, unsigned char out,
165		unsigned int strength, size_t min_noncelen,
166		size_t max_noncelen)
167	0	{
168	0	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
169	0	size_t i;
170
171	0	if (strength > t->strength)
172	0	return 0;
173
174	0	if (t->generate) {
175	0	for (i = 0; i < min_noncelen; i++)
176	0	out[i] = gen_byte(t);
177	0	return min_noncelen;
178	0	}
179
180	0	if (t->nonce == NULL)
181	0	return 0;
182	0	i = t->nonce_len > max_noncelen ? max_noncelen : t->nonce_len;
183	0	if (out != NULL)
184	0	memcpy(out, t->nonce, i);
185	0	return i;
186	0	}
187
188		/* clang-format off */
189		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
190		#ifndef test_rng_get_ctx_params_list
191		static const OSSL_PARAM test_rng_get_ctx_params_list[] = {
192		OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
193		OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
194		OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
195		OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
196		# if defined(FIPS_MODULE)
197		OSSL_PARAM_int(OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR, NULL),
198		# endif
199		OSSL_PARAM_END
200		};
201		#endif
202
203		#ifndef test_rng_get_ctx_params_st
204		struct test_rng_get_ctx_params_st {
205		OSSL_PARAM *gen;
206		# if defined(FIPS_MODULE)
207		OSSL_PARAM *ind;
208		# endif
209		OSSL_PARAM *maxreq;
210		OSSL_PARAM *state;
211		OSSL_PARAM *str;
212		};
213		#endif
214
215		#ifndef test_rng_get_ctx_params_decoder
216		static int test_rng_get_ctx_params_decoder
217		(const OSSL_PARAM p, struct test_rng_get_ctx_params_st r)
218	118	{
219	118	const char *s;
220
221	118	memset(r, 0, sizeof(*r));
222	118	if (p != NULL)
223	236	for (; (s = p->key) != NULL; p++)
224	118	switch(s[0]) {
225	0	default:
226	0	break;
227	0	case 'f':
228		# if defined(FIPS_MODULE)
229		if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
230		/* OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR */
231		if (ossl_unlikely(r->ind != NULL)) {
232		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
233		"param %s is repeated", s);
234		return 0;
235		}
236		r->ind = (OSSL_PARAM *)p;
237		}
238		# endif
239	0	break;
240	0	case 'g':
241	0	if (ossl_likely(strcmp("enerate", s + 1) == 0)) {
242		/* OSSL_RAND_PARAM_GENERATE */
243	0	if (ossl_unlikely(r->gen != NULL)) {
244	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
245	0	"param %s is repeated", s);
246	0	return 0;
247	0	}
248	0	r->gen = (OSSL_PARAM *)p;
249	0	}
250	0	break;
251	118	case 'm':
252	118	if (ossl_likely(strcmp("ax_request", s + 1) == 0)) {
253		/* OSSL_RAND_PARAM_MAX_REQUEST */
254	118	if (ossl_unlikely(r->maxreq != NULL)) {
255	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
256	0	"param %s is repeated", s);
257	0	return 0;
258	0	}
259	118	r->maxreq = (OSSL_PARAM *)p;
260	118	}
261	118	break;
262	118	case 's':
263	0	switch(s[1]) {
264	0	default:
265	0	break;
266	0	case 't':
267	0	switch(s[2]) {
268	0	default:
269	0	break;
270	0	case 'a':
271	0	if (ossl_likely(strcmp("te", s + 3) == 0)) {
272		/* OSSL_RAND_PARAM_STATE */
273	0	if (ossl_unlikely(r->state != NULL)) {
274	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
275	0	"param %s is repeated", s);
276	0	return 0;
277	0	}
278	0	r->state = (OSSL_PARAM *)p;
279	0	}
280	0	break;
281	0	case 'r':
282	0	if (ossl_likely(strcmp("ength", s + 3) == 0)) {
283		/* OSSL_RAND_PARAM_STRENGTH */
284	0	if (ossl_unlikely(r->str != NULL)) {
285	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
286	0	"param %s is repeated", s);
287	0	return 0;
288	0	}
289	0	r->str = (OSSL_PARAM *)p;
290	0	}
291	0	}
292	0	}
293	118	}
294	118	return 1;
295	118	}
296		#endif
297		/* End of machine generated */
298		/* clang-format on */
299
300		static int test_rng_get_ctx_params(void *vtest, OSSL_PARAM params[])
301	118	{
302	118	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
303	118	struct test_rng_get_ctx_params_st p;
304
305	118	if (t == NULL \|\| !test_rng_get_ctx_params_decoder(params, &p))
306	0	return 0;
307
308	118	if (p.state != NULL && !OSSL_PARAM_set_int(p.state, t->state))
309	0	return 0;
310
311	118	if (p.str != NULL && !OSSL_PARAM_set_uint(p.str, t->strength))
312	0	return 0;
313
314	118	if (p.maxreq != NULL && !OSSL_PARAM_set_size_t(p.maxreq, t->max_request))
315	0	return 0;
316
317	118	if (p.gen != NULL && !OSSL_PARAM_set_uint(p.gen, t->generate))
318	0	return 0;
319
320		#ifdef FIPS_MODULE
321		if (p.ind != NULL && !OSSL_PARAM_set_int(p.ind, 0))
322		return 0;
323		#endif /* FIPS_MODULE */
324
325	118	return 1;
326	118	}
327
328		static const OSSL_PARAM test_rng_gettable_ctx_params(ossl_unused void vtest,
329		ossl_unused void *provctx)
330	0	{
331	0	return test_rng_get_ctx_params_list;
332	0	}
333
334		/* clang-format off */
335		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
336		#ifndef test_rng_set_ctx_params_list
337		static const OSSL_PARAM test_rng_set_ctx_params_list[] = {
338		OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, NULL, 0),
339		OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_NONCE, NULL, 0),
340		OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
341		OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
342		OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
343		OSSL_PARAM_END
344		};
345		#endif
346
347		#ifndef test_rng_set_ctx_params_st
348		struct test_rng_set_ctx_params_st {
349		OSSL_PARAM *ent;
350		OSSL_PARAM *gen;
351		OSSL_PARAM *maxreq;
352		OSSL_PARAM *nonce;
353		OSSL_PARAM *str;
354		};
355		#endif
356
357		#ifndef test_rng_set_ctx_params_decoder
358		static int test_rng_set_ctx_params_decoder
359		(const OSSL_PARAM p, struct test_rng_set_ctx_params_st r)
360	118	{
361	118	const char *s;
362
363	118	memset(r, 0, sizeof(*r));
364	118	if (p != NULL)
365	708	for (; (s = p->key) != NULL; p++)
366	590	switch(s[0]) {
367	0	default:
368	0	break;
369	118	case 'g':
370	118	if (ossl_likely(strcmp("enerate", s + 1) == 0)) {
371		/* OSSL_RAND_PARAM_GENERATE */
372	118	if (ossl_unlikely(r->gen != NULL)) {
373	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
374	0	"param %s is repeated", s);
375	0	return 0;
376	0	}
377	118	r->gen = (OSSL_PARAM *)p;
378	118	}
379	118	break;
380	118	case 'm':
381	118	if (ossl_likely(strcmp("ax_request", s + 1) == 0)) {
382		/* OSSL_RAND_PARAM_MAX_REQUEST */
383	118	if (ossl_unlikely(r->maxreq != NULL)) {
384	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
385	0	"param %s is repeated", s);
386	0	return 0;
387	0	}
388	118	r->maxreq = (OSSL_PARAM *)p;
389	118	}
390	118	break;
391	118	case 's':
392	118	if (ossl_likely(strcmp("trength", s + 1) == 0)) {
393		/* OSSL_RAND_PARAM_STRENGTH */
394	118	if (ossl_unlikely(r->str != NULL)) {
395	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
396	0	"param %s is repeated", s);
397	0	return 0;
398	0	}
399	118	r->str = (OSSL_PARAM *)p;
400	118	}
401	118	break;
402	236	case 't':
403	236	switch(s[1]) {
404	0	default:
405	0	break;
406	236	case 'e':
407	236	switch(s[2]) {
408	0	default:
409	0	break;
410	236	case 's':
411	236	switch(s[3]) {
412	0	default:
413	0	break;
414	236	case 't':
415	236	switch(s[4]) {
416	0	default:
417	0	break;
418	236	case '_':
419	236	switch(s[5]) {
420	0	default:
421	0	break;
422	118	case 'e':
423	118	if (ossl_likely(strcmp("ntropy", s + 6) == 0)) {
424		/* OSSL_RAND_PARAM_TEST_ENTROPY */
425	118	if (ossl_unlikely(r->ent != NULL)) {
426	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
427	0	"param %s is repeated", s);
428	0	return 0;
429	0	}
430	118	r->ent = (OSSL_PARAM *)p;
431	118	}
432	118	break;
433	118	case 'n':
434	118	if (ossl_likely(strcmp("once", s + 6) == 0)) {
435		/* OSSL_RAND_PARAM_TEST_NONCE */
436	118	if (ossl_unlikely(r->nonce != NULL)) {
437	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
438	0	"param %s is repeated", s);
439	0	return 0;
440	0	}
441	118	r->nonce = (OSSL_PARAM *)p;
442	118	}
443	236	}
444	236	}
445	236	}
446	236	}
447	236	}
448	590	}
449	118	return 1;
450	118	}
451		#endif
452		/* End of machine generated */
453		/* clang-format on */
454
455		static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[])
456	118	{
457	118	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
458	118	struct test_rng_set_ctx_params_st p;
459	118	void *ptr = NULL;
460	118	size_t size = 0;
461
462	118	if (t == NULL \|\| !test_rng_set_ctx_params_decoder(params, &p))
463	0	return 0;
464
465	118	if (p.str != NULL && !OSSL_PARAM_get_uint(p.str, &t->strength))
466	0	return 0;
467
468	118	if (p.ent != NULL) {
469	118	if (!OSSL_PARAM_get_octet_string(p.ent, &ptr, 0, &size))
470	0	return 0;
471	118	OPENSSL_free(t->entropy);
472	118	t->entropy = ptr;
473	118	t->entropy_len = size;
474	118	t->entropy_pos = 0;
475	118	ptr = NULL;
476	118	}
477
478	118	if (p.nonce != NULL) {
479	118	if (!OSSL_PARAM_get_octet_string(p.nonce, &ptr, 0, &size))
480	0	return 0;
481	118	OPENSSL_free(t->nonce);
482	118	t->nonce = ptr;
483	118	t->nonce_len = size;
484	118	}
485
486	118	if (p.maxreq != NULL && !OSSL_PARAM_get_size_t(p.maxreq, &t->max_request))
487	0	return 0;
488
489	118	if (p.gen != NULL && !OSSL_PARAM_get_uint(p.gen, &t->generate))
490	0	return 0;
491	118	return 1;
492	118	}
493
494		static const OSSL_PARAM test_rng_settable_ctx_params(ossl_unused void vtest,
495		ossl_unused void *provctx)
496	229	{
497	229	return test_rng_set_ctx_params_list;
498	229	}
499
500		static int test_rng_verify_zeroization(ossl_unused void *vtest)
501	0	{
502	0	return 1;
503	0	}
504
505		static size_t test_rng_get_seed(void vtest, unsigned char *pout,
506		int entropy, size_t min_len, size_t max_len,
507		ossl_unused int prediction_resistance,
508		ossl_unused const unsigned char *adin,
509		ossl_unused size_t adin_len)
510	0	{
511	0	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
512
513	0	*pout = t->entropy;
514	0	return t->entropy_len > max_len ? max_len : t->entropy_len;
515	0	}
516
517		static int test_rng_enable_locking(void *vtest)
518	0	{
519	0	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
520
521	0	if (t != NULL && t->lock == NULL) {
522	0	t->lock = CRYPTO_THREAD_lock_new();
523	0	if (t->lock == NULL) {
524	0	ERR_raise(ERR_LIB_PROV, RAND_R_FAILED_TO_CREATE_LOCK);
525	0	return 0;
526	0	}
527	0	}
528	0	return 1;
529	0	}
530
531		static int test_rng_lock(void *vtest)
532	550	{
533	550	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
534
535	550	if (t == NULL \|\| t->lock == NULL)
536	550	return 1;
537	0	return CRYPTO_THREAD_write_lock(t->lock);
538	550	}
539
540		static void test_rng_unlock(void *vtest)
541	550	{
542	550	PROV_TEST_RNG t = (PROV_TEST_RNG )vtest;
543
544	550	if (t != NULL && t->lock != NULL)
545	0	CRYPTO_THREAD_unlock(t->lock);
546	550	}
547
548		const OSSL_DISPATCH ossl_test_rng_functions[] = {
549		{ OSSL_FUNC_RAND_NEWCTX, (void (*)(void))test_rng_new },
550		{ OSSL_FUNC_RAND_FREECTX, (void (*)(void))test_rng_free },
551		{ OSSL_FUNC_RAND_INSTANTIATE,
552		(void (*)(void))test_rng_instantiate },
553		{ OSSL_FUNC_RAND_UNINSTANTIATE,
554		(void (*)(void))test_rng_uninstantiate },
555		{ OSSL_FUNC_RAND_GENERATE, (void (*)(void))test_rng_generate },
556		{ OSSL_FUNC_RAND_RESEED, (void (*)(void))test_rng_reseed },
557		{ OSSL_FUNC_RAND_NONCE, (void (*)(void))test_rng_nonce },
558		{ OSSL_FUNC_RAND_ENABLE_LOCKING, (void (*)(void))test_rng_enable_locking },
559		{ OSSL_FUNC_RAND_LOCK, (void (*)(void))test_rng_lock },
560		{ OSSL_FUNC_RAND_UNLOCK, (void (*)(void))test_rng_unlock },
561		{ OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS,
562		(void (*)(void))test_rng_settable_ctx_params },
563		{ OSSL_FUNC_RAND_SET_CTX_PARAMS, (void (*)(void))test_rng_set_ctx_params },
564		{ OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS,
565		(void (*)(void))test_rng_gettable_ctx_params },
566		{ OSSL_FUNC_RAND_GET_CTX_PARAMS, (void (*)(void))test_rng_get_ctx_params },
567		{ OSSL_FUNC_RAND_VERIFY_ZEROIZATION,
568		(void (*)(void))test_rng_verify_zeroization },
569		{ OSSL_FUNC_RAND_GET_SEED, (void (*)(void))test_rng_get_seed },
570		OSSL_DISPATCH_END
571		};