2 * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
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
10 #include <openssl/evp.h>
14 #include <openssl/engine.h>
15 #include <openssl/evp.h>
16 #include <openssl/x509v3.h>
17 #include <openssl/rand.h>
18 #include <openssl/core.h>
19 #include <openssl/core_names.h>
20 #include <openssl/crypto.h>
21 #include "crypto/asn1.h"
22 #include "crypto/evp.h"
23 #include "internal/cryptlib.h"
24 #include "internal/numbers.h"
25 #include "internal/provider.h"
26 #include "evp_local.h"
31 CRYPTO_REF_COUNT refcnt;
32 CRYPTO_RWLOCK *refcnt_lock;
34 const OSSL_DISPATCH *dispatch;
35 OSSL_FUNC_rand_newctx_fn *newctx;
36 OSSL_FUNC_rand_freectx_fn *freectx;
37 OSSL_FUNC_rand_instantiate_fn *instantiate;
38 OSSL_FUNC_rand_uninstantiate_fn *uninstantiate;
39 OSSL_FUNC_rand_generate_fn *generate;
40 OSSL_FUNC_rand_reseed_fn *reseed;
41 OSSL_FUNC_rand_nonce_fn *nonce;
42 OSSL_FUNC_rand_enable_locking_fn *enable_locking;
43 OSSL_FUNC_rand_lock_fn *lock;
44 OSSL_FUNC_rand_unlock_fn *unlock;
45 OSSL_FUNC_rand_gettable_params_fn *gettable_params;
46 OSSL_FUNC_rand_gettable_ctx_params_fn *gettable_ctx_params;
47 OSSL_FUNC_rand_settable_ctx_params_fn *settable_ctx_params;
48 OSSL_FUNC_rand_get_params_fn *get_params;
49 OSSL_FUNC_rand_get_ctx_params_fn *get_ctx_params;
50 OSSL_FUNC_rand_set_ctx_params_fn *set_ctx_params;
51 OSSL_FUNC_rand_verify_zeroization_fn *verify_zeroization;
54 static int evp_rand_up_ref(void *vrand)
56 EVP_RAND *rand = (EVP_RAND *)vrand;
60 return CRYPTO_UP_REF(&rand->refcnt, &ref, rand->refcnt_lock);
64 static void evp_rand_free(void *vrand){
65 EVP_RAND *rand = (EVP_RAND *)vrand;
69 CRYPTO_DOWN_REF(&rand->refcnt, &ref, rand->refcnt_lock);
71 ossl_provider_free(rand->prov);
72 CRYPTO_THREAD_lock_free(rand->refcnt_lock);
78 static void *evp_rand_new(void)
80 EVP_RAND *rand = OPENSSL_zalloc(sizeof(*rand));
83 || (rand->refcnt_lock = CRYPTO_THREAD_lock_new()) == NULL) {
91 /* Enable locking of the underlying DRBG/RAND if available */
92 int EVP_RAND_enable_locking(EVP_RAND_CTX *rand)
94 if (rand->meth->enable_locking != NULL)
95 return rand->meth->enable_locking(rand->data);
96 ERR_raise(ERR_LIB_EVP, EVP_R_LOCKING_NOT_SUPPORTED);
100 /* Lock the underlying DRBG/RAND if available */
101 static int evp_rand_lock(EVP_RAND_CTX *rand)
103 if (rand->meth->lock != NULL)
104 return rand->meth->lock(rand->data);
108 /* Unlock the underlying DRBG/RAND if available */
109 static void evp_rand_unlock(EVP_RAND_CTX *rand)
111 if (rand->meth->unlock != NULL)
112 rand->meth->unlock(rand->data);
115 static void *evp_rand_from_dispatch(int name_id,
116 const OSSL_DISPATCH *fns,
119 EVP_RAND *rand = NULL;
120 int fnrandcnt = 0, fnctxcnt = 0, fnlockcnt = 0, fnenablelockcnt = 0;
122 int fnzeroizecnt = 0;
125 if ((rand = evp_rand_new()) == NULL) {
126 ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
129 rand->name_id = name_id;
130 rand->dispatch = fns;
131 for (; fns->function_id != 0; fns++) {
132 switch (fns->function_id) {
133 case OSSL_FUNC_RAND_NEWCTX:
134 if (rand->newctx != NULL)
136 rand->newctx = OSSL_FUNC_rand_newctx(fns);
139 case OSSL_FUNC_RAND_FREECTX:
140 if (rand->freectx != NULL)
142 rand->freectx = OSSL_FUNC_rand_freectx(fns);
145 case OSSL_FUNC_RAND_INSTANTIATE:
146 if (rand->instantiate != NULL)
148 rand->instantiate = OSSL_FUNC_rand_instantiate(fns);
151 case OSSL_FUNC_RAND_UNINSTANTIATE:
152 if (rand->uninstantiate != NULL)
154 rand->uninstantiate = OSSL_FUNC_rand_uninstantiate(fns);
157 case OSSL_FUNC_RAND_GENERATE:
158 if (rand->generate != NULL)
160 rand->generate = OSSL_FUNC_rand_generate(fns);
163 case OSSL_FUNC_RAND_RESEED:
164 if (rand->reseed != NULL)
166 rand->reseed = OSSL_FUNC_rand_reseed(fns);
168 case OSSL_FUNC_RAND_NONCE:
169 if (rand->nonce != NULL)
171 rand->nonce = OSSL_FUNC_rand_nonce(fns);
173 case OSSL_FUNC_RAND_ENABLE_LOCKING:
174 if (rand->enable_locking != NULL)
176 rand->enable_locking = OSSL_FUNC_rand_enable_locking(fns);
179 case OSSL_FUNC_RAND_LOCK:
180 if (rand->lock != NULL)
182 rand->lock = OSSL_FUNC_rand_lock(fns);
185 case OSSL_FUNC_RAND_UNLOCK:
186 if (rand->unlock != NULL)
188 rand->unlock = OSSL_FUNC_rand_unlock(fns);
191 case OSSL_FUNC_RAND_GETTABLE_PARAMS:
192 if (rand->gettable_params != NULL)
194 rand->gettable_params =
195 OSSL_FUNC_rand_gettable_params(fns);
197 case OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS:
198 if (rand->gettable_ctx_params != NULL)
200 rand->gettable_ctx_params =
201 OSSL_FUNC_rand_gettable_ctx_params(fns);
203 case OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS:
204 if (rand->settable_ctx_params != NULL)
206 rand->settable_ctx_params =
207 OSSL_FUNC_rand_settable_ctx_params(fns);
209 case OSSL_FUNC_RAND_GET_PARAMS:
210 if (rand->get_params != NULL)
212 rand->get_params = OSSL_FUNC_rand_get_params(fns);
214 case OSSL_FUNC_RAND_GET_CTX_PARAMS:
215 if (rand->get_ctx_params != NULL)
217 rand->get_ctx_params = OSSL_FUNC_rand_get_ctx_params(fns);
220 case OSSL_FUNC_RAND_SET_CTX_PARAMS:
221 if (rand->set_ctx_params != NULL)
223 rand->set_ctx_params = OSSL_FUNC_rand_set_ctx_params(fns);
225 case OSSL_FUNC_RAND_VERIFY_ZEROIZATION:
226 if (rand->verify_zeroization != NULL)
228 rand->verify_zeroization = OSSL_FUNC_rand_verify_zeroization(fns);
236 * In order to be a consistent set of functions we must have at least
237 * a complete set of "rand" functions and a complete set of context
238 * management functions. In FIPS mode, we also require the zeroization
239 * verification function.
241 * In addition, if locking can be enabled, we need a complete set of
246 || (fnenablelockcnt != 0 && fnenablelockcnt != 1)
247 || (fnlockcnt != 0 && fnlockcnt != 2)
253 ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_PROVIDER_FUNCTIONS);
257 if (prov != NULL && !ossl_provider_up_ref(prov)) {
259 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
267 EVP_RAND *EVP_RAND_fetch(OSSL_LIB_CTX *libctx, const char *algorithm,
268 const char *properties)
270 return evp_generic_fetch(libctx, OSSL_OP_RAND, algorithm, properties,
271 evp_rand_from_dispatch, evp_rand_up_ref,
275 int EVP_RAND_up_ref(EVP_RAND *rand)
277 return evp_rand_up_ref(rand);
280 void EVP_RAND_free(EVP_RAND *rand)
285 int EVP_RAND_number(const EVP_RAND *rand)
287 return rand->name_id;
290 const char *EVP_RAND_name(const EVP_RAND *rand)
292 return evp_first_name(rand->prov, rand->name_id);
295 int EVP_RAND_is_a(const EVP_RAND *rand, const char *name)
297 return evp_is_a(rand->prov, rand->name_id, NULL, name);
300 const OSSL_PROVIDER *EVP_RAND_provider(const EVP_RAND *rand)
305 int EVP_RAND_get_params(EVP_RAND *rand, OSSL_PARAM params[])
307 if (rand->get_params != NULL)
308 return rand->get_params(params);
312 static int evp_rand_ctx_up_ref(EVP_RAND_CTX *ctx)
316 return CRYPTO_UP_REF(&ctx->refcnt, &ref, ctx->refcnt_lock);
319 EVP_RAND_CTX *EVP_RAND_CTX_new(EVP_RAND *rand, EVP_RAND_CTX *parent)
322 void *parent_ctx = NULL;
323 const OSSL_DISPATCH *parent_dispatch = NULL;
326 ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_NULL_ALGORITHM);
330 ctx = OPENSSL_zalloc(sizeof(*ctx));
331 if (ctx == NULL || (ctx->refcnt_lock = CRYPTO_THREAD_lock_new()) == NULL) {
333 ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
336 if (parent != NULL) {
337 if (!evp_rand_ctx_up_ref(parent)) {
338 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
339 CRYPTO_THREAD_lock_free(ctx->refcnt_lock);
343 parent_ctx = parent->data;
344 parent_dispatch = parent->meth->dispatch;
346 if ((ctx->data = rand->newctx(ossl_provider_ctx(rand->prov), parent_ctx,
347 parent_dispatch)) == NULL
348 || !EVP_RAND_up_ref(rand)) {
349 ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
350 rand->freectx(ctx->data);
351 CRYPTO_THREAD_lock_free(ctx->refcnt_lock);
353 EVP_RAND_CTX_free(parent);
357 ctx->parent = parent;
362 void EVP_RAND_CTX_free(EVP_RAND_CTX *ctx)
367 CRYPTO_DOWN_REF(&ctx->refcnt, &ref, ctx->refcnt_lock);
369 EVP_RAND_CTX *parent = ctx->parent;
371 ctx->meth->freectx(ctx->data);
373 EVP_RAND_free(ctx->meth);
374 CRYPTO_THREAD_lock_free(ctx->refcnt_lock);
376 EVP_RAND_CTX_free(parent);
381 EVP_RAND *EVP_RAND_CTX_rand(EVP_RAND_CTX *ctx)
386 static int evp_rand_get_ctx_params_locked(EVP_RAND_CTX *ctx,
389 return ctx->meth->get_ctx_params(ctx->data, params);
392 int EVP_RAND_get_ctx_params(EVP_RAND_CTX *ctx, OSSL_PARAM params[])
396 if (!evp_rand_lock(ctx))
398 res = evp_rand_get_ctx_params_locked(ctx, params);
399 evp_rand_unlock(ctx);
403 static int evp_rand_set_ctx_params_locked(EVP_RAND_CTX *ctx,
404 const OSSL_PARAM params[])
406 if (ctx->meth->set_ctx_params != NULL)
407 return ctx->meth->set_ctx_params(ctx->data, params);
411 int EVP_RAND_set_ctx_params(EVP_RAND_CTX *ctx, const OSSL_PARAM params[])
415 if (!evp_rand_lock(ctx))
417 res = evp_rand_set_ctx_params_locked(ctx, params);
418 evp_rand_unlock(ctx);
422 const OSSL_PARAM *EVP_RAND_gettable_params(const EVP_RAND *rand)
424 if (rand->gettable_params == NULL)
426 return rand->gettable_params(ossl_provider_ctx(EVP_RAND_provider(rand)));
429 const OSSL_PARAM *EVP_RAND_gettable_ctx_params(const EVP_RAND *rand)
431 if (rand->gettable_ctx_params == NULL)
433 return rand->gettable_ctx_params(
434 ossl_provider_ctx(EVP_RAND_provider(rand)));
437 const OSSL_PARAM *EVP_RAND_settable_ctx_params(const EVP_RAND *rand)
439 if (rand->settable_ctx_params == NULL)
441 return rand->settable_ctx_params(
442 ossl_provider_ctx(EVP_RAND_provider(rand)));
445 void EVP_RAND_do_all_provided(OSSL_LIB_CTX *libctx,
446 void (*fn)(EVP_RAND *rand, void *arg),
449 evp_generic_do_all(libctx, OSSL_OP_RAND,
450 (void (*)(void *, void *))fn, arg,
451 evp_rand_from_dispatch, evp_rand_free);
454 int EVP_RAND_names_do_all(const EVP_RAND *rand,
455 void (*fn)(const char *name, void *data),
458 if (rand->prov != NULL)
459 return evp_names_do_all(rand->prov, rand->name_id, fn, data);
464 static int evp_rand_instantiate_locked
465 (EVP_RAND_CTX *ctx, unsigned int strength, int prediction_resistance,
466 const unsigned char *pstr, size_t pstr_len)
468 return ctx->meth->instantiate(ctx->data, strength, prediction_resistance,
472 int EVP_RAND_instantiate(EVP_RAND_CTX *ctx, unsigned int strength,
473 int prediction_resistance,
474 const unsigned char *pstr, size_t pstr_len)
478 if (!evp_rand_lock(ctx))
480 res = evp_rand_instantiate_locked(ctx, strength, prediction_resistance,
482 evp_rand_unlock(ctx);
486 static int evp_rand_uninstantiate_locked(EVP_RAND_CTX *ctx)
488 return ctx->meth->uninstantiate(ctx->data);
491 int EVP_RAND_uninstantiate(EVP_RAND_CTX *ctx)
495 if (!evp_rand_lock(ctx))
497 res = evp_rand_uninstantiate_locked(ctx);
498 evp_rand_unlock(ctx);
502 static int evp_rand_generate_locked(EVP_RAND_CTX *ctx, unsigned char *out,
503 size_t outlen, unsigned int strength,
504 int prediction_resistance,
505 const unsigned char *addin,
508 size_t chunk, max_request = 0;
509 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
511 params[0] = OSSL_PARAM_construct_size_t(OSSL_RAND_PARAM_MAX_REQUEST,
513 if (!evp_rand_get_ctx_params_locked(ctx, params)
514 || max_request == 0) {
515 ERR_raise(ERR_LIB_EVP, EVP_R_UNABLE_TO_GET_MAXIMUM_REQUEST_SIZE);
518 for (; outlen > 0; outlen -= chunk, out += chunk) {
519 chunk = outlen > max_request ? max_request : outlen;
520 if (!ctx->meth->generate(ctx->data, out, chunk, strength,
521 prediction_resistance, addin, addin_len)) {
522 ERR_raise(ERR_LIB_EVP, EVP_R_GENERATE_ERROR);
526 * Prediction resistance is only relevant the first time around,
527 * subsequently, the DRBG has already been properly reseeded.
529 prediction_resistance = 0;
534 int EVP_RAND_generate(EVP_RAND_CTX *ctx, unsigned char *out, size_t outlen,
535 unsigned int strength, int prediction_resistance,
536 const unsigned char *addin, size_t addin_len)
540 if (!evp_rand_lock(ctx))
542 res = evp_rand_generate_locked(ctx, out, outlen, strength,
543 prediction_resistance, addin, addin_len);
544 evp_rand_unlock(ctx);
548 static int evp_rand_reseed_locked(EVP_RAND_CTX *ctx, int prediction_resistance,
549 const unsigned char *ent, size_t ent_len,
550 const unsigned char *addin, size_t addin_len)
552 if (ctx->meth->reseed != NULL)
553 return ctx->meth->reseed(ctx->data, prediction_resistance,
554 ent, ent_len, addin, addin_len);
558 int EVP_RAND_reseed(EVP_RAND_CTX *ctx, int prediction_resistance,
559 const unsigned char *ent, size_t ent_len,
560 const unsigned char *addin, size_t addin_len)
564 if (!evp_rand_lock(ctx))
566 res = evp_rand_reseed_locked(ctx, prediction_resistance,
567 ent, ent_len, addin, addin_len);
568 evp_rand_unlock(ctx);
572 static unsigned int evp_rand_strength_locked(EVP_RAND_CTX *ctx)
574 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
575 unsigned int strength = 0;
577 params[0] = OSSL_PARAM_construct_uint(OSSL_RAND_PARAM_STRENGTH, &strength);
578 if (!evp_rand_get_ctx_params_locked(ctx, params))
583 unsigned int EVP_RAND_strength(EVP_RAND_CTX *ctx)
587 if (!evp_rand_lock(ctx))
589 res = evp_rand_strength_locked(ctx);
590 evp_rand_unlock(ctx);
594 static int evp_rand_nonce_locked(EVP_RAND_CTX *ctx, unsigned char *out,
597 unsigned int str = evp_rand_strength_locked(ctx);
599 if (ctx->meth->nonce == NULL)
601 if (ctx->meth->nonce(ctx->data, out, str, outlen, outlen))
603 return evp_rand_generate_locked(ctx, out, outlen, str, 0, NULL, 0);
606 int EVP_RAND_nonce(EVP_RAND_CTX *ctx, unsigned char *out, size_t outlen)
610 if (!evp_rand_lock(ctx))
612 res = evp_rand_nonce_locked(ctx, out, outlen);
613 evp_rand_unlock(ctx);
617 int EVP_RAND_state(EVP_RAND_CTX *ctx)
619 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
622 params[0] = OSSL_PARAM_construct_int(OSSL_RAND_PARAM_STATE, &state);
623 if (!EVP_RAND_get_ctx_params(ctx, params))
624 state = EVP_RAND_STATE_ERROR;
628 static int evp_rand_verify_zeroization_locked(EVP_RAND_CTX *ctx)
630 if (ctx->meth->verify_zeroization != NULL)
631 return ctx->meth->verify_zeroization(ctx->data);
635 int EVP_RAND_verify_zeroization(EVP_RAND_CTX *ctx)
639 if (!evp_rand_lock(ctx))
641 res = evp_rand_verify_zeroization_locked(ctx);
642 evp_rand_unlock(ctx);