VirtualBox

source: vbox/trunk/src/libs/openssl-3.1.5/providers/implementations/rands/test_rng.c@ 105132

最後變更 在這個檔案從105132是 104078,由 vboxsync 提交於 12 月 前

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette