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

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

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

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

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

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-08-25 06:30

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