crypto/init.c

   1 /*
   2  * Copyright 2016-2018 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 "e_os.h"
  11 #include "internal/cryptlib_int.h"
  12 #include <openssl/err.h>
  13 #include "internal/rand_int.h"
  14 #include "internal/bio.h"
  15 #include <openssl/evp.h>
  16 #include "internal/evp_int.h"
  17 #include "internal/conf.h"
  18 #include "internal/async.h"
  19 #include "internal/engine.h"
  20 #include "internal/comp.h"
  21 #include "internal/err.h"
  22 #include "internal/err_int.h"
  23 #include "internal/objects.h"
  24 #include <stdlib.h>
  25 #include <assert.h>
  26 #include "internal/thread_once.h"
  27 #include "internal/dso_conf.h"
  28 #include "internal/dso.h"
  29 #include "internal/store.h"
  30
  31 static int stopped = 0;
  32
  33 /*
  34  * Since per-thread-specific-data destructors are not universally
  35  * available, i.e. not on Windows, only below CRYPTO_THREAD_LOCAL key
  36  * is assumed to have destructor associated. And then an effort is made
  37  * to call this single destructor on non-pthread platform[s].
  38  *
  39  * Initial value is "impossible". It is used as guard value to shortcut
  40  * destructor for threads terminating before libcrypto is initialized or
  41  * after it's de-initialized. Access to the key doesn't have to be
  42  * serialized for the said threads, because they didn't use libcrypto
  43  * and it doesn't matter if they pick "impossible" or derefernce real
  44  * key value and pull NULL past initialization in the first thread that
  45  * intends to use libcrypto.
  46  */
  47 static union {
  48     long sane;
  49     CRYPTO_THREAD_LOCAL value;
  50 } destructor_key = { -1 };
  51
  52 static void ossl_init_thread_stop(struct thread_local_inits_st *locals);
  53
  54 static void ossl_init_thread_destructor(void *local)
  55 {
  56     ossl_init_thread_stop((struct thread_local_inits_st *)local);
  57 }
  58
  59 static struct thread_local_inits_st *ossl_init_get_thread_local(int alloc)
  60 {
  61     struct thread_local_inits_st *local =
  62         CRYPTO_THREAD_get_local(&destructor_key.value);
  63
  64     if (alloc) {
  65         if (local == NULL
  66             && (local = OPENSSL_zalloc(sizeof(*local))) != NULL
  67             && !CRYPTO_THREAD_set_local(&destructor_key.value, local)) {
  68             OPENSSL_free(local);
  69             return NULL;
  70         }
  71     } else {
  72         CRYPTO_THREAD_set_local(&destructor_key.value, NULL);
  73     }
  74
  75     return local;
  76 }
  77
  78 typedef struct ossl_init_stop_st OPENSSL_INIT_STOP;
  79 struct ossl_init_stop_st {
  80     void (*handler)(void);
  81     OPENSSL_INIT_STOP *next;
  82 };
  83
  84 static OPENSSL_INIT_STOP *stop_handlers = NULL;
  85 static CRYPTO_RWLOCK *init_lock = NULL;
  86
  87 static CRYPTO_ONCE base = CRYPTO_ONCE_STATIC_INIT;
  88 static int base_inited = 0;
  89 DEFINE_RUN_ONCE_STATIC(ossl_init_base)
  90 {
  91     CRYPTO_THREAD_LOCAL key;
  92
  93 #ifdef OPENSSL_INIT_DEBUG
  94     fprintf(stderr, "OPENSSL_INIT: ossl_init_base: Setting up stop handlers\n");
  95 #endif
  96 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
  97     ossl_malloc_setup_failures();
  98 #endif
  99     if (!CRYPTO_THREAD_init_local(&key, ossl_init_thread_destructor))
 100         return 0;
 101     if ((init_lock = CRYPTO_THREAD_lock_new()) == NULL)
 102         goto err;
 103 #ifndef OPENSSL_SYS_UEFI
 104     if (atexit(OPENSSL_cleanup) != 0)
 105         goto err;
 106 #endif
 107     OPENSSL_cpuid_setup();
 108
 109     destructor_key.value = key;
 110     base_inited = 1;
 111     return 1;
 112
 113 err:
 114 #ifdef OPENSSL_INIT_DEBUG
 115     fprintf(stderr, "OPENSSL_INIT: ossl_init_base not ok!\n");
 116 #endif
 117     CRYPTO_THREAD_lock_free(init_lock);
 118     init_lock = NULL;
 119
 120     CRYPTO_THREAD_cleanup_local(&key);
 121     return 0;
 122 }
 123
 124 static CRYPTO_ONCE load_crypto_nodelete = CRYPTO_ONCE_STATIC_INIT;
 125 DEFINE_RUN_ONCE_STATIC(ossl_init_load_crypto_nodelete)
 126 {
 127 #ifdef OPENSSL_INIT_DEBUG
 128     fprintf(stderr, "OPENSSL_INIT: ossl_init_load_crypto_nodelete()\n");
 129 #endif
 130 #if !defined(OPENSSL_NO_DSO) && !defined(OPENSSL_USE_NODELETE)
 131 # ifdef DSO_WIN32
 132     {
 133         HMODULE handle = NULL;
 134         BOOL ret;
 135
 136         /* We don't use the DSO route for WIN32 because there is a better way */
 137         ret = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
 138                                 | GET_MODULE_HANDLE_EX_FLAG_PIN,
 139                                 (void *)&base_inited, &handle);
 140
 141 #  ifdef OPENSSL_INIT_DEBUG
 142         fprintf(stderr, "OPENSSL_INIT: obtained DSO reference? %s\n",
 143                 (ret == TRUE ? "No!" : "Yes."));
 144 #  endif
 145         return (ret == TRUE) ? 1 : 0;
 146     }
 147 # else
 148     /*
 149      * Deliberately leak a reference to ourselves. This will force the library
 150      * to remain loaded until the atexit() handler is run at process exit.
 151      */
 152     {
 153         DSO *dso;
 154         void *err;
 155
 156         if (!err_shelve_state(&err))
 157             return 0;
 158
 159         dso = DSO_dsobyaddr(&base_inited, DSO_FLAG_NO_UNLOAD_ON_FREE);
 160 #  ifdef OPENSSL_INIT_DEBUG
 161         fprintf(stderr, "OPENSSL_INIT: obtained DSO reference? %s\n",
 162                 (dso == NULL ? "No!" : "Yes."));
 163         /*
 164          * In case of No!, it is uncertain our exit()-handlers can still be
 165          * called. After dlclose() the whole library might have been unloaded
 166          * already.
 167          */
 168 #  endif
 169         DSO_free(dso);
 170         err_unshelve_state(err);
 171     }
 172 # endif
 173 #endif
 174
 175     return 1;
 176 }
 177
 178 static CRYPTO_ONCE load_crypto_strings = CRYPTO_ONCE_STATIC_INIT;
 179 static int load_crypto_strings_inited = 0;
 180 DEFINE_RUN_ONCE_STATIC(ossl_init_load_crypto_strings)
 181 {
 182     int ret = 1;
 183     /*
 184      * OPENSSL_NO_AUTOERRINIT is provided here to prevent at compile time
 185      * pulling in all the error strings during static linking
 186      */
 187 #if !defined(OPENSSL_NO_ERR) && !defined(OPENSSL_NO_AUTOERRINIT)
 188 # ifdef OPENSSL_INIT_DEBUG
 189     fprintf(stderr, "OPENSSL_INIT: ossl_init_load_crypto_strings: "
 190                     "err_load_crypto_strings_int()\n");
 191 # endif
 192     ret = err_load_crypto_strings_int();
 193     load_crypto_strings_inited = 1;
 194 #endif
 195     return ret;
 196 }
 197
 198 DEFINE_RUN_ONCE_STATIC_ALT(ossl_init_no_load_crypto_strings,
 199                            ossl_init_load_crypto_strings)
 200 {
 201     /* Do nothing in this case */
 202     return 1;
 203 }
 204
 205 static CRYPTO_ONCE add_all_ciphers = CRYPTO_ONCE_STATIC_INIT;
 206 DEFINE_RUN_ONCE_STATIC(ossl_init_add_all_ciphers)
 207 {
 208     /*
 209      * OPENSSL_NO_AUTOALGINIT is provided here to prevent at compile time
 210      * pulling in all the ciphers during static linking
 211      */
 212 #ifndef OPENSSL_NO_AUTOALGINIT
 213 # ifdef OPENSSL_INIT_DEBUG
 214     fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_ciphers: "
 215                     "openssl_add_all_ciphers_int()\n");
 216 # endif
 217     openssl_add_all_ciphers_int();
 218 #endif
 219     return 1;
 220 }
 221
 222 DEFINE_RUN_ONCE_STATIC_ALT(ossl_init_no_add_all_ciphers,
 223                            ossl_init_add_all_ciphers)
 224 {
 225     /* Do nothing */
 226     return 1;
 227 }
 228
 229 static CRYPTO_ONCE add_all_digests = CRYPTO_ONCE_STATIC_INIT;
 230 DEFINE_RUN_ONCE_STATIC(ossl_init_add_all_digests)
 231 {
 232     /*
 233      * OPENSSL_NO_AUTOALGINIT is provided here to prevent at compile time
 234      * pulling in all the ciphers during static linking
 235      */
 236 #ifndef OPENSSL_NO_AUTOALGINIT
 237 # ifdef OPENSSL_INIT_DEBUG
 238     fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_digests: "
 239                     "openssl_add_all_digests()\n");
 240 # endif
 241     openssl_add_all_digests_int();
 242 #endif
 243     return 1;
 244 }
 245
 246 DEFINE_RUN_ONCE_STATIC_ALT(ossl_init_no_add_all_digests,
 247                            ossl_init_add_all_digests)
 248 {
 249     /* Do nothing */
 250     return 1;
 251 }
 252
 253 static CRYPTO_ONCE add_all_macs = CRYPTO_ONCE_STATIC_INIT;
 254 DEFINE_RUN_ONCE_STATIC(ossl_init_add_all_macs)
 255 {
 256     /*
 257      * OPENSSL_NO_AUTOALGINIT is provided here to prevent at compile time
 258      * pulling in all the macs during static linking
 259      */
 260 #ifndef OPENSSL_NO_AUTOALGINIT
 261 # ifdef OPENSSL_INIT_DEBUG
 262     fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_macs: "
 263                     "openssl_add_all_macs_int()\n");
 264 # endif
 265     openssl_add_all_macs_int();
 266 #endif
 267     return 1;
 268 }
 269
 270 DEFINE_RUN_ONCE_STATIC_ALT(ossl_init_no_add_all_macs, ossl_init_add_all_macs)
 271 {
 272     /* Do nothing */
 273     return 1;
 274 }
 275
 276 static CRYPTO_ONCE config = CRYPTO_ONCE_STATIC_INIT;
 277 static int config_inited = 0;
 278 static const char *appname;
 279 DEFINE_RUN_ONCE_STATIC(ossl_init_config)
 280 {
 281 #ifdef OPENSSL_INIT_DEBUG
 282     fprintf(stderr,
 283             "OPENSSL_INIT: ossl_init_config: openssl_config(%s)\n",
 284             appname == NULL ? "NULL" : appname);
 285 #endif
 286     openssl_config_int(appname);
 287     config_inited = 1;
 288     return 1;
 289 }
 290 DEFINE_RUN_ONCE_STATIC_ALT(ossl_init_no_config, ossl_init_config)
 291 {
 292 #ifdef OPENSSL_INIT_DEBUG
 293     fprintf(stderr,
 294             "OPENSSL_INIT: ossl_init_config: openssl_no_config_int()\n");
 295 #endif
 296     openssl_no_config_int();
 297     config_inited = 1;
 298     return 1;
 299 }
 300
 301 static CRYPTO_ONCE async = CRYPTO_ONCE_STATIC_INIT;
 302 static int async_inited = 0;
 303 DEFINE_RUN_ONCE_STATIC(ossl_init_async)
 304 {
 305 #ifdef OPENSSL_INIT_DEBUG
 306     fprintf(stderr, "OPENSSL_INIT: ossl_init_async: async_init()\n");
 307 #endif
 308     if (!async_init())
 309         return 0;
 310     async_inited = 1;
 311     return 1;
 312 }
 313
 314 #ifndef OPENSSL_NO_ENGINE
 315 static CRYPTO_ONCE engine_openssl = CRYPTO_ONCE_STATIC_INIT;
 316 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_openssl)
 317 {
 318 # ifdef OPENSSL_INIT_DEBUG
 319     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_openssl: "
 320                     "engine_load_openssl_int()\n");
 321 # endif
 322     engine_load_openssl_int();
 323     return 1;
 324 }
 325 # ifndef OPENSSL_NO_DEVCRYPTOENG
 326 static CRYPTO_ONCE engine_devcrypto = CRYPTO_ONCE_STATIC_INIT;
 327 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_devcrypto)
 328 {
 329 #  ifdef OPENSSL_INIT_DEBUG
 330     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_devcrypto: "
 331                     "engine_load_devcrypto_int()\n");
 332 #  endif
 333     engine_load_devcrypto_int();
 334     return 1;
 335 }
 336 # endif
 337
 338 # ifndef OPENSSL_NO_RDRAND
 339 static CRYPTO_ONCE engine_rdrand = CRYPTO_ONCE_STATIC_INIT;
 340 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_rdrand)
 341 {
 342 #  ifdef OPENSSL_INIT_DEBUG
 343     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_rdrand: "
 344                     "engine_load_rdrand_int()\n");
 345 #  endif
 346     engine_load_rdrand_int();
 347     return 1;
 348 }
 349 # endif
 350 static CRYPTO_ONCE engine_dynamic = CRYPTO_ONCE_STATIC_INIT;
 351 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_dynamic)
 352 {
 353 # ifdef OPENSSL_INIT_DEBUG
 354     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_dynamic: "
 355                     "engine_load_dynamic_int()\n");
 356 # endif
 357     engine_load_dynamic_int();
 358     return 1;
 359 }
 360 # ifndef OPENSSL_NO_STATIC_ENGINE
 361 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
 362 static CRYPTO_ONCE engine_padlock = CRYPTO_ONCE_STATIC_INIT;
 363 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_padlock)
 364 {
 365 #   ifdef OPENSSL_INIT_DEBUG
 366     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_padlock: "
 367                     "engine_load_padlock_int()\n");
 368 #   endif
 369     engine_load_padlock_int();
 370     return 1;
 371 }
 372 #  endif
 373 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
 374 static CRYPTO_ONCE engine_capi = CRYPTO_ONCE_STATIC_INIT;
 375 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_capi)
 376 {
 377 #   ifdef OPENSSL_INIT_DEBUG
 378     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_capi: "
 379                     "engine_load_capi_int()\n");
 380 #   endif
 381     engine_load_capi_int();
 382     return 1;
 383 }
 384 #  endif
 385 #  if !defined(OPENSSL_NO_AFALGENG)
 386 static CRYPTO_ONCE engine_afalg = CRYPTO_ONCE_STATIC_INIT;
 387 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_afalg)
 388 {
 389 #   ifdef OPENSSL_INIT_DEBUG
 390     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_afalg: "
 391                     "engine_load_afalg_int()\n");
 392 #   endif
 393     engine_load_afalg_int();
 394     return 1;
 395 }
 396 #  endif
 397 # endif
 398 #endif
 399
 400 #ifndef OPENSSL_NO_COMP
 401 static CRYPTO_ONCE zlib = CRYPTO_ONCE_STATIC_INIT;
 402
 403 static int zlib_inited = 0;
 404 DEFINE_RUN_ONCE_STATIC(ossl_init_zlib)
 405 {
 406     /* Do nothing - we need to know about this for the later cleanup */
 407     zlib_inited = 1;
 408     return 1;
 409 }
 410 #endif
 411
 412 static void ossl_init_thread_stop(struct thread_local_inits_st *locals)
 413 {
 414     /* Can't do much about this */
 415     if (locals == NULL)
 416         return;
 417
 418     if (locals->async) {
 419 #ifdef OPENSSL_INIT_DEBUG
 420         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "
 421                         "async_delete_thread_state()\n");
 422 #endif
 423         async_delete_thread_state();
 424     }
 425
 426     if (locals->err_state) {
 427 #ifdef OPENSSL_INIT_DEBUG
 428         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "
 429                         "err_delete_thread_state()\n");
 430 #endif
 431         err_delete_thread_state();
 432     }
 433
 434     if (locals->rand) {
 435 #ifdef OPENSSL_INIT_DEBUG
 436         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "
 437                         "drbg_delete_thread_state()\n");
 438 #endif
 439         drbg_delete_thread_state();
 440     }
 441
 442     OPENSSL_free(locals);
 443 }
 444
 445 void OPENSSL_thread_stop(void)
 446 {
 447     if (destructor_key.sane != -1)
 448         ossl_init_thread_stop(ossl_init_get_thread_local(0));
 449 }
 450
 451 int ossl_init_thread_start(uint64_t opts)
 452 {
 453     struct thread_local_inits_st *locals;
 454
 455     if (!OPENSSL_init_crypto(0, NULL))
 456         return 0;
 457
 458     locals = ossl_init_get_thread_local(1);
 459
 460     if (locals == NULL)
 461         return 0;
 462
 463     if (opts & OPENSSL_INIT_THREAD_ASYNC) {
 464 #ifdef OPENSSL_INIT_DEBUG
 465         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
 466                         "marking thread for async\n");
 467 #endif
 468         locals->async = 1;
 469     }
 470
 471     if (opts & OPENSSL_INIT_THREAD_ERR_STATE) {
 472 #ifdef OPENSSL_INIT_DEBUG
 473         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
 474                         "marking thread for err_state\n");
 475 #endif
 476         locals->err_state = 1;
 477     }
 478
 479     if (opts & OPENSSL_INIT_THREAD_RAND) {
 480 #ifdef OPENSSL_INIT_DEBUG
 481         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
 482                         "marking thread for rand\n");
 483 #endif
 484         locals->rand = 1;
 485     }
 486
 487     return 1;
 488 }
 489
 490 void OPENSSL_cleanup(void)
 491 {
 492     OPENSSL_INIT_STOP *currhandler, *lasthandler;
 493     CRYPTO_THREAD_LOCAL key;
 494
 495     /* If we've not been inited then no need to deinit */
 496     if (!base_inited)
 497         return;
 498
 499     /* Might be explicitly called and also by atexit */
 500     if (stopped)
 501         return;
 502     stopped = 1;
 503
 504     /*
 505      * Thread stop may not get automatically called by the thread library for
 506      * the very last thread in some situations, so call it directly.
 507      */
 508     ossl_init_thread_stop(ossl_init_get_thread_local(0));
 509
 510     currhandler = stop_handlers;
 511     while (currhandler != NULL) {
 512         currhandler->handler();
 513         lasthandler = currhandler;
 514         currhandler = currhandler->next;
 515         OPENSSL_free(lasthandler);
 516     }
 517     stop_handlers = NULL;
 518
 519     CRYPTO_THREAD_lock_free(init_lock);
 520     init_lock = NULL;
 521
 522     /*
 523      * We assume we are single-threaded for this function, i.e. no race
 524      * conditions for the various "*_inited" vars below.
 525      */
 526
 527 #ifndef OPENSSL_NO_COMP
 528     if (zlib_inited) {
 529 #ifdef OPENSSL_INIT_DEBUG
 530         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 531                         "comp_zlib_cleanup_int()\n");
 532 #endif
 533         comp_zlib_cleanup_int();
 534     }
 535 #endif
 536
 537     if (async_inited) {
 538 # ifdef OPENSSL_INIT_DEBUG
 539         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 540                         "async_deinit()\n");
 541 # endif
 542         async_deinit();
 543     }
 544
 545     if (load_crypto_strings_inited) {
 546 #ifdef OPENSSL_INIT_DEBUG
 547         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 548                         "err_free_strings_int()\n");
 549 #endif
 550         err_free_strings_int();
 551     }
 552
 553     key = destructor_key.value;
 554     destructor_key.sane = -1;
 555     CRYPTO_THREAD_cleanup_local(&key);
 556
 557 #ifdef OPENSSL_INIT_DEBUG
 558     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 559                     "rand_cleanup_int()\n");
 560     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 561                     "conf_modules_free_int()\n");
 562 #ifndef OPENSSL_NO_ENGINE
 563     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 564                     "engine_cleanup_int()\n");
 565 #endif
 566     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 567                     "crypto_cleanup_all_ex_data_int()\n");
 568     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 569                     "bio_sock_cleanup_int()\n");
 570     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 571                     "bio_cleanup()\n");
 572     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 573                     "evp_cleanup_int()\n");
 574     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 575                     "obj_cleanup_int()\n");
 576     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 577                     "err_cleanup()\n");
 578 #endif
 579     /*
 580      * Note that cleanup order is important:
 581      * - rand_cleanup_int could call an ENGINE's RAND cleanup function so
 582      * must be called before engine_cleanup_int()
 583      * - ENGINEs use CRYPTO_EX_DATA and therefore, must be cleaned up
 584      * before the ex data handlers are wiped in CRYPTO_cleanup_all_ex_data().
 585      * - conf_modules_free_int() can end up in ENGINE code so must be called
 586      * before engine_cleanup_int()
 587      * - ENGINEs and additional EVP algorithms might use added OIDs names so
 588      * obj_cleanup_int() must be called last
 589      */
 590     rand_cleanup_int();
 591     rand_drbg_cleanup_int();
 592     conf_modules_free_int();
 593 #ifndef OPENSSL_NO_ENGINE
 594     engine_cleanup_int();
 595 #endif
 596     ossl_store_cleanup_int();
 597     crypto_cleanup_all_ex_data_int();
 598     bio_cleanup();
 599     evp_cleanup_int();
 600     obj_cleanup_int();
 601     err_cleanup();
 602
 603     CRYPTO_secure_malloc_done();
 604
 605     base_inited = 0;
 606 }
 607
 608 /*
 609  * If this function is called with a non NULL settings value then it must be
 610  * called prior to any threads making calls to any OpenSSL functions,
 611  * i.e. passing a non-null settings value is assumed to be single-threaded.
 612  */
 613 int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
 614 {
 615     if (stopped) {
 616         if (!(opts & OPENSSL_INIT_BASE_ONLY))
 617             CRYPTOerr(CRYPTO_F_OPENSSL_INIT_CRYPTO, ERR_R_INIT_FAIL);
 618         return 0;
 619     }
 620
 621     if (!RUN_ONCE(&base, ossl_init_base))
 622         return 0;
 623
 624     if (!(opts & OPENSSL_INIT_BASE_ONLY)
 625             && !RUN_ONCE(&load_crypto_nodelete,
 626                          ossl_init_load_crypto_nodelete))
 627         return 0;
 628
 629     if ((opts & OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS)
 630             && !RUN_ONCE_ALT(&load_crypto_strings,
 631                              ossl_init_no_load_crypto_strings,
 632                              ossl_init_load_crypto_strings))
 633         return 0;
 634
 635     if ((opts & OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
 636             && !RUN_ONCE(&load_crypto_strings, ossl_init_load_crypto_strings))
 637         return 0;
 638
 639     if ((opts & OPENSSL_INIT_NO_ADD_ALL_CIPHERS)
 640             && !RUN_ONCE_ALT(&add_all_ciphers, ossl_init_no_add_all_ciphers,
 641                              ossl_init_add_all_ciphers))
 642         return 0;
 643
 644     if ((opts & OPENSSL_INIT_ADD_ALL_CIPHERS)
 645             && !RUN_ONCE(&add_all_ciphers, ossl_init_add_all_ciphers))
 646         return 0;
 647
 648     if ((opts & OPENSSL_INIT_NO_ADD_ALL_DIGESTS)
 649             && !RUN_ONCE_ALT(&add_all_digests, ossl_init_no_add_all_digests,
 650                              ossl_init_add_all_digests))
 651         return 0;
 652
 653     if ((opts & OPENSSL_INIT_ADD_ALL_DIGESTS)
 654             && !RUN_ONCE(&add_all_digests, ossl_init_add_all_digests))
 655         return 0;
 656
 657     if ((opts & OPENSSL_INIT_NO_ADD_ALL_MACS)
 658             && !RUN_ONCE_ALT(&add_all_macs, ossl_init_no_add_all_macs,
 659                              ossl_init_add_all_macs))
 660         return 0;
 661
 662     if ((opts & OPENSSL_INIT_ADD_ALL_MACS)
 663             && !RUN_ONCE(&add_all_macs, ossl_init_add_all_macs))
 664         return 0;
 665
 666     if ((opts & OPENSSL_INIT_ATFORK)
 667             && !openssl_init_fork_handlers())
 668         return 0;
 669
 670     if ((opts & OPENSSL_INIT_NO_LOAD_CONFIG)
 671             && !RUN_ONCE_ALT(&config, ossl_init_no_config, ossl_init_config))
 672         return 0;
 673
 674     if (opts & OPENSSL_INIT_LOAD_CONFIG) {
 675         int ret;
 676         CRYPTO_THREAD_write_lock(init_lock);
 677         appname = (settings == NULL) ? NULL : settings->appname;
 678         ret = RUN_ONCE(&config, ossl_init_config);
 679         CRYPTO_THREAD_unlock(init_lock);
 680         if (!ret)
 681             return 0;
 682     }
 683
 684     if ((opts & OPENSSL_INIT_ASYNC)
 685             && !RUN_ONCE(&async, ossl_init_async))
 686         return 0;
 687
 688 #ifndef OPENSSL_NO_ENGINE
 689     if ((opts & OPENSSL_INIT_ENGINE_OPENSSL)
 690             && !RUN_ONCE(&engine_openssl, ossl_init_engine_openssl))
 691         return 0;
 692 # if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_DEVCRYPTOENG)
 693     if ((opts & OPENSSL_INIT_ENGINE_CRYPTODEV)
 694             && !RUN_ONCE(&engine_devcrypto, ossl_init_engine_devcrypto))
 695         return 0;
 696 # endif
 697 # ifndef OPENSSL_NO_RDRAND
 698     if ((opts & OPENSSL_INIT_ENGINE_RDRAND)
 699             && !RUN_ONCE(&engine_rdrand, ossl_init_engine_rdrand))
 700         return 0;
 701 # endif
 702     if ((opts & OPENSSL_INIT_ENGINE_DYNAMIC)
 703             && !RUN_ONCE(&engine_dynamic, ossl_init_engine_dynamic))
 704         return 0;
 705 # ifndef OPENSSL_NO_STATIC_ENGINE
 706 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
 707     if ((opts & OPENSSL_INIT_ENGINE_PADLOCK)
 708             && !RUN_ONCE(&engine_padlock, ossl_init_engine_padlock))
 709         return 0;
 710 #  endif
 711 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
 712     if ((opts & OPENSSL_INIT_ENGINE_CAPI)
 713             && !RUN_ONCE(&engine_capi, ossl_init_engine_capi))
 714         return 0;
 715 #  endif
 716 #  if !defined(OPENSSL_NO_AFALGENG)
 717     if ((opts & OPENSSL_INIT_ENGINE_AFALG)
 718             && !RUN_ONCE(&engine_afalg, ossl_init_engine_afalg))
 719         return 0;
 720 #  endif
 721 # endif
 722     if (opts & (OPENSSL_INIT_ENGINE_ALL_BUILTIN
 723                 | OPENSSL_INIT_ENGINE_OPENSSL
 724                 | OPENSSL_INIT_ENGINE_AFALG)) {
 725         ENGINE_register_all_complete();
 726     }
 727 #endif
 728
 729 #ifndef OPENSSL_NO_COMP
 730     if ((opts & OPENSSL_INIT_ZLIB)
 731             && !RUN_ONCE(&zlib, ossl_init_zlib))
 732         return 0;
 733 #endif
 734
 735     return 1;
 736 }
 737
 738 int OPENSSL_atexit(void (*handler)(void))
 739 {
 740     OPENSSL_INIT_STOP *newhand;
 741
 742 #if !defined(OPENSSL_NO_DSO) && !defined(OPENSSL_USE_NODELETE)
 743     {
 744         union {
 745             void *sym;
 746             void (*func)(void);
 747         } handlersym;
 748
 749         handlersym.func = handler;
 750 # ifdef DSO_WIN32
 751         {
 752             HMODULE handle = NULL;
 753             BOOL ret;
 754
 755             /*
 756              * We don't use the DSO route for WIN32 because there is a better
 757              * way
 758              */
 759             ret = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
 760                                     | GET_MODULE_HANDLE_EX_FLAG_PIN,
 761                                     handlersym.sym, &handle);
 762
 763             if (!ret)
 764                 return 0;
 765         }
 766 # else
 767         /*
 768          * Deliberately leak a reference to the handler. This will force the
 769          * library/code containing the handler to remain loaded until we run the
 770          * atexit handler. If -znodelete has been used then this is
 771          * unnecessary.
 772          */
 773         {
 774             DSO *dso = NULL;
 775
 776             ERR_set_mark();
 777             dso = DSO_dsobyaddr(handlersym.sym, DSO_FLAG_NO_UNLOAD_ON_FREE);
 778 #  ifdef OPENSSL_INIT_DEBUG
 779             fprintf(stderr,
 780                     "OPENSSL_INIT: OPENSSL_atexit: obtained DSO reference? %s\n",
 781                     (dso == NULL ? "No!" : "Yes."));
 782             /* See same code above in ossl_init_base() for an explanation. */
 783 #  endif
 784             DSO_free(dso);
 785             ERR_pop_to_mark();
 786         }
 787 # endif
 788     }
 789 #endif
 790
 791     if ((newhand = OPENSSL_malloc(sizeof(*newhand))) == NULL) {
 792         CRYPTOerr(CRYPTO_F_OPENSSL_ATEXIT, ERR_R_MALLOC_FAILURE);
 793         return 0;
 794     }
 795
 796     newhand->handler = handler;
 797     newhand->next = stop_handlers;
 798     stop_handlers = newhand;
 799
 800     return 1;
 801 }
 802
 803 #ifdef OPENSSL_SYS_UNIX
 804 /*
 805  * The following three functions are for OpenSSL developers.  This is
 806  * where we set/reset state across fork (called via pthread_atfork when
 807  * it exists, or manually by the application when it doesn't).
 808  *
 809  * WARNING!  If you put code in either OPENSSL_fork_parent or
 810  * OPENSSL_fork_child, you MUST MAKE SURE that they are async-signal-
 811  * safe.  See this link, for example:
 812  *      http://man7.org/linux/man-pages/man7/signal-safety.7.html
 813  */
 814
 815 void OPENSSL_fork_prepare(void)
 816 {
 817 }
 818
 819 void OPENSSL_fork_parent(void)
 820 {
 821 }
 822
 823 void OPENSSL_fork_child(void)
 824 {
 825     rand_fork();
 826 }
 827 #endif