/src/openssl30/providers/implementations/rands/seed_src.c

Source (jump to first uncovered line)
/*
 * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <string.h>
#include <openssl/rand.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 <openssl/proverr.h>
#include "prov/implementations.h"
#include "prov/provider_ctx.h"
#include "crypto/rand.h"
#include "crypto/rand_pool.h"

static OSSL_FUNC_rand_newctx_fn seed_src_new;
static OSSL_FUNC_rand_freectx_fn seed_src_free;
static OSSL_FUNC_rand_instantiate_fn seed_src_instantiate;
static OSSL_FUNC_rand_uninstantiate_fn seed_src_uninstantiate;
static OSSL_FUNC_rand_generate_fn seed_src_generate;
static OSSL_FUNC_rand_reseed_fn seed_src_reseed;
static OSSL_FUNC_rand_gettable_ctx_params_fn seed_src_gettable_ctx_params;
static OSSL_FUNC_rand_get_ctx_params_fn seed_src_get_ctx_params;
static OSSL_FUNC_rand_verify_zeroization_fn seed_src_verify_zeroization;
static OSSL_FUNC_rand_enable_locking_fn seed_src_enable_locking;
static OSSL_FUNC_rand_lock_fn seed_src_lock;
static OSSL_FUNC_rand_unlock_fn seed_src_unlock;
static OSSL_FUNC_rand_get_seed_fn seed_get_seed;
static OSSL_FUNC_rand_clear_seed_fn seed_clear_seed;

typedef struct {
    void *provctx;
    int state;
} PROV_SEED_SRC;

static void *seed_src_new(void *provctx, void *parent,
                          const OSSL_DISPATCH *parent_dispatch)
{
    PROV_SEED_SRC *s;

    if (parent != NULL) {
        ERR_raise(ERR_LIB_PROV, PROV_R_SEED_SOURCES_MUST_NOT_HAVE_A_PARENT);
        return NULL;
    }

    s = OPENSSL_zalloc(sizeof(*s));
    if (s == NULL) {
        ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
        return NULL;
    }

    s->provctx = provctx;
    s->state = EVP_RAND_STATE_UNINITIALISED;
    return s;
}

static void seed_src_free(void *vseed)
{
    OPENSSL_free(vseed);
}

static int seed_src_instantiate(void *vseed, unsigned int strength,
                                int prediction_resistance,
                                const unsigned char *pstr, size_t pstr_len,
                                ossl_unused const OSSL_PARAM params[])
{
    PROV_SEED_SRC *s = (PROV_SEED_SRC *)vseed;

    s->state = EVP_RAND_STATE_READY;
    return 1;
}

static int seed_src_uninstantiate(void *vseed)
{
    PROV_SEED_SRC *s = (PROV_SEED_SRC *)vseed;

    s->state = EVP_RAND_STATE_UNINITIALISED;
    return 1;
}

static int seed_src_generate(void *vseed, unsigned char *out, size_t outlen,
                             unsigned int strength,
                             ossl_unused int prediction_resistance,
                             ossl_unused const unsigned char *adin,
                             ossl_unused size_t adin_len)
{
    PROV_SEED_SRC *s = (PROV_SEED_SRC *)vseed;
    size_t entropy_available;
    RAND_POOL *pool;

    if (s->state != EVP_RAND_STATE_READY) {
        ERR_raise(ERR_LIB_PROV,
                  s->state == EVP_RAND_STATE_ERROR ? PROV_R_IN_ERROR_STATE
                                                   : PROV_R_NOT_INSTANTIATED);
        return 0;
    }

    pool = ossl_rand_pool_new(strength, 1, outlen, outlen);
    if (pool == NULL) {
        ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
        return 0;
    }

    /* Get entropy by polling system entropy sources. */
    entropy_available = ossl_pool_acquire_entropy(pool);

    if (entropy_available > 0)
        memcpy(out, ossl_rand_pool_buffer(pool), ossl_rand_pool_length(pool));

    ossl_rand_pool_free(pool);
    return entropy_available > 0;
}

static int seed_src_reseed(void *vseed,
                           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)
{
    PROV_SEED_SRC *s = (PROV_SEED_SRC *)vseed;

    if (s->state != EVP_RAND_STATE_READY) {
        ERR_raise(ERR_LIB_PROV,
                  s->state == EVP_RAND_STATE_ERROR ? PROV_R_IN_ERROR_STATE
                                                   : PROV_R_NOT_INSTANTIATED);
        return 0;
    }
    return 1;
}

