providers/fips/fipsprov.c

   1 /*
   2  * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <string.h>
  11 #include <stdio.h>
  12 #include <openssl/core.h>
  13 #include <openssl/core_numbers.h>
  14 #include <openssl/core_names.h>
  15 #include <openssl/params.h>
  16 #include <openssl/err.h>
  17 #include <openssl/evp.h>
  18
  19 /* TODO(3.0): Needed for dummy_evp_call(). To be removed */
  20 #include <openssl/sha.h>
  21 #include <openssl/rand_drbg.h>
  22 #include <openssl/ec.h>
  23 #include <openssl/fips_names.h>
  24
  25 #include "internal/cryptlib.h"
  26 #include "internal/property.h"
  27 #include "internal/evp_int.h"
  28 #include "internal/provider_algs.h"
  29 #include "internal/provider_ctx.h"
  30 #include "internal/providercommon.h"
  31 #include "selftest.h"
  32
  33 extern OSSL_core_thread_start_fn *c_thread_start;
  34
  35 /*
  36  * TODO(3.0): Should these be stored in the provider side provctx? Could they
  37  * ever be different from one init to the next? Unfortunately we can't do this
  38  * at the moment because c_put_error/c_add_error_vdata do not provide
  39  * us with the OPENSSL_CTX as a parameter.
  40  */
  41
  42 static SELF_TEST_POST_PARAMS selftest_params;
  43
  44 /* Functions provided by the core */
  45 static OSSL_core_gettable_params_fn *c_gettable_params;
  46 static OSSL_core_get_params_fn *c_get_params;
  47 OSSL_core_thread_start_fn *c_thread_start;
  48 static OSSL_core_new_error_fn *c_new_error;
  49 static OSSL_core_set_error_debug_fn *c_set_error_debug;
  50 static OSSL_core_vset_error_fn *c_vset_error;
  51 static OSSL_CRYPTO_malloc_fn *c_CRYPTO_malloc;
  52 static OSSL_CRYPTO_zalloc_fn *c_CRYPTO_zalloc;
  53 static OSSL_CRYPTO_free_fn *c_CRYPTO_free;
  54 static OSSL_CRYPTO_clear_free_fn *c_CRYPTO_clear_free;
  55 static OSSL_CRYPTO_realloc_fn *c_CRYPTO_realloc;
  56 static OSSL_CRYPTO_clear_realloc_fn *c_CRYPTO_clear_realloc;
  57 static OSSL_CRYPTO_secure_malloc_fn *c_CRYPTO_secure_malloc;
  58 static OSSL_CRYPTO_secure_zalloc_fn *c_CRYPTO_secure_zalloc;
  59 static OSSL_CRYPTO_secure_free_fn *c_CRYPTO_secure_free;
  60 static OSSL_CRYPTO_secure_clear_free_fn *c_CRYPTO_secure_clear_free;
  61 static OSSL_CRYPTO_secure_allocated_fn *c_CRYPTO_secure_allocated;
  62
  63 typedef struct fips_global_st {
  64     const OSSL_PROVIDER *prov;
  65 } FIPS_GLOBAL;
  66
  67 static void *fips_prov_ossl_ctx_new(OPENSSL_CTX *libctx)
  68 {
  69     FIPS_GLOBAL *fgbl = OPENSSL_zalloc(sizeof(*fgbl));
  70
  71     return fgbl;
  72 }
  73
  74 static void fips_prov_ossl_ctx_free(void *fgbl)
  75 {
  76     OPENSSL_free(fgbl);
  77 }
  78
  79 static const OPENSSL_CTX_METHOD fips_prov_ossl_ctx_method = {
  80     fips_prov_ossl_ctx_new,
  81     fips_prov_ossl_ctx_free,
  82 };
  83
  84
  85 /* Parameters we provide to the core */
  86 static const OSSL_PARAM fips_param_types[] = {
  87     OSSL_PARAM_DEFN(OSSL_PROV_PARAM_NAME, OSSL_PARAM_UTF8_PTR, NULL, 0),
  88     OSSL_PARAM_DEFN(OSSL_PROV_PARAM_VERSION, OSSL_PARAM_UTF8_PTR, NULL, 0),
  89     OSSL_PARAM_DEFN(OSSL_PROV_PARAM_BUILDINFO, OSSL_PARAM_UTF8_PTR, NULL, 0),
  90     OSSL_PARAM_END
  91 };
  92
  93 /*
  94  * Parameters to retrieve from the core provider - required for self testing.
  95  * NOTE: inside core_get_params() these will be loaded from config items
  96  * stored inside prov->parameters (except for OSSL_PROV_PARAM_MODULE_FILENAME).
  97  */
  98 static OSSL_PARAM core_params[] =
  99 {
 100     OSSL_PARAM_utf8_ptr(OSSL_PROV_PARAM_MODULE_FILENAME,
 101                         selftest_params.module_filename,
 102                         sizeof(selftest_params.module_filename)),
 103     OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_MODULE_MAC,
 104                         selftest_params.module_checksum_data,
 105                         sizeof(selftest_params.module_checksum_data)),
 106     OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_MAC,
 107                         selftest_params.indicator_checksum_data,
 108                         sizeof(selftest_params.indicator_checksum_data)),
 109     OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_STATUS,
 110                         selftest_params.indicator_data,
 111                         sizeof(selftest_params.indicator_data)),
 112     OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_VERSION,
 113                         selftest_params.indicator_version,
 114                         sizeof(selftest_params.indicator_version)),
 115     OSSL_PARAM_END
 116 };
 117
 118 /* TODO(3.0): To be removed */
 119 static int dummy_evp_call(void *provctx)
 120 {
 121     OPENSSL_CTX *libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
 122     EVP_MD_CTX *ctx = EVP_MD_CTX_new();
 123     EVP_MD *sha256 = EVP_MD_fetch(libctx, "SHA256", NULL);
 124     char msg[] = "Hello World!";
 125     const unsigned char exptd[] = {
 126         0x7f, 0x83, 0xb1, 0x65, 0x7f, 0xf1, 0xfc, 0x53, 0xb9, 0x2d, 0xc1, 0x81,
 127         0x48, 0xa1, 0xd6, 0x5d, 0xfc, 0x2d, 0x4b, 0x1f, 0xa3, 0xd6, 0x77, 0x28,
 128         0x4a, 0xdd, 0xd2, 0x00, 0x12, 0x6d, 0x90, 0x69
 129     };
 130     unsigned int dgstlen = 0;
 131     unsigned char dgst[SHA256_DIGEST_LENGTH];
 132     int ret = 0;
 133     BN_CTX *bnctx = NULL;
 134     BIGNUM *a = NULL, *b = NULL;
 135     unsigned char randbuf[128];
 136     RAND_DRBG *drbg = OPENSSL_CTX_get0_public_drbg(libctx);
 137 #ifndef OPENSSL_NO_EC
 138     EC_KEY *key = NULL;
 139 #endif
 140
 141     if (ctx == NULL || sha256 == NULL || drbg == NULL)
 142         goto err;
 143
 144     if (!EVP_DigestInit_ex(ctx, sha256, NULL))
 145         goto err;
 146     if (!EVP_DigestUpdate(ctx, msg, sizeof(msg) - 1))
 147         goto err;
 148     if (!EVP_DigestFinal(ctx, dgst, &dgstlen))
 149         goto err;
 150     if (dgstlen != sizeof(exptd) || memcmp(dgst, exptd, sizeof(exptd)) != 0)
 151         goto err;
 152
 153     bnctx = BN_CTX_new_ex(libctx);
 154     if (bnctx == NULL)
 155         goto err;
 156     BN_CTX_start(bnctx);
 157     a = BN_CTX_get(bnctx);
 158     b = BN_CTX_get(bnctx);
 159     if (b == NULL)
 160         goto err;
 161     BN_zero(a);
 162     if (!BN_one(b)
 163         || !BN_add(a, a, b)
 164         || BN_cmp(a, b) != 0)
 165         goto err;
 166
 167     if (RAND_DRBG_bytes(drbg, randbuf, sizeof(randbuf)) <= 0)
 168         goto err;
 169
 170     if (!BN_rand_ex(a, 256, BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY, bnctx))
 171         goto err;
 172
 173 #ifndef OPENSSL_NO_EC
 174     /* Do some dummy EC calls */
 175     key = EC_KEY_new_by_curve_name_ex(libctx, NID_X9_62_prime256v1);
 176     if (key == NULL)
 177         goto err;
 178
 179     if (!EC_KEY_generate_key(key))
 180         goto err;
 181 #endif
 182
 183     ret = 1;
 184  err:
 185     BN_CTX_end(bnctx);
 186     BN_CTX_free(bnctx);
 187
 188     EVP_MD_CTX_free(ctx);
 189     EVP_MD_meth_free(sha256);
 190
 191 #ifndef OPENSSL_NO_EC
 192     EC_KEY_free(key);
 193 #endif
 194     return ret;
 195 }
 196
 197 static const OSSL_PARAM *fips_gettable_params(const OSSL_PROVIDER *prov)
 198 {
 199     return fips_param_types;
 200 }
 201
 202 static int fips_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[])
 203 {
 204     OSSL_PARAM *p;
 205
 206     p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME);
 207     if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL FIPS Provider"))
 208         return 0;
 209     p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_VERSION);
 210     if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_VERSION_STR))
 211         return 0;
 212     p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_BUILDINFO);
 213     if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_FULL_VERSION_STR))
 214         return 0;
 215
 216     return 1;
 217 }
 218
 219 /* FIPS specific version of the function of the same name in provlib.c */
 220 const char *ossl_prov_util_nid_to_name(int nid)
 221 {
 222     /* We don't have OBJ_nid2n() in FIPS_MODE so we have an explicit list */
 223
 224     switch (nid) {
 225     /* Digests */
 226     case NID_sha1:
 227         return "SHA224";
 228     case NID_sha224:
 229         return "SHA224";
 230     case NID_sha256:
 231         return "SHA256";
 232     case NID_sha384:
 233         return "SHA384";
 234     case NID_sha512:
 235         return "SHA512";
 236     case NID_sha512_224:
 237         return "SHA512-224";
 238     case NID_sha512_256:
 239         return "SHA512-256";
 240     case NID_sha3_224:
 241         return "SHA3-224";
 242     case NID_sha3_256:
 243         return "SHA3-256";
 244     case NID_sha3_384:
 245         return "SHA3-384";
 246     case NID_sha3_512:
 247         return "SHA3-512";
 248
 249     /* Ciphers */
 250     case NID_aes_256_ecb:
 251         return "AES-256-ECB";
 252     case NID_aes_192_ecb:
 253         return "AES-192-ECB";
 254     case NID_aes_128_ecb:
 255         return "AES-128-ECB";
 256     case NID_aes_256_cbc:
 257         return "AES-256-CBC";
 258     case NID_aes_192_cbc:
 259         return "AES-192-CBC";
 260     case NID_aes_128_cbc:
 261         return "AES-128-CBC";
 262     case NID_aes_256_ctr:
 263         return "AES-256-CTR";
 264     case NID_aes_192_ctr:
 265         return "AES-192-CTR";
 266     case NID_aes_128_ctr:
 267         return "AES-128-CTR";
 268     /* TODO(3.0) Change these when we have aliases */
 269     case NID_aes_256_gcm:
 270         return "id-aes256-GCM";
 271     case NID_aes_192_gcm:
 272         return "id-aes192-GCM";
 273     case NID_aes_128_gcm:
 274         return "id-aes128-GCM";
 275     case NID_aes_256_ccm:
 276         return "id-aes256-CCM";
 277     case NID_aes_192_ccm:
 278         return "id-aes192-CCM";
 279     case NID_aes_128_ccm:
 280         return "id-aes128-CCM";
 281     default:
 282         break;
 283     }
 284
 285     return NULL;
 286 }
 287
 288 static const OSSL_ALGORITHM fips_digests[] = {
 289     { "SHA1", "fips=yes", sha1_functions },
 290     { "SHA224", "fips=yes", sha224_functions },
 291     { "SHA256", "fips=yes", sha256_functions },
 292     { "SHA384", "fips=yes", sha384_functions },
 293     { "SHA512", "fips=yes", sha512_functions },
 294     { "SHA512-224", "fips=yes", sha512_224_functions },
 295     { "SHA512-256", "fips=yes", sha512_256_functions },
 296     { "SHA3-224", "fips=yes", sha3_224_functions },
 297     { "SHA3-256", "fips=yes", sha3_256_functions },
 298     { "SHA3-384", "fips=yes", sha3_384_functions },
 299     { "SHA3-512", "fips=yes", sha3_512_functions },
 300     /*
 301      * KECCAK_KMAC128 and KECCAK_KMAC256 as hashes are mostly useful for
 302      * the KMAC128 and KMAC256.
 303      */
 304     { "KECCAK_KMAC128", "fips=yes", keccak_kmac_128_functions },
 305     { "KECCAK_KMAC256", "fips=yes", keccak_kmac_256_functions },
 306
 307     { NULL, NULL, NULL }
 308 };
 309
 310 static const OSSL_ALGORITHM fips_ciphers[] = {
 311     { "AES-256-ECB", "fips=yes", aes256ecb_functions },
 312     { "AES-192-ECB", "fips=yes", aes192ecb_functions },
 313     { "AES-128-ECB", "fips=yes", aes128ecb_functions },
 314     { "AES-256-CBC", "fips=yes", aes256cbc_functions },
 315     { "AES-192-CBC", "fips=yes", aes192cbc_functions },
 316     { "AES-128-CBC", "fips=yes", aes128cbc_functions },
 317     { "AES-256-CTR", "fips=yes", aes256ctr_functions },
 318     { "AES-192-CTR", "fips=yes", aes192ctr_functions },
 319     { "AES-128-CTR", "fips=yes", aes128ctr_functions },
 320     /* TODO(3.0) Add aliases for these ciphers */
 321     { "id-aes256-GCM", "fips=yes", aes256gcm_functions },
 322     { "id-aes192-GCM", "fips=yes", aes192gcm_functions },
 323     { "id-aes128-GCM", "fips=yes", aes128gcm_functions },
 324     { "id-aes256-CCM", "fips=yes", aes256ccm_functions },
 325     { "id-aes192-CCM", "fips=yes", aes192ccm_functions },
 326     { "id-aes128-CCM", "fips=yes", aes128ccm_functions },
 327     { NULL, NULL, NULL }
 328 };
 329
 330 static const OSSL_ALGORITHM fips_macs[] = {
 331     { "CMAC", "fips=yes", cmac_functions },
 332     { "GMAC", "fips=yes", gmac_functions },
 333     { "HMAC", "fips=yes", hmac_functions },
 334     { "KMAC128", "fips=yes", kmac128_functions },
 335     { "KMAC256", "fips=yes", kmac256_functions },
 336     { NULL, NULL, NULL }
 337 };
 338
 339 static const OSSL_ALGORITHM *fips_query(OSSL_PROVIDER *prov,
 340                                          int operation_id,
 341                                          int *no_cache)
 342 {
 343     *no_cache = 0;
 344     switch (operation_id) {
 345     case OSSL_OP_DIGEST:
 346         return fips_digests;
 347     case OSSL_OP_CIPHER:
 348         return fips_ciphers;
 349     case OSSL_OP_MAC:
 350         return fips_macs;
 351     }
 352     return NULL;
 353 }
 354
 355 /* Functions we provide to the core */
 356 static const OSSL_DISPATCH fips_dispatch_table[] = {
 357     /*
 358      * To release our resources we just need to free the OPENSSL_CTX so we just
 359      * use OPENSSL_CTX_free directly as our teardown function
 360      */
 361     { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))OPENSSL_CTX_free },
 362     { OSSL_FUNC_PROVIDER_GETTABLE_PARAMS, (void (*)(void))fips_gettable_params },
 363     { OSSL_FUNC_PROVIDER_GET_PARAMS, (void (*)(void))fips_get_params },
 364     { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query },
 365     { 0, NULL }
 366 };
 367
 368 /* Functions we provide to ourself */
 369 static const OSSL_DISPATCH intern_dispatch_table[] = {
 370     { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query },
 371     { 0, NULL }
 372 };
 373
 374
 375 int OSSL_provider_init(const OSSL_PROVIDER *provider,
 376                        const OSSL_DISPATCH *in,
 377                        const OSSL_DISPATCH **out,
 378                        void **provctx)
 379 {
 380     FIPS_GLOBAL *fgbl;
 381     OPENSSL_CTX *ctx;
 382
 383     for (; in->function_id != 0; in++) {
 384         switch (in->function_id) {
 385         case OSSL_FUNC_CORE_GETTABLE_PARAMS:
 386             c_gettable_params = OSSL_get_core_gettable_params(in);
 387             break;
 388         case OSSL_FUNC_CORE_GET_PARAMS:
 389             c_get_params = OSSL_get_core_get_params(in);
 390             break;
 391         case OSSL_FUNC_CORE_THREAD_START:
 392             c_thread_start = OSSL_get_core_thread_start(in);
 393             break;
 394         case OSSL_FUNC_CORE_NEW_ERROR:
 395             c_new_error = OSSL_get_core_new_error(in);
 396             break;
 397         case OSSL_FUNC_CORE_SET_ERROR_DEBUG:
 398             c_set_error_debug = OSSL_get_core_set_error_debug(in);
 399             break;
 400         case OSSL_FUNC_CORE_VSET_ERROR:
 401             c_vset_error = OSSL_get_core_vset_error(in);
 402             break;
 403         case OSSL_FUNC_CRYPTO_MALLOC:
 404             c_CRYPTO_malloc = OSSL_get_CRYPTO_malloc(in);
 405             break;
 406         case OSSL_FUNC_CRYPTO_ZALLOC:
 407             c_CRYPTO_zalloc = OSSL_get_CRYPTO_zalloc(in);
 408             break;
 409         case OSSL_FUNC_CRYPTO_FREE:
 410             c_CRYPTO_free = OSSL_get_CRYPTO_free(in);
 411             break;
 412         case OSSL_FUNC_CRYPTO_CLEAR_FREE:
 413             c_CRYPTO_clear_free = OSSL_get_CRYPTO_clear_free(in);
 414             break;
 415         case OSSL_FUNC_CRYPTO_REALLOC:
 416             c_CRYPTO_realloc = OSSL_get_CRYPTO_realloc(in);
 417             break;
 418         case OSSL_FUNC_CRYPTO_CLEAR_REALLOC:
 419             c_CRYPTO_clear_realloc = OSSL_get_CRYPTO_clear_realloc(in);
 420             break;
 421         case OSSL_FUNC_CRYPTO_SECURE_MALLOC:
 422             c_CRYPTO_secure_malloc = OSSL_get_CRYPTO_secure_malloc(in);
 423             break;
 424         case OSSL_FUNC_CRYPTO_SECURE_ZALLOC:
 425             c_CRYPTO_secure_zalloc = OSSL_get_CRYPTO_secure_zalloc(in);
 426             break;
 427         case OSSL_FUNC_CRYPTO_SECURE_FREE:
 428             c_CRYPTO_secure_free = OSSL_get_CRYPTO_secure_free(in);
 429             break;
 430         case OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE:
 431             c_CRYPTO_secure_clear_free = OSSL_get_CRYPTO_secure_clear_free(in);
 432             break;
 433         case OSSL_FUNC_CRYPTO_SECURE_ALLOCATED:
 434             c_CRYPTO_secure_allocated = OSSL_get_CRYPTO_secure_allocated(in);
 435             break;
 436         case OSSL_FUNC_BIO_NEW_FILE:
 437             selftest_params.bio_new_file_cb = OSSL_get_BIO_new_file(in);
 438             break;
 439         case OSSL_FUNC_BIO_NEW_MEMBUF:
 440             selftest_params.bio_new_buffer_cb = OSSL_get_BIO_new_membuf(in);
 441             break;
 442         case OSSL_FUNC_BIO_READ:
 443             selftest_params.bio_read_cb = OSSL_get_BIO_read(in);
 444             break;
 445         case OSSL_FUNC_BIO_FREE:
 446             selftest_params.bio_free_cb = OSSL_get_BIO_free(in);
 447             break;
 448         default:
 449             /* Just ignore anything we don't understand */
 450             break;
 451         }
 452     }
 453
 454     if (!c_get_params(provider, core_params))
 455         return 0;
 456
 457     /*  Create a context. */
 458     if ((ctx = OPENSSL_CTX_new()) == NULL)
 459         return 0;
 460     if ((fgbl = openssl_ctx_get_data(ctx, OPENSSL_CTX_FIPS_PROV_INDEX,
 461                                      &fips_prov_ossl_ctx_method)) == NULL) {
 462         OPENSSL_CTX_free(ctx);
 463         return 0;
 464     }
 465     fgbl->prov = provider;
 466     *out = fips_dispatch_table;
 467     *provctx = ctx;
 468
 469     /*
 470      * TODO(3.0): Remove me. This is just a dummy call to demonstrate making
 471      * EVP calls from within the FIPS module.
 472      */
 473     if (!dummy_evp_call(*provctx)) {
 474         OPENSSL_CTX_free(*provctx);
 475         *provctx = NULL;
 476         return 0;
 477     }
 478
 479     return 1;
 480 }
 481
 482 /*
 483  * The internal init function used when the FIPS module uses EVP to call
 484  * another algorithm also in the FIPS module. This is a recursive call that has
 485  * been made from within the FIPS module itself. To make this work, we populate
 486  * the provider context of this inner instance with the same library context
 487  * that was used in the EVP call that initiated this recursive call.
 488  */
 489 OSSL_provider_init_fn fips_intern_provider_init;
 490 int fips_intern_provider_init(const OSSL_PROVIDER *provider,
 491                               const OSSL_DISPATCH *in,
 492                               const OSSL_DISPATCH **out,
 493                               void **provctx)
 494 {
 495     OSSL_core_get_library_context_fn *c_get_libctx = NULL;
 496
 497     for (; in->function_id != 0; in++) {
 498         switch (in->function_id) {
 499         case OSSL_FUNC_CORE_GET_LIBRARY_CONTEXT:
 500             c_get_libctx = OSSL_get_core_get_library_context(in);
 501             break;
 502         default:
 503             break;
 504         }
 505     }
 506
 507     if (c_get_libctx == NULL)
 508         return 0;
 509
 510     *provctx = c_get_libctx(provider);
 511
 512     /*
 513      * Safety measure...  we should get the library context that was
 514      * created up in OSSL_provider_init().
 515      */
 516     if (*provctx == NULL)
 517         return 0;
 518
 519     *out = intern_dispatch_table;
 520     return 1;
 521 }
 522
 523 void ERR_new(void)
 524 {
 525     c_new_error(NULL);
 526 }
 527
 528 void ERR_set_debug(const char *file, int line, const char *func)
 529 {
 530     c_set_error_debug(NULL, file, line, func);
 531 }
 532
 533 void ERR_set_error(int lib, int reason, const char *fmt, ...)
 534 {
 535     va_list args;
 536
 537     va_start(args, fmt);
 538     c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args);
 539     va_end(args);
 540 }
 541
 542 void ERR_vset_error(int lib, int reason, const char *fmt, va_list args)
 543 {
 544     c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args);
 545 }
 546
 547 const OSSL_PROVIDER *FIPS_get_provider(OPENSSL_CTX *ctx)
 548 {
 549     FIPS_GLOBAL *fgbl = openssl_ctx_get_data(ctx, OPENSSL_CTX_FIPS_PROV_INDEX,
 550                                              &fips_prov_ossl_ctx_method);
 551
 552     if (fgbl == NULL)
 553         return NULL;
 554
 555     return fgbl->prov;
 556 }
 557
 558 void *CRYPTO_malloc(size_t num, const char *file, int line)
 559 {
 560     return c_CRYPTO_malloc(num, file, line);
 561 }
 562
 563 void *CRYPTO_zalloc(size_t num, const char *file, int line)
 564 {
 565     return c_CRYPTO_zalloc(num, file, line);
 566 }
 567
 568 void CRYPTO_free(void *ptr, const char *file, int line)
 569 {
 570     c_CRYPTO_free(ptr, file, line);
 571 }
 572
 573 void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line)
 574 {
 575     c_CRYPTO_clear_free(ptr, num, file, line);
 576 }
 577
 578 void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line)
 579 {
 580     return c_CRYPTO_realloc(addr, num, file, line);
 581 }
 582
 583 void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
 584                            const char *file, int line)
 585 {
 586     return c_CRYPTO_clear_realloc(addr, old_num, num, file, line);
 587 }
 588
 589 void *CRYPTO_secure_malloc(size_t num, const char *file, int line)
 590 {
 591     return c_CRYPTO_secure_malloc(num, file, line);
 592 }
 593
 594 void *CRYPTO_secure_zalloc(size_t num, const char *file, int line)
 595 {
 596     return c_CRYPTO_secure_zalloc(num, file, line);
 597 }
 598
 599 void CRYPTO_secure_free(void *ptr, const char *file, int line)
 600 {
 601     c_CRYPTO_secure_free(ptr, file, line);
 602 }
 603
 604 void CRYPTO_secure_clear_free(void *ptr, size_t num, const char *file, int line)
 605 {
 606     c_CRYPTO_secure_clear_free(ptr, num, file, line);
 607 }
 608
 609 int CRYPTO_secure_allocated(const void *ptr)
 610 {
 611     return c_CRYPTO_secure_allocated(ptr);
 612 }