/src/openssl30/providers/implementations/rands/test_rng.c
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/core_dispatch.h> |
12 | | #include <openssl/e_os2.h> |
13 | | #include <openssl/params.h> |
14 | | #include <openssl/core_names.h> |
15 | | #include <openssl/evp.h> |
16 | | #include <openssl/err.h> |
17 | | #include <openssl/randerr.h> |
18 | | #include "prov/providercommon.h" |
19 | | #include "prov/provider_ctx.h" |
20 | | #include "prov/provider_util.h" |
21 | | #include "prov/implementations.h" |
22 | | |
23 | | static OSSL_FUNC_rand_newctx_fn test_rng_new; |
24 | | static OSSL_FUNC_rand_freectx_fn test_rng_free; |
25 | | static OSSL_FUNC_rand_instantiate_fn test_rng_instantiate; |
26 | | static OSSL_FUNC_rand_uninstantiate_fn test_rng_uninstantiate; |
27 | | static OSSL_FUNC_rand_generate_fn test_rng_generate; |
28 | | static OSSL_FUNC_rand_reseed_fn test_rng_reseed; |
29 | | static OSSL_FUNC_rand_nonce_fn test_rng_nonce; |
30 | | static OSSL_FUNC_rand_settable_ctx_params_fn test_rng_settable_ctx_params; |
31 | | static OSSL_FUNC_rand_set_ctx_params_fn test_rng_set_ctx_params; |
32 | | static OSSL_FUNC_rand_gettable_ctx_params_fn test_rng_gettable_ctx_params; |
33 | | static OSSL_FUNC_rand_get_ctx_params_fn test_rng_get_ctx_params; |
34 | | static OSSL_FUNC_rand_verify_zeroization_fn test_rng_verify_zeroization; |
35 | | static OSSL_FUNC_rand_enable_locking_fn test_rng_enable_locking; |
36 | | static OSSL_FUNC_rand_lock_fn test_rng_lock; |
37 | | static OSSL_FUNC_rand_unlock_fn test_rng_unlock; |
38 | | static OSSL_FUNC_rand_get_seed_fn test_rng_get_seed; |
39 | | |
40 | | typedef struct { |
41 | | void *provctx; |
42 | | int state; |
43 | | unsigned int strength; |
44 | | size_t max_request; |
45 | | unsigned char *entropy, *nonce; |
46 | | size_t entropy_len, entropy_pos, nonce_len; |
47 | | CRYPTO_RWLOCK *lock; |
48 | | } PROV_TEST_RNG; |
49 | | |
50 | | static void *test_rng_new(void *provctx, void *parent, |
51 | | const OSSL_DISPATCH *parent_dispatch) |
52 | 60 | { |
53 | 60 | PROV_TEST_RNG *t; |
54 | | |
55 | 60 | t = OPENSSL_zalloc(sizeof(*t)); |
56 | 60 | if (t == NULL) |
57 | 0 | return NULL; |
58 | | |
59 | 60 | t->max_request = INT_MAX; |
60 | 60 | t->provctx = provctx; |
61 | 60 | t->state = EVP_RAND_STATE_UNINITIALISED; |
62 | 60 | return t; |
63 | 60 | } |
64 | | |
65 | | static void test_rng_free(void *vtest) |
66 | 60 | { |
67 | 60 | PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest; |
68 | | |
69 | 60 | if (t == NULL) |
70 | 0 | return; |
71 | 60 | OPENSSL_free(t->entropy); |
72 | 60 | OPENSSL_free(t->nonce); |
73 | 60 | CRYPTO_THREAD_lock_free(t->lock); |
74 | 60 | OPENSSL_free(t); |
75 | 60 | } |
76 | | |
77 | | static int test_rng_instantiate(void *vtest, unsigned int strength, |
78 | | int prediction_resistance, |
79 | | const unsigned char *pstr, size_t pstr_len, |
80 | | const OSSL_PARAM params[]) |
81 | 0 | { |
82 | 0 | PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest; |
83 | |
|
84 | 0 | if (!test_rng_set_ctx_params(t, params) || strength > t->strength) |
85 | 0 | return 0; |
86 | | |
87 | 0 | t->state = EVP_RAND_STATE_READY; |
88 | 0 | t->entropy_pos = 0; |
89 | |
|
90 | 0 | return 1; |
91 | 0 | } |
92 | | |
93 | | static int test_rng_uninstantiate(void *vtest) |
94 | 0 | { |
95 | 0 | PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest; |
96 | |
|
97 | 0 | t->entropy_pos = 0; |
98 | 0 | t->state = EVP_RAND_STATE_UNINITIALISED; |
99 | 0 | return 1; |
100 | 0 | } |
101 | | |
102 | | static int test_rng_generate(void *vtest, unsigned char *out, size_t outlen, |
103 | | unsigned int strength, int prediction_resistance, |
104 | | const unsigned char *adin, size_t adin_len) |
105 | | { |
106 | | PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest; |
107 | | |
108 | | if (strength > t->strength || t->entropy_len - t->entropy_pos < outlen) |
109 | | return 0; |
110 | | memcpy(out, t->entropy + t->entropy_pos, outlen); |
111 | | t->entropy_pos += outlen; |
112 | | return 1; |
113 | | } |
114 | | |
115 | | static int test_rng_reseed(ossl_unused void *vtest, |
116 | | ossl_unused int prediction_resistance, |
117 | | ossl_unused const unsigned char *ent, |
118 | | ossl_unused size_t ent_len, |
119 | | ossl_unused const unsigned char *adin, |
120 | | ossl_unused size_t adin_len) |
121 | 29 | { |
122 | 29 | return 1; |
123 | 29 | } |
124 | | |
125 | | static size_t test_rng_nonce(void *vtest, unsigned char *out, |
126 | | unsigned int strength, |
127 | | ossl_unused size_t min_noncelen, |
128 | | size_t max_noncelen) |
129 | 0 | { |
130 | 0 | PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest; |
131 | 0 | size_t i; |
132 | |
|
133 | 0 | if (t->nonce == NULL || strength > t->strength) |
134 | 0 | return 0; |
135 | | |
136 | 0 | i = t->nonce_len > max_noncelen ? max_noncelen : t->nonce_len; |
137 | 0 | if (out != NULL) |
138 | 0 | memcpy(out, t->nonce, i); |
139 | 0 | return i; |
140 | 0 | } |
141 | | |
142 | | static int test_rng_get_ctx_params(void *vtest, OSSL_PARAM params[]) |
143 | 0 | { |
144 | 0 | PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest; |
145 | 0 | OSSL_PARAM *p; |
146 | |
|
147 | 0 | p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STATE); |
148 | 0 | if (p != NULL && !OSSL_PARAM_set_int(p, t->state)) |
149 | 0 | return 0; |
150 | | |
151 | 0 | p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STRENGTH); |
152 | 0 | if (p != NULL && !OSSL_PARAM_set_int(p, t->strength)) |
153 | 0 | return 0; |
154 | | |
155 | 0 | p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST); |
156 | 0 | if (p != NULL && !OSSL_PARAM_set_size_t(p, t->max_request)) |
157 | 0 | return 0; |
158 | 0 | return 1; |
159 | 0 | } |
160 | | |
161 | | static const OSSL_PARAM *test_rng_gettable_ctx_params(ossl_unused void *vtest, |
162 | | ossl_unused void *provctx) |
163 | 0 | { |
164 | 0 | static const OSSL_PARAM known_gettable_ctx_params[] = { |
165 | 0 | OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL), |
166 | 0 | OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL), |
167 | 0 | OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL), |
168 | 0 | OSSL_PARAM_END |
169 | 0 | }; |
170 | 0 | return known_gettable_ctx_params; |
171 | 0 | } |
172 | | |
173 | | static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[]) |
174 | | { |
175 | | PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest; |
176 | | const OSSL_PARAM *p; |
177 | | void *ptr = NULL; |
178 | | size_t size = 0; |
179 | | |
180 | | if (params == NULL) |
181 | | return 1; |
182 | | |
183 | | p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_STRENGTH); |
184 | | if (p != NULL && !OSSL_PARAM_get_uint(p, &t->strength)) |
185 | | return 0; |
186 | | |
187 | | p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_ENTROPY); |
188 | | if (p != NULL) { |
189 | | if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size)) |
190 | | return 0; |
191 | | OPENSSL_free(t->entropy); |
192 | | t->entropy = ptr; |
193 | | t->entropy_len = size; |
194 | | t->entropy_pos = 0; |
195 | | ptr = NULL; |
196 | | } |
197 | | |
198 | | p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_NONCE); |
199 | | if (p != NULL) { |
200 | | if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size)) |
201 | | return 0; |
202 | | OPENSSL_free(t->nonce); |
203 | | t->nonce = ptr; |
204 | | t->nonce_len = size; |
205 | | } |
206 | | |
207 | | p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_MAX_REQUEST); |
208 | | if (p != NULL && !OSSL_PARAM_get_size_t(p, &t->max_request)) |
209 | | return 0; |
210 | | |
211 | | return 1; |
212 | | } |
213 | | |
214 | | static const OSSL_PARAM *test_rng_settable_ctx_params(ossl_unused void *vtest, |
215 | | ossl_unused void *provctx) |
216 | 60 | { |
217 | 60 | static const OSSL_PARAM known_settable_ctx_params[] = { |
218 | 60 | OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, NULL, 0), |
219 | 60 | OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_NONCE, NULL, 0), |
220 | 60 | OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL), |
221 | 60 | OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL), |
222 | 60 | OSSL_PARAM_END |
223 | 60 | }; |
224 | 60 | return known_settable_ctx_params; |
225 | 60 | } |
226 | | |
227 | | static int test_rng_verify_zeroization(ossl_unused void *vtest) |
228 | 0 | { |
229 | 0 | return 1; |
230 | 0 | } |
231 | | |
232 | | static size_t test_rng_get_seed(void *vtest, unsigned char **pout, |
233 | | int entropy, size_t min_len, size_t max_len, |
234 | | ossl_unused int prediction_resistance, |
235 | | ossl_unused const unsigned char *adin, |
236 | | ossl_unused size_t adin_len) |
237 | 0 | { |
238 | 0 | PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest; |
239 | |
|
240 | 0 | *pout = t->entropy; |
241 | 0 | return t->entropy_len > max_len ? max_len : t->entropy_len; |
242 | 0 | } |
243 | | |
244 | | static int test_rng_enable_locking(void *vtest) |
245 | 0 | { |
246 | 0 | PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest; |
247 | |
|
248 | 0 | if (t != NULL && t->lock == NULL) { |
249 | 0 | t->lock = CRYPTO_THREAD_lock_new(); |
250 | 0 | if (t->lock == NULL) { |
251 | 0 | ERR_raise(ERR_LIB_PROV, RAND_R_FAILED_TO_CREATE_LOCK); |
252 | 0 | return 0; |
253 | 0 | } |
254 | 0 | } |
255 | 0 | return 1; |
256 | 0 | } |
257 | | |
258 | | static int test_rng_lock(void *vtest) |
259 | 149 | { |
260 | 149 | PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest; |
261 | | |
262 | 149 | if (t == NULL || t->lock == NULL) |
263 | 149 | return 1; |
264 | 0 | return CRYPTO_THREAD_write_lock(t->lock); |
265 | 149 | } |
266 | | |
267 | | static void test_rng_unlock(void *vtest) |
268 | 149 | { |
269 | 149 | PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest; |
270 | | |
271 | 149 | if (t != NULL && t->lock != NULL) |
272 | 0 | CRYPTO_THREAD_unlock(t->lock); |
273 | 149 | } |
274 | | |
275 | | const OSSL_DISPATCH ossl_test_rng_functions[] = { |
276 | | { OSSL_FUNC_RAND_NEWCTX, (void(*)(void))test_rng_new }, |
277 | | { OSSL_FUNC_RAND_FREECTX, (void(*)(void))test_rng_free }, |
278 | | { OSSL_FUNC_RAND_INSTANTIATE, |
279 | | (void(*)(void))test_rng_instantiate }, |
280 | | { OSSL_FUNC_RAND_UNINSTANTIATE, |
281 | | (void(*)(void))test_rng_uninstantiate }, |
282 | | { OSSL_FUNC_RAND_GENERATE, (void(*)(void))test_rng_generate }, |
283 | | { OSSL_FUNC_RAND_RESEED, (void(*)(void))test_rng_reseed }, |
284 | | { OSSL_FUNC_RAND_NONCE, (void(*)(void))test_rng_nonce }, |
285 | | { OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))test_rng_enable_locking }, |
286 | | { OSSL_FUNC_RAND_LOCK, (void(*)(void))test_rng_lock }, |
287 | | { OSSL_FUNC_RAND_UNLOCK, (void(*)(void))test_rng_unlock }, |
288 | | { OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS, |
289 | | (void(*)(void))test_rng_settable_ctx_params }, |
290 | | { OSSL_FUNC_RAND_SET_CTX_PARAMS, (void(*)(void))test_rng_set_ctx_params }, |
291 | | { OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS, |
292 | | (void(*)(void))test_rng_gettable_ctx_params }, |
293 | | { OSSL_FUNC_RAND_GET_CTX_PARAMS, (void(*)(void))test_rng_get_ctx_params }, |
294 | | { OSSL_FUNC_RAND_VERIFY_ZEROIZATION, |
295 | | (void(*)(void))test_rng_verify_zeroization }, |
296 | | { OSSL_FUNC_RAND_GET_SEED, (void(*)(void))test_rng_get_seed }, |
297 | | { 0, NULL } |
298 | | }; |