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 {
 320     EVP_RAND_CTX *rand;
 321 #ifndef OPENSSL_NO_DEPRECATED_3_0
 322     const RAND_METHOD *meth = RAND_get_rand_method();
 323
 324     if (meth != NULL && meth != RAND_OpenSSL()) {
 325         if (meth->bytes != NULL)
 326             return meth->bytes(buf, num);
 327         ERR_raise(ERR_LIB_RAND, RAND_R_FUNC_NOT_IMPLEMENTED);
 328         return -1;
 329     }
 330 #endif
 331
 332     rand = RAND_get0_private(ctx);
 333     if (rand != NULL)
 334         return EVP_RAND_generate(rand, buf, num, 0, 0, NULL, 0);
 335
 336     return 0;
 337 }
 338
 339 int RAND_priv_bytes(unsigned char *buf, int num)
 340 {
 341     return RAND_priv_bytes_ex(NULL, buf, num);
 342 }
 343
 344 int RAND_bytes_ex(OSSL_LIB_CTX *ctx, unsigned char *buf, int num)
 345 {
 346     EVP_RAND_CTX *rand;
 347 #ifndef OPENSSL_NO_DEPRECATED_3_0
 348     const RAND_METHOD *meth = RAND_get_rand_method();
 349
 350     if (meth != NULL && meth != RAND_OpenSSL()) {
 351         if (meth->bytes != NULL)
 352             return meth->bytes(buf, num);
 353         ERR_raise(ERR_LIB_RAND, RAND_R_FUNC_NOT_IMPLEMENTED);
 354         return -1;
 355     }
 356 #endif
 357
 358     rand = RAND_get0_public(ctx);
 359     if (rand != NULL)
 360         return EVP_RAND_generate(rand, buf, num, 0, 0, NULL, 0);
 361
 362     return 0;
 363 }
 364
 365 int RAND_bytes(unsigned char *buf, int num)
 366 {
 367     return RAND_bytes_ex(NULL, buf, num);
 368 }
 369
 370 typedef struct rand_global_st {
 371     /*
 372      * The three shared DRBG instances
 373      *
 374      * There are three shared DRBG instances: <primary>, <public>, and
 375      * <private>.  The <public> and <private> DRBGs are secondary ones.
 376      * These are used for non-secret (e.g. nonces) and secret
 377      * (e.g. private keys) data respectively.
 378      */
 379     CRYPTO_RWLOCK *lock;
 380
 381     EVP_RAND_CTX *seed;
 382
 383     /*
 384      * The <primary> DRBG
 385      *
 386      * Not used directly by the application, only for reseeding the two other
 387      * DRBGs. It reseeds itself by pulling either randomness from os entropy
 388      * sources or by consuming randomness which was added by RAND_add().
 389      *
 390      * The <primary> DRBG is a global instance which is accessed concurrently by
 391      * all threads. The necessary locking is managed automatically by its child
 392      * DRBG instances during reseeding.
 393      */
 394     EVP_RAND_CTX *primary;
 395
 396     /*
 397      * The <public> DRBG
 398      *
 399      * Used by default for generating random bytes using RAND_bytes().
 400      *
 401      * The <public> secondary DRBG is thread-local, i.e., there is one instance
 402      * per thread.
 403      */
 404     CRYPTO_THREAD_LOCAL public;
 405
 406     /*
 407      * The <private> DRBG
 408      *
 409      * Used by default for generating private keys using RAND_priv_bytes()
 410      *
 411      * The <private> secondary DRBG is thread-local, i.e., there is one
 412      * instance per thread.
 413      */
 414     CRYPTO_THREAD_LOCAL private;
 415
 416     /* Which RNG is being used by default and it's configuration settings */
 417     char *rng_name;
 418     char *rng_cipher;
 419     char *rng_digest;
 420     char *rng_propq;
 421
 422     /* Allow the randomness source to be changed */
 423     char *seed_name;
 424     char *seed_propq;
 425 } RAND_GLOBAL;
 426
 427 /*
 428  * Initialize the OSSL_LIB_CTX global DRBGs on first use.
 429  * Returns the allocated global data on success or NULL on failure.
 430  */
 431 static void *rand_ossl_ctx_new(OSSL_LIB_CTX *libctx)
 432 {
 433     RAND_GLOBAL *dgbl = OPENSSL_zalloc(sizeof(*dgbl));
 434
 435     if (dgbl == NULL)
 436         return NULL;
 437
 438 #ifndef FIPS_MODULE
 439     /*
 440      * We need to ensure that base libcrypto thread handling has been
 441      * initialised.
 442      */
 443      OPENSSL_init_crypto(OPENSSL_INIT_BASE_ONLY, NULL);
 444 #endif
 445
 446     dgbl->lock = CRYPTO_THREAD_lock_new();
 447     if (dgbl->lock == NULL)
 448         goto err1;
 449
 450     if (!CRYPTO_THREAD_init_local(&dgbl->private, NULL))
 451         goto err1;
 452
 453     if (!CRYPTO_THREAD_init_local(&dgbl->public, NULL))
 454         goto err2;
 455
 456     return dgbl;
 457
 458  err2:
 459     CRYPTO_THREAD_cleanup_local(&dgbl->private);
 460  err1:
 461     CRYPTO_THREAD_lock_free(dgbl->lock);
 462     OPENSSL_free(dgbl);
 463     return NULL;
 464 }
 465
 466 static void rand_ossl_ctx_free(void *vdgbl)
 467 {
 468     RAND_GLOBAL *dgbl = vdgbl;
 469
 470     if (dgbl == NULL)
 471         return;
 472
 473     CRYPTO_THREAD_lock_free(dgbl->lock);
 474     CRYPTO_THREAD_cleanup_local(&dgbl->private);
 475     CRYPTO_THREAD_cleanup_local(&dgbl->public);
 476     EVP_RAND_CTX_free(dgbl->primary);
 477     EVP_RAND_CTX_free(dgbl->seed);
 478     OPENSSL_free(dgbl->rng_name);
 479     OPENSSL_free(dgbl->rng_cipher);
 480     OPENSSL_free(dgbl->rng_digest);
 481     OPENSSL_free(dgbl->rng_propq);
 482     OPENSSL_free(dgbl->seed_name);
 483     OPENSSL_free(dgbl->seed_propq);
 484
 485     OPENSSL_free(dgbl);
 486 }
 487
 488 static const OSSL_LIB_CTX_METHOD rand_drbg_ossl_ctx_method = {
 489     OSSL_LIB_CTX_METHOD_DEFAULT_PRIORITY,
 490     rand_ossl_ctx_new,
 491     rand_ossl_ctx_free,
 492 };
 493
 494 static RAND_GLOBAL *rand_get_global(OSSL_LIB_CTX *libctx)
 495 {
 496     return ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_DRBG_INDEX,
 497                                  &rand_drbg_ossl_ctx_method);
 498 }
 499
 500 static void rand_delete_thread_state(void *arg)
 501 {
 502     OSSL_LIB_CTX *ctx = arg;
 503     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 504     EVP_RAND_CTX *rand;
 505
 506     if (dgbl == NULL)
 507         return;
 508
 509     rand = CRYPTO_THREAD_get_local(&dgbl->public);
 510     CRYPTO_THREAD_set_local(&dgbl->public, NULL);
 511     EVP_RAND_CTX_free(rand);
 512
 513     rand = CRYPTO_THREAD_get_local(&dgbl->private);
 514     CRYPTO_THREAD_set_local(&dgbl->private, NULL);
 515     EVP_RAND_CTX_free(rand);
 516 }
 517
 518 #ifndef FIPS_MODULE
 519 static EVP_RAND_CTX *rand_new_seed(OSSL_LIB_CTX *libctx)
 520 {
 521     EVP_RAND *rand;
 522     RAND_GLOBAL *dgbl = rand_get_global(libctx);
 523     EVP_RAND_CTX *ctx;
 524     char *name;
 525
 526     name = dgbl->seed_name != NULL ? dgbl->seed_name : "SEED-SRC";
 527     rand = EVP_RAND_fetch(libctx, name, dgbl->seed_propq);
 528     if (rand == NULL) {
 529         ERR_raise(ERR_LIB_RAND, RAND_R_UNABLE_TO_FETCH_DRBG);
 530         return NULL;
 531     }
 532     ctx = EVP_RAND_CTX_new(rand, NULL);
 533     EVP_RAND_free(rand);
 534     if (ctx == NULL) {
 535         ERR_raise(ERR_LIB_RAND, RAND_R_UNABLE_TO_CREATE_DRBG);
 536         return NULL;
 537     }
 538     if (!EVP_RAND_instantiate(ctx, 0, 0, NULL, 0, NULL)) {
 539         ERR_raise(ERR_LIB_RAND, RAND_R_ERROR_INSTANTIATING_DRBG);
 540         EVP_RAND_CTX_free(ctx);
 541         return NULL;
 542     }
 543     return ctx;
 544 }
 545 #endif
 546
 547 static EVP_RAND_CTX *rand_new_drbg(OSSL_LIB_CTX *libctx, EVP_RAND_CTX *parent,
 548                                    unsigned int reseed_interval,
 549                                    time_t reseed_time_interval)
 550 {
 551     EVP_RAND *rand;
 552     RAND_GLOBAL *dgbl = rand_get_global(libctx);
 553     EVP_RAND_CTX *ctx;
 554     OSSL_PARAM params[7], *p = params;
 555     char *name, *cipher;
 556
 557     name = dgbl->rng_name != NULL ? dgbl->rng_name : "CTR-DRBG";
 558     rand = EVP_RAND_fetch(libctx, name, dgbl->rng_propq);
 559     if (rand == NULL) {
 560         ERR_raise(ERR_LIB_RAND, RAND_R_UNABLE_TO_FETCH_DRBG);
 561         return NULL;
 562     }
 563     ctx = EVP_RAND_CTX_new(rand, parent);
 564     EVP_RAND_free(rand);
 565     if (ctx == NULL) {
 566         ERR_raise(ERR_LIB_RAND, RAND_R_UNABLE_TO_CREATE_DRBG);
 567         return NULL;
 568     }
 569
 570     /*
 571      * Rather than trying to decode the DRBG settings, just pass them through
 572      * and rely on the other end to ignore those it doesn't care about.
 573      */
 574     cipher = dgbl->rng_cipher != NULL ? dgbl->rng_cipher : "AES-256-CTR";
 575     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_CIPHER,
 576                                             cipher, 0);
 577     if (dgbl->rng_digest != NULL)
 578         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_DIGEST,
 579                                                 dgbl->rng_digest, 0);
 580     if (dgbl->rng_propq != NULL)
 581         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_PROPERTIES,
 582                                                 dgbl->rng_propq, 0);
 583     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_ALG_PARAM_MAC, "HMAC", 0);
 584     *p++ = OSSL_PARAM_construct_uint(OSSL_DRBG_PARAM_RESEED_REQUESTS,
 585                                      &reseed_interval);
 586     *p++ = OSSL_PARAM_construct_time_t(OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL,
 587                                        &reseed_time_interval);
 588     *p = OSSL_PARAM_construct_end();
 589     if (!EVP_RAND_instantiate(ctx, 0, 0, NULL, 0, params)) {
 590         ERR_raise(ERR_LIB_RAND, RAND_R_ERROR_INSTANTIATING_DRBG);
 591         EVP_RAND_CTX_free(ctx);
 592         return NULL;
 593     }
 594     return ctx;
 595 }
 596
 597 /*
 598  * Get the primary random generator.
 599  * Returns pointer to its EVP_RAND_CTX on success, NULL on failure.
 600  *
 601  */
 602 EVP_RAND_CTX *RAND_get0_primary(OSSL_LIB_CTX *ctx)
 603 {
 604     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 605     EVP_RAND_CTX *ret;
 606
 607     if (dgbl == NULL)
 608         return NULL;
 609
 610     if (!CRYPTO_THREAD_read_lock(dgbl->lock))
 611         return NULL;
 612
 613     ret = dgbl->primary;
 614     CRYPTO_THREAD_unlock(dgbl->lock);
 615
 616     if (ret != NULL)
 617         return ret;
 618
 619     if (!CRYPTO_THREAD_write_lock(dgbl->lock))
 620         return NULL;
 621
 622     ret = dgbl->primary;
 623     if (ret != NULL) {
 624         CRYPTO_THREAD_unlock(dgbl->lock);
 625         return ret;
 626     }
 627
 628 #ifndef FIPS_MODULE
 629     if (dgbl->seed == NULL) {
 630         ERR_set_mark();
 631         dgbl->seed = rand_new_seed(ctx);
 632         ERR_pop_to_mark();
 633     }
 634 #endif
 635
 636     ret = dgbl->primary = rand_new_drbg(ctx, dgbl->seed,
 637                                         PRIMARY_RESEED_INTERVAL,
 638                                         PRIMARY_RESEED_TIME_INTERVAL);
 639     /*
 640     * The primary DRBG may be shared between multiple threads so we must
 641     * enable locking.
 642     */
 643     if (ret != NULL && !EVP_RAND_enable_locking(ret)) {
 644         ERR_raise(ERR_LIB_EVP, EVP_R_UNABLE_TO_ENABLE_LOCKING);
 645         EVP_RAND_CTX_free(ret);
 646         ret = dgbl->primary = NULL;
 647     }
 648     CRYPTO_THREAD_unlock(dgbl->lock);
 649
 650     return ret;
 651 }
 652
 653 /*
 654  * Get the public random generator.
 655  * Returns pointer to its EVP_RAND_CTX on success, NULL on failure.
 656  */
 657 EVP_RAND_CTX *RAND_get0_public(OSSL_LIB_CTX *ctx)
 658 {
 659     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 660     EVP_RAND_CTX *rand, *primary;
 661
 662     if (dgbl == NULL)
 663         return NULL;
 664
 665     rand = CRYPTO_THREAD_get_local(&dgbl->public);
 666     if (rand == NULL) {
 667         primary = RAND_get0_primary(ctx);
 668         if (primary == NULL)
 669             return NULL;
 670
 671         ctx = ossl_lib_ctx_get_concrete(ctx);
 672         /*
 673          * If the private is also NULL then this is the first time we've
 674          * used this thread.
 675          */
 676         if (CRYPTO_THREAD_get_local(&dgbl->private) == NULL
 677                 && !ossl_init_thread_start(NULL, ctx, rand_delete_thread_state))
 678             return NULL;
 679         rand = rand_new_drbg(ctx, primary, SECONDARY_RESEED_INTERVAL,
 680                              SECONDARY_RESEED_TIME_INTERVAL);
 681         CRYPTO_THREAD_set_local(&dgbl->public, rand);
 682     }
 683     return rand;
 684 }
 685
 686 /*
 687  * Get the private random generator.
 688  * Returns pointer to its EVP_RAND_CTX on success, NULL on failure.
 689  */
 690 EVP_RAND_CTX *RAND_get0_private(OSSL_LIB_CTX *ctx)
 691 {
 692     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 693     EVP_RAND_CTX *rand, *primary;
 694
 695     if (dgbl == NULL)
 696         return NULL;
 697
 698     rand = CRYPTO_THREAD_get_local(&dgbl->private);
 699     if (rand == NULL) {
 700         primary = RAND_get0_primary(ctx);
 701         if (primary == NULL)
 702             return NULL;
 703
 704         ctx = ossl_lib_ctx_get_concrete(ctx);
 705         /*
 706          * If the public is also NULL then this is the first time we've
 707          * used this thread.
 708          */
 709         if (CRYPTO_THREAD_get_local(&dgbl->public) == NULL
 710                 && !ossl_init_thread_start(NULL, ctx, rand_delete_thread_state))
 711             return NULL;
 712         rand = rand_new_drbg(ctx, primary, SECONDARY_RESEED_INTERVAL,
 713                              SECONDARY_RESEED_TIME_INTERVAL);
 714         CRYPTO_THREAD_set_local(&dgbl->private, rand);
 715     }
 716     return rand;
 717 }
 718
 719 #ifndef FIPS_MODULE
 720 static int random_set_string(char **p, const char *s)
 721 {
 722     char *d = NULL;
 723
 724     if (s != NULL) {
 725         d = OPENSSL_strdup(s);
 726         if (d == NULL) {
 727             ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
 728             return 0;
 729         }
 730     }
 731     OPENSSL_free(*p);
 732     *p = d;
 733     return 1;
 734 }
 735
 736 /*
 737  * Load the DRBG definitions from a configuration file.
 738  */
 739 static int random_conf_init(CONF_IMODULE *md, const CONF *cnf)
 740 {
 741     STACK_OF(CONF_VALUE) *elist;
 742     CONF_VALUE *cval;
 743     RAND_GLOBAL *dgbl = rand_get_global(cnf->libctx);
 744     int i, r = 1;
 745
 746     OSSL_TRACE1(CONF, "Loading random module: section %s\n",
 747                 CONF_imodule_get_value(md));
 748
 749     /* Value is a section containing RANDOM configuration */
 750     elist = NCONF_get_section(cnf, CONF_imodule_get_value(md));
 751     if (elist == NULL) {
 752         ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_RANDOM_SECTION_ERROR);
 753         return 0;
 754     }
 755
 756     for (i = 0; i < sk_CONF_VALUE_num(elist); i++) {
 757         cval = sk_CONF_VALUE_value(elist, i);
 758         if (strcasecmp(cval->name, "random") == 0) {
 759             if (!random_set_string(&dgbl->rng_name, cval->value))
 760                 return 0;
 761         } else if (strcasecmp(cval->name, "cipher") == 0) {
 762             if (!random_set_string(&dgbl->rng_cipher, cval->value))
 763                 return 0;
 764         } else if (strcasecmp(cval->name, "digest") == 0) {
 765             if (!random_set_string(&dgbl->rng_digest, cval->value))
 766                 return 0;
 767         } else if (strcasecmp(cval->name, "properties") == 0) {
 768             if (!random_set_string(&dgbl->rng_propq, cval->value))
 769                 return 0;
 770         } else if (strcasecmp(cval->name, "seed") == 0) {
 771             if (!random_set_string(&dgbl->seed_name, cval->value))
 772                 return 0;
 773         } else if (strcasecmp(cval->name, "seed_properties") == 0) {
 774             if (!random_set_string(&dgbl->seed_propq, cval->value))
 775                 return 0;
 776         } else {
 777             ERR_raise_data(ERR_LIB_CRYPTO,
 778                            CRYPTO_R_UNKNOWN_NAME_IN_RANDOM_SECTION,
 779                            "name=%s, value=%s", cval->name, cval->value);
 780             r = 0;
 781         }
 782     }
 783     return r;
 784 }
 785
 786
 787 static void random_conf_deinit(CONF_IMODULE *md)
 788 {
 789     OSSL_TRACE(CONF, "Cleaned up random\n");
 790 }
 791
 792 void ossl_random_add_conf_module(void)
 793 {
 794     OSSL_TRACE(CONF, "Adding config module 'random'\n");
 795     CONF_module_add("random", random_conf_init, random_conf_deinit);
 796 }
 797
 798 int RAND_set_DRBG_type(OSSL_LIB_CTX *ctx, const char *drbg, const char *propq,
 799                        const char *cipher, const char *digest)
 800 {
 801     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 802
 803     if (dgbl == NULL)
 804         return 0;
 805     if (dgbl->primary != NULL) {
 806         ERR_raise(ERR_LIB_CRYPTO, RAND_R_ALREADY_INSTANTIATED);
 807         return 0;
 808     }
 809     return random_set_string(&dgbl->rng_name, drbg)
 810         && random_set_string(&dgbl->rng_propq, propq)
 811         && random_set_string(&dgbl->rng_cipher, cipher)
 812         && random_set_string(&dgbl->rng_digest, digest);
 813 }
 814
 815 int RAND_set_seed_source_type(OSSL_LIB_CTX *ctx, const char *seed,
 816                               const char *propq)
 817 {
 818     RAND_GLOBAL *dgbl = rand_get_global(ctx);
 819
 820     if (dgbl == NULL)
 821         return 0;
 822     if (dgbl->primary != NULL) {
 823         ERR_raise(ERR_LIB_CRYPTO, RAND_R_ALREADY_INSTANTIATED);
 824         return 0;
 825     }
 826     return random_set_string(&dgbl->seed_name, seed)
 827         && random_set_string(&dgbl->seed_propq, propq);
 828 }
 829
 830 #endif