crypto/rand/rand_lib.c

   1 /*
   2  * Copyright 1995-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 /* We need to use some engine deprecated APIs */
  11 #define OPENSSL_SUPPRESS_DEPRECATED
  12
  13 #include <stdio.h>
  14 #include <time.h>
  15 #include <limits.h>
  16 #include <openssl/trace.h>
  17 #include <openssl/err.h>
  18 #include <openssl/conf.h>
  19 #include "internal/cryptlib.h"
  20 #include <openssl/opensslconf.h>
  21 #include "crypto/rand.h"
  22 #include "crypto/cryptlib.h"
  23 #include <openssl/engine.h>
  24 #include <openssl/core_names.h>
  25 #include "internal/thread_once.h"
  26 #include "rand_local.h"
  27 #include "e_os.h"
  28
  29 #ifndef FIPS_MODULE
  30 # include "crypto/rand_pool.h"
  31 # include "prov/seeding.h"
  32
  33 # ifndef OPENSSL_NO_ENGINE
  34 /* non-NULL if default_RAND_meth is ENGINE-provided */
  35 static ENGINE *funct_ref;
  36 static CRYPTO_RWLOCK *rand_engine_lock;
  37 # endif
  38 # ifndef OPENSSL_NO_DEPRECATED_3_0
  39 static CRYPTO_RWLOCK *rand_meth_lock;
  40 static const RAND_METHOD *default_RAND_meth;
  41 # endif
  42 static CRYPTO_ONCE rand_init = CRYPTO_ONCE_STATIC_INIT;
  43
  44 static int rand_inited = 0;
  45
  46 DEFINE_RUN_ONCE_STATIC(do_rand_init)
  47 {
  48 # ifndef OPENSSL_NO_ENGINE
  49     rand_engine_lock = CRYPTO_THREAD_lock_new();
  50     if (rand_engine_lock == NULL)
  51         return 0;
  52 # endif
  53
  54 # ifndef OPENSSL_NO_DEPRECATED_3_0
  55     rand_meth_lock = CRYPTO_THREAD_lock_new();
  56     if (rand_meth_lock == NULL)
  57         goto err;
  58 # endif
  59
  60     if (!ossl_rand_pool_init())
  61         goto err;
  62
  63     rand_inited = 1;
  64     return 1;
  65
  66  err:
  67 # ifndef OPENSSL_NO_DEPRECATED_3_0
  68     CRYPTO_THREAD_lock_free(rand_meth_lock);
  69     rand_meth_lock = NULL;
  70 # endif
  71 # ifndef OPENSSL_NO_ENGINE
  72     CRYPTO_THREAD_lock_free(rand_engine_lock);
  73     rand_engine_lock = NULL;
  74 # endif
  75     return 0;
  76 }
  77
  78 void ossl_rand_cleanup_int(void)
  79 {
  80 # ifndef OPENSSL_NO_DEPRECATED_3_0
  81     const RAND_METHOD *meth = default_RAND_meth;
  82
  83     if (!rand_inited)
  84         return;
  85
  86     if (meth != NULL && meth->cleanup != NULL)
  87         meth->cleanup();
  88     RAND_set_rand_method(NULL);
  89 # endif
  90     ossl_rand_pool_cleanup();
  91 # ifndef OPENSSL_NO_ENGINE
  92     CRYPTO_THREAD_lock_free(rand_engine_lock);
  93     rand_engine_lock = NULL;
  94 # endif
  95 # ifndef OPENSSL_NO_DEPRECATED_3_0
  96     CRYPTO_THREAD_lock_free(rand_meth_lock);
  97     rand_meth_lock = NULL;
  98 # endif
  99     rand_inited = 0;
 100 }
 101
 102 /*
 103  * RAND_close_seed_files() ensures that any seed file descriptors are
 104  * closed after use.  This only applies to libcrypto/default provider,
 105  * it does not apply to other providers.
 106  */
 107 void RAND_keep_random_devices_open(int keep)
 108 {
 109     if (RUN_ONCE(&rand_init, do_rand_init))
 110         ossl_rand_pool_keep_random_devices_open(keep);
 111 }
 112
 113 /*
 114  * RAND_poll() reseeds the default RNG using random input
 115  *
 116  * The random input is obtained from polling various entropy
 117  * sources which depend on the operating system and are
 118  * configurable via the --with-rand-seed configure option.
 119  */
 120 int RAND_poll(void)
 121 {
 122 # ifndef OPENSSL_NO_DEPRECATED_3_0
 123     const RAND_METHOD *meth = RAND_get_rand_method();
 124     int ret = meth == RAND_OpenSSL();
 125
 126     if (meth == NULL)
 127         return 0;
 128
 129     if (!ret) {
 130         /* fill random pool and seed the current legacy RNG */
 131         RAND_POOL *pool = ossl_rand_pool_new(RAND_DRBG_STRENGTH, 1,
 132                                              (RAND_DRBG_STRENGTH + 7) / 8,
 133                                              RAND_POOL_MAX_LENGTH);
 134
 135         if (pool == NULL)
 136             return 0;
 137
 138         if (ossl_pool_acquire_entropy(pool) == 0)
 139             goto err;
 140
 141         if (meth->add == NULL
 142             || meth->add(ossl_rand_pool_buffer(pool),
 143                          ossl_rand_pool_length(pool),
 144                          (ossl_rand_pool_entropy(pool) / 8.0)) == 0)
 145             goto err;
 146
 147         ret = 1;
 148      err:
 149         ossl_rand_pool_free(pool);
 150     }
 151     return ret;
 152 # else
 153     static const char salt[] = "polling";
 154
 155     RAND_seed(salt, sizeof(salt));
 156     return 1;
 157 # endif
 158 }
 159
 160 # ifndef OPENSSL_NO_DEPRECATED_3_0
 161 static int rand_set_rand_method_internal(const RAND_METHOD *meth,
 162                                          ossl_unused ENGINE *e)
 163 {
 164     if (!RUN_ONCE(&rand_init, do_rand_init))
 165         return 0;
 166
 167     if (!CRYPTO_THREAD_write_lock(rand_meth_lock))
 168         return 0;
 169 #  ifndef OPENSSL_NO_ENGINE
 170     ENGINE_finish(funct_ref);
 171     funct_ref = e;
 172 #  endif
 173     default_RAND_meth = meth;
 174     CRYPTO_THREAD_unlock(rand_meth_lock);
 175     return 1;
 176 }
 177
 178 int RAND_set_rand_method(const RAND_METHOD *meth)
 179 {
 180     return rand_set_rand_method_internal(meth, NULL);
 181 }
 182
 183 const RAND_METHOD *RAND_get_rand_method(void)
 184 {
 185     const RAND_METHOD *tmp_meth = NULL;
 186
 187     if (!RUN_ONCE(&rand_init, do_rand_init))
 188         return NULL;
 189
 190     if (!CRYPTO_THREAD_write_lock(rand_meth_lock))
 191         return NULL;
 192     if (default_RAND_meth == NULL) {
 193 #  ifndef OPENSSL_NO_ENGINE
 194         ENGINE *e;
 195
 196         /* If we have an engine that can do RAND, use it. */
 197         if ((e = ENGINE_get_default_RAND()) != NULL
 198                 && (tmp_meth = ENGINE_get_RAND(e)) != NULL) {
 199             funct_ref = e;
 200             default_RAND_meth = tmp_meth;
 201         } else {
 202             ENGINE_finish(e);
 203             default_RAND_meth = &ossl_rand_meth;
 204         }
 205 #  else
 206         default_RAND_meth = &ossl_rand_meth;
 207 #  endif
 208     }
 209     tmp_meth = default_RAND_meth;
 210     CRYPTO_THREAD_unlock(rand_meth_lock);
 211     return tmp_meth;
 212 }
 213
 214 #  if !defined(OPENSSL_NO_ENGINE)
 215 int RAND_set_rand_engine(ENGINE *engine)
 216 {
 217     const RAND_METHOD *tmp_meth = NULL;
 218
 219     if (!RUN_ONCE(&rand_init, do_rand_init))
 220         return 0;
 221
 222     if (engine != NULL) {
 223         if (!ENGINE_init(engine))
 224             return 0;
 225         tmp_meth = ENGINE_get_RAND(engine);
 226         if (tmp_meth == NULL) {
 227             ENGINE_finish(engine);
 228             return 0;
 229         }
 230     }
 231     if (!CRYPTO_THREAD_write_lock(rand_engine_lock)) {
 232         ENGINE_finish(engine);
 233         return 0;
 234     }
 235
 236     /* This function releases any prior ENGINE so call it first */
 237     rand_set_rand_method_internal(tmp_meth, engine);
 238     CRYPTO_THREAD_unlock(rand_engine_lock);
 239     return 1;
 240 }
 241 #  endif
 242 # endif /* OPENSSL_NO_DEPRECATED_3_0 */
 243
 244 void RAND_seed(const void *buf, int num)
 245 {
 246     EVP_RAND_CTX *drbg;
 247 # ifndef OPENSSL_NO_DEPRECATED_3_0
 248     const RAND_METHOD *meth = RAND_get_rand_method();
 249
 250     if (meth != NULL && meth->seed != NULL) {
 251         meth->seed(buf, num);
 252         return;
 253     }
 254 # endif
 255
 256     drbg = RAND_get0_primary(NULL);
 257     if (drbg != NULL && num > 0)
 258         EVP_RAND_reseed(drbg, 0, NULL, 0, buf, num);
 259 }
 260
 261 void RAND_add(const void *buf, int num, double randomness)
 262 {
 263     EVP_RAND_CTX *drbg;
 264 # ifndef OPENSSL_NO_DEPRECATED_3_0
 265     const RAND_METHOD *meth = RAND_get_rand_method();
 266
 267     if (meth != NULL && meth->add != NULL) {
 268         meth->add(buf, num, randomness);
 269         return;
 270     }
 271 # endif
 272     drbg = RAND_get0_primary(NULL);
 273     if (drbg != NULL && num > 0)
 274         EVP_RAND_reseed(drbg, 0, NULL, 0, buf, num);
 275 }
 276
 277 # if !defined(OPENSSL_NO_DEPRECATED_1_1_0)
 278 int RAND_pseudo_bytes(unsigned char *buf, int num)
 279 {
 280     const RAND_METHOD *meth = RAND_get_rand_method();
 281
 282     if (meth != NULL && meth->pseudorand != NULL)
 283         return meth->pseudorand(buf, num);
 284     ERR_raise(ERR_LIB_RAND, RAND_R_FUNC_NOT_IMPLEMENTED);
 285     return -1;
 286 }
 287 # endif
 288
 289 int RAND_status(void)
 290 {
 291     EVP_RAND_CTX *rand;
 292 # ifndef OPENSSL_NO_DEPRECATED_3_0
 293     const RAND_METHOD *meth = RAND_get_rand_method();
 294
 295     if (meth != NULL && meth != RAND_OpenSSL())
 296         return meth->status != NULL ? meth->status() : 0;
 297 # endif
 298
 299     if ((rand = RAND_get0_primary(NULL)) == NULL)
 300         return 0;
 301     return EVP_RAND_state(rand) == EVP_RAND_STATE_READY;
 302 }
 303 # else  /* !FIPS_MODULE */
 304
 305 # ifndef OPENSSL_NO_DEPRECATED_3_0
 306 const RAND_METHOD *RAND_get_rand_method(void)
 307 {
 308     return NULL;
 309 }
 310 # endif
 311 #endif /* !FIPS_MODULE */
 312
 313 /*
 314  * This function is not part of RAND_METHOD, so if we're not using
 315  * the default method, then just call RAND_bytes().  Otherwise make
 316  * sure we're instantiated and use the private DRBG.
 317  */
 318 int RAND_priv_bytes_ex(OSSL_LIB_CTX *ctx, unsigned char *buf, int num,
 319                        unsigned int strength)
 320 {
 321     EVP_RAND_CTX *rand;
 322 #ifndef OPENSSL_NO_DEPRECATED_3_0
 323     const RAND_METHOD *meth = RAND_get_rand_method();
 324
 325     if (meth != NULL && meth != RAND_OpenSSL()) {
 326         if (meth->bytes != NULL)
 327             return meth->bytes(buf, num);
 328         ERR_raise(ERR_LIB_RAND, RAND_R_FUNC_NOT_IMPLEMENTED);
 329         return -1;
 330     }
 331 #endif
 332
 333     rand = RAND_get0_private(ctx);
 334     if (rand != NULL)
 335         return EVP_RAND_generate(rand, buf, num, strength, 0, NULL, 0);
 336
 337     return 0;
 338 }
 339
 340 int RAND_priv_bytes(unsigned char *buf, int num)
 341 {
 342     return RAND_priv_bytes_ex(NULL, buf, num, 0);
 343 }
 344
 345 int RAND_bytes_ex(OSSL_LIB_CTX *ctx, unsigned char *buf, int num,
 346                   unsigned int strength)
 347 {
 348     EVP_RAND_CTX *rand;
 349 #ifndef OPENSSL_NO_DEPRECATED_3_0
 350     const RAND_METHOD *meth = RAND_get_rand_method();
 351
 352     if (meth != NULL && meth != RAND_OpenSSL()) {
 353         if (meth->bytes != NULL)
 354             return meth->bytes(buf, num);
 355         ERR_raise(ERR_LIB_RAND, RAND_R_FUNC_NOT_IMPLEMENTED);
 356         return -1;
 357     }
 358 #endif
 359
 360     rand = RAND_get0_public(ctx);
 361     if (rand != NULL)
 362         return EVP_RAND_generate(rand, buf, num, strength, 0, NULL, 0);
 363
 364     return 0;
 365 }
 366
 367 int RAND_bytes(unsigned char *buf, int num)
 368 {
 369     return RAND_bytes_ex(NULL, buf, num, 0);
 370 }
 371
 372 typedef struct rand_global_st {
 373     /*
 374      * The three shared DRBG instances
 375      *
 376      * There are three shared DRBG instances: <primary>, <public>, and
 377      * <private>.  The <public> and <private> DRBGs are secondary ones.
 378      * These are used for non-secret (e.g. nonces) and secret
 379      * (e.g. private keys) data respectively.
 380      */
 381     CRYPTO_RWLOCK *lock;
 382
 383     EVP_RAND_CTX *seed;
 384
 385     /*
 386      * The <primary> DRBG
 387      *
 388      * Not used directly by the application, only for reseeding the two other
 389      * DRBGs. It reseeds itself by pulling either randomness from os entropy
 390      * sources or by consuming randomness which was added by RAND_add().
 391      *
 392      * The <primary> DRBG is a global instance which is accessed concurrently by
 393      * all threads. The necessary locking is managed automatically by its child
 394      * DRBG instances during reseeding.
 395      */
 396     EVP_RAND_CTX *primary;
 397
 398     /*
 399      * The <public> DRBG
 400      *
 401      * Used by default for generating random bytes using RAND_bytes().
 402      *
 403      * The <public> secondary DRBG is thread-local, i.e., there is one instance
 404      * per thread.
 405      */
 406     CRYPTO_THREAD_LOCAL public;
 407
 408     /*
 409      * The <private> DRBG
 410      *
 411      * Used by default for generating private keys using RAND_priv_bytes()
 412      *
 413      * The <private> secondary DRBG is thread-local, i.e., there is one
 414      * instance per thread.
 415      */
 416     CRYPTO_THREAD_LOCAL private;
 417
 418     /* Which RNG is being used by default and it's configuration settings */
 419     char *rng_name;
 420     char *rng_cipher;
 421     char *rng_digest;
 422     char *rng_propq;
 423
 424     /* Allow the randomness source to be changed */
 425     char *seed_name;
 426     char *seed_propq;
 427 } RAND_GLOBAL;
 428
 429 /*
 430  * Initialize the OSSL_LIB_CTX global DRBGs on first use.
 431  * Returns the allocated global data on success or NULL on failure.
 432  */
 433 static void *rand_ossl_ctx_new(OSSL_LIB_CTX *libctx)
 434 {
 435     RAND_GLOBAL *dgbl = OPENSSL_zalloc(sizeof(*dgbl));
 436
 437     if (dgbl == NULL)
 438         return NULL;
 439
 440 #ifndef FIPS_MODULE
 441     /*
 442      * We need to ensure that base libcrypto thread handling has been
 443      * initialised.
 444      */
 445      OPENSSL_init_crypto(OPENSSL_INIT_BASE_ONLY, NULL);
 446 #endif
 447
 448     dgbl->lock = CRYPTO_THREAD_lock_new();
 449     if (dgbl->lock == NULL)
 450         goto err1;
 451
 452     if (!CRYPTO_THREAD_init_local(&dgbl->private, NULL))
 453         goto err1;
 454
 455     if (!CRYPTO_THREAD_init_local(&dgbl->public, NULL))
 456         goto err2;
 457
 458     return dgbl;
 459
 460  err2:
 461     CRYPTO_THREAD_cleanup_local(&dgbl->private);
 462  err1:
 463     CRYPTO_THREAD_lock_free(dgbl->lock);
 464     OPENSSL_free(dgbl);
 465     return NULL;
 466 }
 467
 468 static void rand_ossl_ctx_free(void *vdgbl)
 469 {
 470     RAND_GLOBAL *dgbl = vdgbl;
 471
 472     if (dgbl == NULL)
 473         return;
 474
 475     CRYPTO_THREAD_lock_free(dgbl->lock);
 476     CRYPTO_THREAD_cleanup_local(&dgbl->private);
 477     CRYPTO_THREAD_cleanup_local(&dgbl->public);
 478     EVP_RAND_CTX_free(dgbl->primary);
 479     EVP_RAND_CTX_free(dgbl->seed);
 480     OPENSSL_free(dgbl->rng_name);
 481     OPENSSL_free(dgbl->rng_cipher);
 482     OPENSSL_free(dgbl->rng_digest);
 483     OPENSSL_free(dgbl->rng_propq);
 484     OPENSSL_free(dgbl->seed_name);
 485     OPENSSL_free(dgbl->seed_propq);
 486
 487     OPENSSL_free(dgbl);
 488 }
 489
 490 static const OSSL_LIB_CTX_METHOD rand_drbg_ossl_ctx_method = {
 491     OSSL_LIB_CTX_METHOD_DEFAULT_PRIORITY,
 492     rand_ossl_ctx_new,
 493     rand_ossl_ctx_free,
 494 };
 495
 496 static RAND_GLOBAL *rand_get_global(OSSL_LIB_CTX *libctx)
 497 {
 498     return ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_DRBG_INDEX,
 499                                  &rand_drbg_ossl_ctx_method);
 500 }
 501
 502 static void rand_delete_thread_state(void *arg)
 503 {
 504     OSSL_LIB_CTX *ctx = arg;
 505     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 506     EVP_RAND_CTX *rand;
 507
 508     if (dgbl == NULL)
 509         return;
 510
 511     rand = CRYPTO_THREAD_get_local(&dgbl->public);
 512     CRYPTO_THREAD_set_local(&dgbl->public, NULL);
 513     EVP_RAND_CTX_free(rand);
 514
 515     rand = CRYPTO_THREAD_get_local(&dgbl->private);
 516     CRYPTO_THREAD_set_local(&dgbl->private, NULL);
 517     EVP_RAND_CTX_free(rand);
 518 }
 519
 520 #ifndef FIPS_MODULE
 521 static EVP_RAND_CTX *rand_new_seed(OSSL_LIB_CTX *libctx)
 522 {
 523     EVP_RAND *rand;
 524     RAND_GLOBAL *dgbl = rand_get_global(libctx);
 525     EVP_RAND_CTX *ctx;
 526     char *name;
 527
 528     name = dgbl->seed_name != NULL ? dgbl->seed_name : "SEED-SRC";
 529     rand = EVP_RAND_fetch(libctx, name, dgbl->seed_propq);
 530     if (rand == NULL) {
 531         ERR_raise(ERR_LIB_RAND, RAND_R_UNABLE_TO_FETCH_DRBG);
 532         return NULL;
 533     }
 534     ctx = EVP_RAND_CTX_new(rand, NULL);
 535     EVP_RAND_free(rand);
 536     if (ctx == NULL) {
 537         ERR_raise(ERR_LIB_RAND, RAND_R_UNABLE_TO_CREATE_DRBG);
 538         return NULL;
 539     }
 540     if (!EVP_RAND_instantiate(ctx, 0, 0, NULL, 0, NULL)) {
 541         ERR_raise(ERR_LIB_RAND, RAND_R_ERROR_INSTANTIATING_DRBG);
 542         EVP_RAND_CTX_free(ctx);
 543         return NULL;
 544     }
 545     return ctx;
 546 }
 547 #endif
 548
 549 static EVP_RAND_CTX *rand_new_drbg(OSSL_LIB_CTX *libctx, EVP_RAND_CTX *parent,
 550                                    unsigned int reseed_interval,
 551                                    time_t reseed_time_interval)
 552 {
 553     EVP_RAND *rand;
 554     RAND_GLOBAL *dgbl = rand_get_global(libctx);
 555     EVP_RAND_CTX *ctx;
 556     OSSL_PARAM params[7], *p = params;
 557     char *name, *cipher;
 558
 559     name = dgbl->rng_name != NULL ? dgbl->rng_name : "CTR-DRBG";
 560     rand = EVP_RAND_fetch(libctx, name, dgbl->rng_propq);
 561     if (rand == NULL) {
 562         ERR_raise(ERR_LIB_RAND, RAND_R_UNABLE_TO_FETCH_DRBG);
 563         return NULL;
 564     }
 565     ctx = EVP_RAND_CTX_new(rand, parent);
 566     EVP_RAND_free(rand);
 567     if (ctx == NULL) {
 568         ERR_raise(ERR_LIB_RAND, RAND_R_UNABLE_TO_CREATE_DRBG);
 569         return NULL;
 570     }
 571
 572     /*
 573      * Rather than trying to decode the DRBG settings, just pass them through
 574      * and rely on the other end to ignore those it doesn't care about.
 575      */
 576     cipher = dgbl->rng_cipher != NULL ? dgbl->rng_cipher : "AES-256-CTR";
 577     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_CIPHER,
 578                                             cipher, 0);
 579     if (dgbl->rng_digest != NULL)
 580         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_DIGEST,
 581                                                 dgbl->rng_digest, 0);
 582     if (dgbl->rng_propq != NULL)
 583         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_PROPERTIES,
 584                                                 dgbl->rng_propq, 0);
 585     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_ALG_PARAM_MAC, "HMAC", 0);
 586     *p++ = OSSL_PARAM_construct_uint(OSSL_DRBG_PARAM_RESEED_REQUESTS,
 587                                      &reseed_interval);
 588     *p++ = OSSL_PARAM_construct_time_t(OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL,
 589                                        &reseed_time_interval);
 590     *p = OSSL_PARAM_construct_end();
 591     if (!EVP_RAND_instantiate(ctx, 0, 0, NULL, 0, params)) {
 592         ERR_raise(ERR_LIB_RAND, RAND_R_ERROR_INSTANTIATING_DRBG);
 593         EVP_RAND_CTX_free(ctx);
 594         return NULL;
 595     }
 596     return ctx;
 597 }
 598
 599 /*
 600  * Get the primary random generator.
 601  * Returns pointer to its EVP_RAND_CTX on success, NULL on failure.
 602  *
 603  */
 604 EVP_RAND_CTX *RAND_get0_primary(OSSL_LIB_CTX *ctx)
 605 {
 606     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 607     EVP_RAND_CTX *ret;
 608
 609     if (dgbl == NULL)
 610         return NULL;
 611
 612     if (!CRYPTO_THREAD_read_lock(dgbl->lock))
 613         return NULL;
 614
 615     ret = dgbl->primary;
 616     CRYPTO_THREAD_unlock(dgbl->lock);
 617
 618     if (ret != NULL)
 619         return ret;
 620
 621     if (!CRYPTO_THREAD_write_lock(dgbl->lock))
 622         return NULL;
 623
 624     ret = dgbl->primary;
 625     if (ret != NULL) {
 626         CRYPTO_THREAD_unlock(dgbl->lock);
 627         return ret;
 628     }
 629
 630 #ifndef FIPS_MODULE
 631     if (dgbl->seed == NULL) {
 632         ERR_set_mark();
 633         dgbl->seed = rand_new_seed(ctx);
 634         ERR_pop_to_mark();
 635     }
 636 #endif
 637
 638     ret = dgbl->primary = rand_new_drbg(ctx, dgbl->seed,
 639                                         PRIMARY_RESEED_INTERVAL,
 640                                         PRIMARY_RESEED_TIME_INTERVAL);
 641     /*
 642     * The primary DRBG may be shared between multiple threads so we must
 643     * enable locking.
 644     */
 645     if (ret != NULL && !EVP_RAND_enable_locking(ret)) {
 646         ERR_raise(ERR_LIB_EVP, EVP_R_UNABLE_TO_ENABLE_LOCKING);
 647         EVP_RAND_CTX_free(ret);
 648         ret = dgbl->primary = NULL;
 649     }
 650     CRYPTO_THREAD_unlock(dgbl->lock);
 651
 652     return ret;
 653 }
 654
 655 /*
 656  * Get the public random generator.
 657  * Returns pointer to its EVP_RAND_CTX on success, NULL on failure.
 658  */
 659 EVP_RAND_CTX *RAND_get0_public(OSSL_LIB_CTX *ctx)
 660 {
 661     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 662     EVP_RAND_CTX *rand, *primary;
 663
 664     if (dgbl == NULL)
 665         return NULL;
 666
 667     rand = CRYPTO_THREAD_get_local(&dgbl->public);
 668     if (rand == NULL) {
 669         primary = RAND_get0_primary(ctx);
 670         if (primary == NULL)
 671             return NULL;
 672
 673         ctx = ossl_lib_ctx_get_concrete(ctx);
 674         /*
 675          * If the private is also NULL then this is the first time we've
 676          * used this thread.
 677          */
 678         if (CRYPTO_THREAD_get_local(&dgbl->private) == NULL
 679                 && !ossl_init_thread_start(NULL, ctx, rand_delete_thread_state))
 680             return NULL;
 681         rand = rand_new_drbg(ctx, primary, SECONDARY_RESEED_INTERVAL,
 682                              SECONDARY_RESEED_TIME_INTERVAL);
 683         CRYPTO_THREAD_set_local(&dgbl->public, rand);
 684     }
 685     return rand;
 686 }
 687
 688 /*
 689  * Get the private random generator.
 690  * Returns pointer to its EVP_RAND_CTX on success, NULL on failure.
 691  */
 692 EVP_RAND_CTX *RAND_get0_private(OSSL_LIB_CTX *ctx)
 693 {
 694     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 695     EVP_RAND_CTX *rand, *primary;
 696
 697     if (dgbl == NULL)
 698         return NULL;
 699
 700     rand = CRYPTO_THREAD_get_local(&dgbl->private);
 701     if (rand == NULL) {
 702         primary = RAND_get0_primary(ctx);
 703         if (primary == NULL)
 704             return NULL;
 705
 706         ctx = ossl_lib_ctx_get_concrete(ctx);
 707         /*
 708          * If the public is also NULL then this is the first time we've
 709          * used this thread.
 710          */
 711         if (CRYPTO_THREAD_get_local(&dgbl->public) == NULL
 712                 && !ossl_init_thread_start(NULL, ctx, rand_delete_thread_state))
 713             return NULL;
 714         rand = rand_new_drbg(ctx, primary, SECONDARY_RESEED_INTERVAL,
 715                              SECONDARY_RESEED_TIME_INTERVAL);
 716         CRYPTO_THREAD_set_local(&dgbl->private, rand);
 717     }
 718     return rand;
 719 }
 720
 721 #ifndef FIPS_MODULE
 722 static int random_set_string(char **p, const char *s)
 723 {
 724     char *d = NULL;
 725
 726     if (s != NULL) {
 727         d = OPENSSL_strdup(s);
 728         if (d == NULL) {
 729             ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
 730             return 0;
 731         }
 732     }
 733     OPENSSL_free(*p);
 734     *p = d;
 735     return 1;
 736 }
 737
 738 /*
 739  * Load the DRBG definitions from a configuration file.
 740  */
 741 static int random_conf_init(CONF_IMODULE *md, const CONF *cnf)
 742 {
 743     STACK_OF(CONF_VALUE) *elist;
 744     CONF_VALUE *cval;
 745     RAND_GLOBAL *dgbl = rand_get_global(cnf->libctx);
 746     int i, r = 1;
 747
 748     OSSL_TRACE1(CONF, "Loading random module: section %s\n",
 749                 CONF_imodule_get_value(md));
 750
 751     /* Value is a section containing RANDOM configuration */
 752     elist = NCONF_get_section(cnf, CONF_imodule_get_value(md));
 753     if (elist == NULL) {
 754         ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_RANDOM_SECTION_ERROR);
 755         return 0;
 756     }
 757
 758     for (i = 0; i < sk_CONF_VALUE_num(elist); i++) {
 759         cval = sk_CONF_VALUE_value(elist, i);
 760         if (strcasecmp(cval->name, "random") == 0) {
 761             if (!random_set_string(&dgbl->rng_name, cval->value))
 762                 return 0;
 763         } else if (strcasecmp(cval->name, "cipher") == 0) {
 764             if (!random_set_string(&dgbl->rng_cipher, cval->value))
 765                 return 0;
 766         } else if (strcasecmp(cval->name, "digest") == 0) {
 767             if (!random_set_string(&dgbl->rng_digest, cval->value))
 768                 return 0;
 769         } else if (strcasecmp(cval->name, "properties") == 0) {
 770             if (!random_set_string(&dgbl->rng_propq, cval->value))
 771                 return 0;
 772         } else if (strcasecmp(cval->name, "seed") == 0) {
 773             if (!random_set_string(&dgbl->seed_name, cval->value))
 774                 return 0;
 775         } else if (strcasecmp(cval->name, "seed_properties") == 0) {
 776             if (!random_set_string(&dgbl->seed_propq, cval->value))
 777                 return 0;
 778         } else {
 779             ERR_raise_data(ERR_LIB_CRYPTO,
 780                            CRYPTO_R_UNKNOWN_NAME_IN_RANDOM_SECTION,
 781                            "name=%s, value=%s", cval->name, cval->value);
 782             r = 0;
 783         }
 784     }
 785     return r;
 786 }
 787
 788
 789 static void random_conf_deinit(CONF_IMODULE *md)
 790 {
 791     OSSL_TRACE(CONF, "Cleaned up random\n");
 792 }
 793
 794 void ossl_random_add_conf_module(void)
 795 {
 796     OSSL_TRACE(CONF, "Adding config module 'random'\n");
 797     CONF_module_add("random", random_conf_init, random_conf_deinit);
 798 }
 799
 800 int RAND_set_DRBG_type(OSSL_LIB_CTX *ctx, const char *drbg, const char *propq,
 801                        const char *cipher, const char *digest)
 802 {
 803     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 804
 805     if (dgbl == NULL)
 806         return 0;
 807     if (dgbl->primary != NULL) {
 808         ERR_raise(ERR_LIB_CRYPTO, RAND_R_ALREADY_INSTANTIATED);
 809         return 0;
 810     }
 811     return random_set_string(&dgbl->rng_name, drbg)
 812         && random_set_string(&dgbl->rng_propq, propq)
 813         && random_set_string(&dgbl->rng_cipher, cipher)
 814         && random_set_string(&dgbl->rng_digest, digest);
 815 }
 816
 817 int RAND_set_seed_source_type(OSSL_LIB_CTX *ctx, const char *seed,
 818                               const char *propq)
 819 {
 820     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 821
 822     if (dgbl == NULL)
 823         return 0;
 824     if (dgbl->primary != NULL) {
 825         ERR_raise(ERR_LIB_CRYPTO, RAND_R_ALREADY_INSTANTIATED);
 826         return 0;
 827     }
 828     return random_set_string(&dgbl->seed_name, seed)
 829         && random_set_string(&dgbl->seed_propq, propq);
 830 }
 831
 832 #endif