static int seed_src_get_ctx_params(void *vseed, OSSL_PARAM params[])
{
    PROV_SEED_SRC *s = (PROV_SEED_SRC *)vseed;
    OSSL_PARAM *p;

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

    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STRENGTH);
    if (p != NULL && !OSSL_PARAM_set_int(p, 1024))
        return 0;

    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST);
    if (p != NULL && !OSSL_PARAM_set_size_t(p, 128))
        return 0;
    return 1;
}

static const OSSL_PARAM *seed_src_gettable_ctx_params(ossl_unused void *vseed,
                                                      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_END
    };
    return known_gettable_ctx_params;
}

static int seed_src_verify_zeroization(ossl_unused void *vseed)
{
    return 1;
}

static size_t seed_get_seed(void *vseed, unsigned char **pout,
                            int entropy, size_t min_len, size_t max_len,
                            int prediction_resistance,
                            const unsigned char *adin, size_t adin_len)
{
    size_t bytes_needed;
    unsigned char *p;

    /*
     * Figure out how many bytes we need.
     * This assumes that the seed sources provide eight bits of entropy
     * per byte.  For lower quality sources, the formula will need to be
     * different.
     */
    bytes_needed = entropy >= 0 ? (entropy + 7) / 8 : 0;
    if (bytes_needed < min_len)
        bytes_needed = min_len;
    if (bytes_needed > max_len) {
        ERR_raise(ERR_LIB_PROV, PROV_R_ENTROPY_SOURCE_STRENGTH_TOO_WEAK);
        return 0;
    }

    p = OPENSSL_secure_malloc(bytes_needed);
    if (p == NULL) {
        ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
        return 0;
    }
    if (seed_src_generate(vseed, p, bytes_needed, 0, prediction_resistance,
                          adin, adin_len) != 0) {
        *pout = p;
        return bytes_needed;
    }
    OPENSSL_secure_clear_free(p, bytes_needed);
    return 0;
}

static void seed_clear_seed(ossl_unused void *vdrbg,
                            unsigned char *out, size_t outlen)
{
    OPENSSL_secure_clear_free(out, outlen);
}

static int seed_src_enable_locking(ossl_unused void *vseed)
{
    return 1;
}

int seed_src_lock(ossl_unused void *vctx)
{
    return 1;
}

void seed_src_unlock(ossl_unused void *vctx)
{
}

const OSSL_DISPATCH ossl_seed_src_functions[] = {
    { OSSL_FUNC_RAND_NEWCTX, (void(*)(void))seed_src_new },
    { OSSL_FUNC_RAND_FREECTX, (void(*)(void))seed_src_free },
    { OSSL_FUNC_RAND_INSTANTIATE,
      (void(*)(void))seed_src_instantiate },
    { OSSL_FUNC_RAND_UNINSTANTIATE,
      (void(*)(void))seed_src_uninstantiate },
    { OSSL_FUNC_RAND_GENERATE, (void(*)(void))seed_src_generate },
    { OSSL_FUNC_RAND_RESEED, (void(*)(void))seed_src_reseed },
    { OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))seed_src_enable_locking },
    { OSSL_FUNC_RAND_LOCK, (void(*)(void))seed_src_lock },
    { OSSL_FUNC_RAND_UNLOCK, (void(*)(void))seed_src_unlock },
    { OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS,
      (void(*)(void))seed_src_gettable_ctx_params },
    { OSSL_FUNC_RAND_GET_CTX_PARAMS, (void(*)(void))seed_src_get_ctx_params },
    { OSSL_FUNC_RAND_VERIFY_ZEROIZATION,
      (void(*)(void))seed_src_verify_zeroization },
    { OSSL_FUNC_RAND_GET_SEED, (void(*)(void))seed_get_seed },
    { OSSL_FUNC_RAND_CLEAR_SEED, (void(*)(void))seed_clear_seed },
    { 0, NULL }
};

Coverage Report

Created: 2025-06-13 06:58

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 2020-2021 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 <openssl/rand.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 <openssl/proverr.h>
20		#include "prov/implementations.h"
21		#include "prov/provider_ctx.h"
22		#include "crypto/rand.h"
23		#include "crypto/rand_pool.h"
24
25		static OSSL_FUNC_rand_newctx_fn seed_src_new;
26		static OSSL_FUNC_rand_freectx_fn seed_src_free;
27		static OSSL_FUNC_rand_instantiate_fn seed_src_instantiate;
28		static OSSL_FUNC_rand_uninstantiate_fn seed_src_uninstantiate;
29		static OSSL_FUNC_rand_generate_fn seed_src_generate;
30		static OSSL_FUNC_rand_reseed_fn seed_src_reseed;
31		static OSSL_FUNC_rand_gettable_ctx_params_fn seed_src_gettable_ctx_params;
32		static OSSL_FUNC_rand_get_ctx_params_fn seed_src_get_ctx_params;
33		static OSSL_FUNC_rand_verify_zeroization_fn seed_src_verify_zeroization;
34		static OSSL_FUNC_rand_enable_locking_fn seed_src_enable_locking;
35		static OSSL_FUNC_rand_lock_fn seed_src_lock;
36		static OSSL_FUNC_rand_unlock_fn seed_src_unlock;
37		static OSSL_FUNC_rand_get_seed_fn seed_get_seed;
38		static OSSL_FUNC_rand_clear_seed_fn seed_clear_seed;
39
40		typedef struct {
41		void *provctx;
42		int state;
43		} PROV_SEED_SRC;
44
45		static void seed_src_new(void provctx, void *parent,
46		const OSSL_DISPATCH *parent_dispatch)
47	37	{
48	37	PROV_SEED_SRC *s;
49
50	37	if (parent != NULL) {
51	0	ERR_raise(ERR_LIB_PROV, PROV_R_SEED_SOURCES_MUST_NOT_HAVE_A_PARENT);
52	0	return NULL;
53	0	}
54
55	37	s = OPENSSL_zalloc(sizeof(*s));
56	37	if (s == NULL) {
57	0	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
58	0	return NULL;
59	0	}
60
61	37	s->provctx = provctx;
62	37	s->state = EVP_RAND_STATE_UNINITIALISED;
63	37	return s;
64	37	}
65
66		static void seed_src_free(void *vseed)
67	37	{
68	37	OPENSSL_free(vseed);
69	37	}
70
71		static int seed_src_instantiate(void *vseed, unsigned int strength,
72		int prediction_resistance,
73		const unsigned char *pstr, size_t pstr_len,
74		ossl_unused const OSSL_PARAM params[])
75	36	{
76	36	PROV_SEED_SRC s = (PROV_SEED_SRC )vseed;
77
78	36	s->state = EVP_RAND_STATE_READY;
79	36	return 1;
80	36	}
81
82		static int seed_src_uninstantiate(void *vseed)
83	0	{
84	0	PROV_SEED_SRC s = (PROV_SEED_SRC )vseed;
85
86	0	s->state = EVP_RAND_STATE_UNINITIALISED;
87	0	return 1;
88	0	}
89
90		static int seed_src_generate(void vseed, unsigned char out, size_t outlen,
91		unsigned int strength,
92		ossl_unused int prediction_resistance,
93		ossl_unused const unsigned char *adin,
94		ossl_unused size_t adin_len)
95	1	{
96	1	PROV_SEED_SRC s = (PROV_SEED_SRC )vseed;
97	1	size_t entropy_available;
98	1	RAND_POOL *pool;
99
100	1	if (s->state != EVP_RAND_STATE_READY) {
101	0	ERR_raise(ERR_LIB_PROV,
102	0	s->state == EVP_RAND_STATE_ERROR ? PROV_R_IN_ERROR_STATE
103	0	: PROV_R_NOT_INSTANTIATED);
104	0	return 0;
105	0	}
106
107	1	pool = ossl_rand_pool_new(strength, 1, outlen, outlen);
108	1	if (pool == NULL) {
109	0	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
110	0	return 0;
111	0	}
112
113		/* Get entropy by polling system entropy sources. */
114	1	entropy_available = ossl_pool_acquire_entropy(pool);
115
116	1	if (entropy_available > 0)
117	1	memcpy(out, ossl_rand_pool_buffer(pool), ossl_rand_pool_length(pool));
118
119	1	ossl_rand_pool_free(pool);
120	1	return entropy_available > 0;
121	1	}
122
123		static int seed_src_reseed(void *vseed,
124		ossl_unused int prediction_resistance,
125		ossl_unused const unsigned char *ent,
126		ossl_unused size_t ent_len,
127		ossl_unused const unsigned char *adin,
128		ossl_unused size_t adin_len)
129	0	{
130	0	PROV_SEED_SRC s = (PROV_SEED_SRC )vseed;
131
132	0	if (s->state != EVP_RAND_STATE_READY) {
133	0	ERR_raise(ERR_LIB_PROV,
134	0	s->state == EVP_RAND_STATE_ERROR ? PROV_R_IN_ERROR_STATE
135	0	: PROV_R_NOT_INSTANTIATED);
136	0	return 0;
137	0	}
138	0	return 1;
139	0	}
140
141		static int seed_src_get_ctx_params(void *vseed, OSSL_PARAM params[])
142	35	{
143	35	PROV_SEED_SRC s = (PROV_SEED_SRC )vseed;
144	35	OSSL_PARAM *p;
145
146	35	p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STATE);
147	35	if (p != NULL && !OSSL_PARAM_set_int(p, s->state))
148	0	return 0;
149
150	35	p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STRENGTH);
151	35	if (p != NULL && !OSSL_PARAM_set_int(p, 1024))
152	0	return 0;
153
154	35	p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST);
155	35	if (p != NULL && !OSSL_PARAM_set_size_t(p, 128))
156	0	return 0;
157	35	return 1;
158	35	}
159
160		static const OSSL_PARAM seed_src_gettable_ctx_params(ossl_unused void vseed,
161		ossl_unused void *provctx)
162	0	{
163	0	static const OSSL_PARAM known_gettable_ctx_params[] = {
164	0	OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
165	0	OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
166	0	OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
167	0	OSSL_PARAM_END
168	0	};
169	0	return known_gettable_ctx_params;
170	0	}
171
172		static int seed_src_verify_zeroization(ossl_unused void *vseed)
173	0	{
174	0	return 1;
175	0	}
176
177		static size_t seed_get_seed(void vseed, unsigned char *pout,
178		int entropy, size_t min_len, size_t max_len,
179		int prediction_resistance,
180		const unsigned char *adin, size_t adin_len)
181	1	{
182	1	size_t bytes_needed;
183	1	unsigned char *p;
184
185		/*
186		* Figure out how many bytes we need.
187		* This assumes that the seed sources provide eight bits of entropy
188		* per byte. For lower quality sources, the formula will need to be
189		* different.
190		*/
191	1	bytes_needed = entropy >= 0 ? (entropy + 7) / 8 : 0;
192	1	if (bytes_needed < min_len)
193	1	bytes_needed = min_len;
194	1	if (bytes_needed > max_len) {
195	0	ERR_raise(ERR_LIB_PROV, PROV_R_ENTROPY_SOURCE_STRENGTH_TOO_WEAK);
196	0	return 0;
197	0	}
198
199	1	p = OPENSSL_secure_malloc(bytes_needed);
200	1	if (p == NULL) {
201	0	ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
202	0	return 0;
203	0	}
204	1	if (seed_src_generate(vseed, p, bytes_needed, 0, prediction_resistance,
205	1	adin, adin_len) != 0) {
206	1	*pout = p;
207	1	return bytes_needed;
208	1	}
209	0	OPENSSL_secure_clear_free(p, bytes_needed);
210	0	return 0;
211	1	}
212
213		static void seed_clear_seed(ossl_unused void *vdrbg,
214		unsigned char *out, size_t outlen)
215	7	{
216	7	OPENSSL_secure_clear_free(out, outlen);
217	7	}
218
219		static int seed_src_enable_locking(ossl_unused void *vseed)
220	7	{
221	7	return 1;
222	7	}
223
224		int seed_src_lock(ossl_unused void *vctx)
225	86	{
226	86	return 1;
227	86	}
228
229		void seed_src_unlock(ossl_unused void *vctx)
230	86	{
231	86	}
232
233		const OSSL_DISPATCH ossl_seed_src_functions[] = {
234		{ OSSL_FUNC_RAND_NEWCTX, (void(*)(void))seed_src_new },
235		{ OSSL_FUNC_RAND_FREECTX, (void(*)(void))seed_src_free },
236		{ OSSL_FUNC_RAND_INSTANTIATE,
237		(void(*)(void))seed_src_instantiate },
238		{ OSSL_FUNC_RAND_UNINSTANTIATE,
239		(void(*)(void))seed_src_uninstantiate },
240		{ OSSL_FUNC_RAND_GENERATE, (void(*)(void))seed_src_generate },
241		{ OSSL_FUNC_RAND_RESEED, (void(*)(void))seed_src_reseed },
242		{ OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))seed_src_enable_locking },
243		{ OSSL_FUNC_RAND_LOCK, (void(*)(void))seed_src_lock },
244		{ OSSL_FUNC_RAND_UNLOCK, (void(*)(void))seed_src_unlock },
245		{ OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS,
246		(void(*)(void))seed_src_gettable_ctx_params },
247		{ OSSL_FUNC_RAND_GET_CTX_PARAMS, (void(*)(void))seed_src_get_ctx_params },
248		{ OSSL_FUNC_RAND_VERIFY_ZEROIZATION,
249		(void(*)(void))seed_src_verify_zeroization },
250		{ OSSL_FUNC_RAND_GET_SEED, (void(*)(void))seed_get_seed },
251		{ OSSL_FUNC_RAND_CLEAR_SEED, (void(*)(void))seed_clear_seed },
252		{ 0, NULL }
253		};