2 * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
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 #include <openssl/kdf.h>
20 /* TODO(3.0): Needed for dummy_evp_call(). To be removed */
21 #include <openssl/sha.h>
22 #include <openssl/rand_drbg.h>
23 #include <openssl/ec.h>
24 #include <openssl/fips_names.h>
26 #include "internal/cryptlib.h"
27 #include "internal/property.h"
28 #include "internal/nelem.h"
29 #include "openssl/param_build.h"
30 #include "crypto/evp.h"
31 #include "prov/implementations.h"
32 #include "prov/provider_ctx.h"
33 #include "prov/providercommon.h"
34 #include "prov/provider_util.h"
35 #include "self_test.h"
38 * Forward declarations to ensure that interface functions are correctly
41 static OSSL_provider_teardown_fn fips_teardown;
42 static OSSL_provider_gettable_params_fn fips_gettable_params;
43 static OSSL_provider_get_params_fn fips_get_params;
44 static OSSL_provider_query_operation_fn fips_query;
46 #define ALGC(NAMES, FUNC, CHECK) { { NAMES, "provider=fips,fips=yes", FUNC }, CHECK }
47 #define ALG(NAMES, FUNC) ALGC(NAMES, FUNC, NULL)
49 extern OSSL_core_thread_start_fn *c_thread_start;
52 * TODO(3.0): Should these be stored in the provider side provctx? Could they
53 * ever be different from one init to the next? Unfortunately we can't do this
54 * at the moment because c_put_error/c_add_error_vdata do not provide
55 * us with the OPENSSL_CTX as a parameter.
58 static SELF_TEST_POST_PARAMS selftest_params;
60 /* Functions provided by the core */
61 static OSSL_core_gettable_params_fn *c_gettable_params;
62 static OSSL_core_get_params_fn *c_get_params;
63 OSSL_core_thread_start_fn *c_thread_start;
64 static OSSL_core_new_error_fn *c_new_error;
65 static OSSL_core_set_error_debug_fn *c_set_error_debug;
66 static OSSL_core_vset_error_fn *c_vset_error;
67 static OSSL_core_set_error_mark_fn *c_set_error_mark;
68 static OSSL_core_clear_last_error_mark_fn *c_clear_last_error_mark;
69 static OSSL_core_pop_error_to_mark_fn *c_pop_error_to_mark;
70 static OSSL_CRYPTO_malloc_fn *c_CRYPTO_malloc;
71 static OSSL_CRYPTO_zalloc_fn *c_CRYPTO_zalloc;
72 static OSSL_CRYPTO_free_fn *c_CRYPTO_free;
73 static OSSL_CRYPTO_clear_free_fn *c_CRYPTO_clear_free;
74 static OSSL_CRYPTO_realloc_fn *c_CRYPTO_realloc;
75 static OSSL_CRYPTO_clear_realloc_fn *c_CRYPTO_clear_realloc;
76 static OSSL_CRYPTO_secure_malloc_fn *c_CRYPTO_secure_malloc;
77 static OSSL_CRYPTO_secure_zalloc_fn *c_CRYPTO_secure_zalloc;
78 static OSSL_CRYPTO_secure_free_fn *c_CRYPTO_secure_free;
79 static OSSL_CRYPTO_secure_clear_free_fn *c_CRYPTO_secure_clear_free;
80 static OSSL_CRYPTO_secure_allocated_fn *c_CRYPTO_secure_allocated;
81 static OSSL_BIO_vsnprintf_fn *c_BIO_vsnprintf;
83 typedef struct fips_global_st {
84 const OSSL_PROVIDER *prov;
87 static void *fips_prov_ossl_ctx_new(OPENSSL_CTX *libctx)
89 FIPS_GLOBAL *fgbl = OPENSSL_zalloc(sizeof(*fgbl));
94 static void fips_prov_ossl_ctx_free(void *fgbl)
99 static const OPENSSL_CTX_METHOD fips_prov_ossl_ctx_method = {
100 fips_prov_ossl_ctx_new,
101 fips_prov_ossl_ctx_free,
105 /* Parameters we provide to the core */
106 static const OSSL_PARAM fips_param_types[] = {
107 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_NAME, OSSL_PARAM_UTF8_PTR, NULL, 0),
108 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_VERSION, OSSL_PARAM_UTF8_PTR, NULL, 0),
109 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_BUILDINFO, OSSL_PARAM_UTF8_PTR, NULL, 0),
114 * Parameters to retrieve from the core provider - required for self testing.
115 * NOTE: inside core_get_params() these will be loaded from config items
116 * stored inside prov->parameters (except for OSSL_PROV_PARAM_MODULE_FILENAME).
118 static OSSL_PARAM core_params[] =
120 OSSL_PARAM_utf8_ptr(OSSL_PROV_PARAM_MODULE_FILENAME,
121 selftest_params.module_filename,
122 sizeof(selftest_params.module_filename)),
123 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_MODULE_MAC,
124 selftest_params.module_checksum_data,
125 sizeof(selftest_params.module_checksum_data)),
126 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_MAC,
127 selftest_params.indicator_checksum_data,
128 sizeof(selftest_params.indicator_checksum_data)),
129 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_STATUS,
130 selftest_params.indicator_data,
131 sizeof(selftest_params.indicator_data)),
132 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_VERSION,
133 selftest_params.indicator_version,
134 sizeof(selftest_params.indicator_version)),
138 /* TODO(3.0): To be removed */
139 static int dummy_evp_call(OPENSSL_CTX *libctx)
141 EVP_MD_CTX *ctx = EVP_MD_CTX_new();
142 EVP_MD *sha256 = EVP_MD_fetch(libctx, "SHA256", NULL);
143 EVP_KDF *kdf = EVP_KDF_fetch(libctx, OSSL_KDF_NAME_PBKDF2, NULL);
144 unsigned char dgst[SHA256_DIGEST_LENGTH];
145 unsigned int dgstlen;
147 BN_CTX *bnctx = NULL;
148 BIGNUM *a = NULL, *b = NULL;
149 unsigned char randbuf[128];
150 RAND_DRBG *drbg = OPENSSL_CTX_get0_public_drbg(libctx);
151 #ifndef OPENSSL_NO_EC
155 static const char msg[] = "Hello World!";
156 static const unsigned char exptd[] = {
157 0x7f, 0x83, 0xb1, 0x65, 0x7f, 0xf1, 0xfc, 0x53, 0xb9, 0x2d, 0xc1, 0x81,
158 0x48, 0xa1, 0xd6, 0x5d, 0xfc, 0x2d, 0x4b, 0x1f, 0xa3, 0xd6, 0x77, 0x28,
159 0x4a, 0xdd, 0xd2, 0x00, 0x12, 0x6d, 0x90, 0x69
162 if (ctx == NULL || sha256 == NULL || drbg == NULL || kdf == NULL)
165 if (!EVP_DigestInit_ex(ctx, sha256, NULL))
167 if (!EVP_DigestUpdate(ctx, msg, sizeof(msg) - 1))
169 if (!EVP_DigestFinal(ctx, dgst, &dgstlen))
171 if (dgstlen != sizeof(exptd) || memcmp(dgst, exptd, sizeof(exptd)) != 0)
174 bnctx = BN_CTX_new_ex(libctx);
178 a = BN_CTX_get(bnctx);
179 b = BN_CTX_get(bnctx);
185 || BN_cmp(a, b) != 0)
188 if (RAND_DRBG_bytes(drbg, randbuf, sizeof(randbuf)) <= 0)
191 if (!BN_rand_ex(a, 256, BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY, bnctx))
194 #ifndef OPENSSL_NO_EC
195 /* Do some dummy EC calls */
196 key = EC_KEY_new_by_curve_name_ex(libctx, NID_X9_62_prime256v1);
200 if (!EC_KEY_generate_key(key))
210 EVP_MD_CTX_free(ctx);
213 #ifndef OPENSSL_NO_EC
219 static const OSSL_PARAM *fips_gettable_params(void *provctx)
221 return fips_param_types;
224 static int fips_get_params(void *provctx, OSSL_PARAM params[])
228 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME);
229 if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL FIPS Provider"))
231 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_VERSION);
232 if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_VERSION_STR))
234 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_BUILDINFO);
235 if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_FULL_VERSION_STR))
241 /* FIPS specific version of the function of the same name in provlib.c */
242 const char *ossl_prov_util_nid_to_name(int nid)
244 /* We don't have OBJ_nid2n() in FIPS_MODULE so we have an explicit list */
259 return "SHA-512/224";
261 return "SHA-512/256";
272 case NID_aes_256_ecb:
273 return "AES-256-ECB";
274 case NID_aes_192_ecb:
275 return "AES-192-ECB";
276 case NID_aes_128_ecb:
277 return "AES-128-ECB";
278 case NID_aes_256_cbc:
279 return "AES-256-CBC";
280 case NID_aes_192_cbc:
281 return "AES-192-CBC";
282 case NID_aes_128_cbc:
283 return "AES-128-CBC";
284 case NID_aes_256_ctr:
285 return "AES-256-CTR";
286 case NID_aes_192_ctr:
287 return "AES-192-CTR";
288 case NID_aes_128_ctr:
289 return "AES-128-CTR";
290 case NID_aes_256_xts:
291 return "AES-256-XTS";
292 case NID_aes_128_xts:
293 return "AES-128-XTS";
294 case NID_aes_256_gcm:
295 return "AES-256-GCM";
296 case NID_aes_192_gcm:
297 return "AES-192-GCM";
298 case NID_aes_128_gcm:
299 return "AES-128-GCM";
300 case NID_aes_256_ccm:
301 return "AES-256-CCM";
302 case NID_aes_192_ccm:
303 return "AES-192-CCM";
304 case NID_aes_128_ccm:
305 return "AES-128-CCM";
306 case NID_id_aes256_wrap:
307 return "AES-256-WRAP";
308 case NID_id_aes192_wrap:
309 return "AES-192-WRAP";
310 case NID_id_aes128_wrap:
311 return "AES-128-WRAP";
312 case NID_id_aes256_wrap_pad:
313 return "AES-256-WRAP-PAD";
314 case NID_id_aes192_wrap_pad:
315 return "AES-192-WRAP-PAD";
316 case NID_id_aes128_wrap_pad:
317 return "AES-128-WRAP-PAD";
318 case NID_des_ede3_ecb:
320 case NID_des_ede3_cbc:
321 return "DES-EDE3-CBC";
322 case NID_aes_256_cbc_hmac_sha256:
323 return "AES-256-CBC-HMAC-SHA256";
324 case NID_aes_128_cbc_hmac_sha256:
325 return "AES-128-CBC-HMAC-SHA256";
326 case NID_aes_256_cbc_hmac_sha1:
327 return "AES-256-CBC-HMAC-SHA1";
328 case NID_aes_128_cbc_hmac_sha1:
329 return "AES-128-CBC-HMAC-SHA1";
338 * For the algorithm names, we use the following formula for our primary
341 * ALGNAME[VERSION?][-SUBNAME[VERSION?]?][-SIZE?][-MODE?]
343 * VERSION is only present if there are multiple versions of
344 * an alg (MD2, MD4, MD5). It may be omitted if there is only
345 * one version (if a subsequent version is released in the future,
346 * we can always change the canonical name, and add the old name
349 * SUBNAME may be present where we are combining multiple
350 * algorithms together, e.g. MD5-SHA1.
352 * SIZE is only present if multiple versions of an algorithm exist
353 * with different sizes (e.g. AES-128-CBC, AES-256-CBC)
355 * MODE is only present where applicable.
357 * We add diverse other names where applicable, such as the names that
358 * NIST uses, or that are used for ASN.1 OBJECT IDENTIFIERs, or names
359 * we have used historically.
361 static const OSSL_ALGORITHM fips_digests[] = {
362 /* Our primary name:NiST name[:our older names] */
363 { "SHA1:SHA-1", "provider=fips,fips=yes", sha1_functions },
364 { "SHA2-224:SHA-224:SHA224", "provider=fips,fips=yes", sha224_functions },
365 { "SHA2-256:SHA-256:SHA256", "provider=fips,fips=yes", sha256_functions },
366 { "SHA2-384:SHA-384:SHA384", "provider=fips,fips=yes", sha384_functions },
367 { "SHA2-512:SHA-512:SHA512", "provider=fips,fips=yes", sha512_functions },
368 { "SHA2-512/224:SHA-512/224:SHA512-224", "provider=fips,fips=yes",
369 sha512_224_functions },
370 { "SHA2-512/256:SHA-512/256:SHA512-256", "provider=fips,fips=yes",
371 sha512_256_functions },
373 /* We agree with NIST here, so one name only */
374 { "SHA3-224", "provider=fips,fips=yes", sha3_224_functions },
375 { "SHA3-256", "provider=fips,fips=yes", sha3_256_functions },
376 { "SHA3-384", "provider=fips,fips=yes", sha3_384_functions },
377 { "SHA3-512", "provider=fips,fips=yes", sha3_512_functions },
379 /* Non-FIPS algorithm to support oneshot_hash in the Ed448 code */
380 { "SHAKE-256:SHAKE256", "provider=fips,fips=no", shake_256_functions },
384 static const OSSL_ALGORITHM_CAPABLE fips_ciphers[] = {
385 /* Our primary name[:ASN.1 OID name][:our older names] */
386 ALG("AES-256-ECB", aes256ecb_functions),
387 ALG("AES-192-ECB", aes192ecb_functions),
388 ALG("AES-128-ECB", aes128ecb_functions),
389 ALG("AES-256-CBC", aes256cbc_functions),
390 ALG("AES-192-CBC", aes192cbc_functions),
391 ALG("AES-128-CBC", aes128cbc_functions),
392 ALG("AES-256-CTR", aes256ctr_functions),
393 ALG("AES-192-CTR", aes192ctr_functions),
394 ALG("AES-128-CTR", aes128ctr_functions),
395 ALG("AES-256-XTS", aes256xts_functions),
396 ALG("AES-128-XTS", aes128xts_functions),
397 ALG("AES-256-GCM:id-aes256-GCM", aes256gcm_functions),
398 ALG("AES-192-GCM:id-aes192-GCM", aes192gcm_functions),
399 ALG("AES-128-GCM:id-aes128-GCM", aes128gcm_functions),
400 ALG("AES-256-CCM:id-aes256-CCM", aes256ccm_functions),
401 ALG("AES-192-CCM:id-aes192-CCM", aes192ccm_functions),
402 ALG("AES-128-CCM:id-aes128-CCM", aes128ccm_functions),
403 ALG("AES-256-WRAP:id-aes256-wrap:AES256-WRAP", aes256wrap_functions),
404 ALG("AES-192-WRAP:id-aes192-wrap:AES192-WRAP", aes192wrap_functions),
405 ALG("AES-128-WRAP:id-aes128-wrap:AES128-WRAP", aes128wrap_functions),
406 ALG("AES-256-WRAP-PAD:id-aes256-wrap-pad:AES256-WRAP-PAD",
407 aes256wrappad_functions),
408 ALG("AES-192-WRAP-PAD:id-aes192-wrap-pad:AES192-WRAP-PAD",
409 aes192wrappad_functions),
410 ALG("AES-128-WRAP-PAD:id-aes128-wrap-pad:AES128-WRAP-PAD",
411 aes128wrappad_functions),
412 ALGC("AES-128-CBC-HMAC-SHA1", aes128cbc_hmac_sha1_functions,
413 cipher_capable_aes_cbc_hmac_sha1),
414 ALGC("AES-256-CBC-HMAC-SHA1", aes256cbc_hmac_sha1_functions,
415 cipher_capable_aes_cbc_hmac_sha1),
416 ALGC("AES-128-CBC-HMAC-SHA256", aes128cbc_hmac_sha256_functions,
417 cipher_capable_aes_cbc_hmac_sha256),
418 ALGC("AES-256-CBC-HMAC-SHA256", aes256cbc_hmac_sha256_functions,
419 cipher_capable_aes_cbc_hmac_sha256),
420 #ifndef OPENSSL_NO_DES
421 ALG("DES-EDE3-ECB:DES-EDE3", tdes_ede3_ecb_functions),
422 ALG("DES-EDE3-CBC:DES3", tdes_ede3_cbc_functions),
423 #endif /* OPENSSL_NO_DES */
424 { { NULL, NULL, NULL }, NULL }
426 static OSSL_ALGORITHM exported_fips_ciphers[OSSL_NELEM(fips_ciphers)];
428 static const OSSL_ALGORITHM fips_macs[] = {
429 { "GMAC", "provider=fips,fips=yes", gmac_functions },
430 { "HMAC", "provider=fips,fips=yes", hmac_functions },
434 static const OSSL_ALGORITHM fips_kdfs[] = {
435 { "HKDF", "provider=fips,fips=yes", kdf_hkdf_functions },
436 { "SSKDF", "provider=fips,fips=yes", kdf_sskdf_functions },
437 { "PBKDF2", "provider=fips,fips=yes", kdf_pbkdf2_functions },
438 { "TLS1-PRF", "provider=fips,fips=yes", kdf_tls1_prf_functions },
442 static const OSSL_ALGORITHM fips_keyexch[] = {
443 #ifndef OPENSSL_NO_DH
444 { "DH:dhKeyAgreement", "provider=fips,fips=yes", dh_keyexch_functions },
446 #ifndef OPENSSL_NO_EC
447 { "ECDH", "provider=fips,fips=yes", ecdh_keyexch_functions },
448 { "X25519", "provider=fips,fips=no", x25519_keyexch_functions },
449 { "X448", "provider=fips,fips=no", x448_keyexch_functions },
454 static const OSSL_ALGORITHM fips_signature[] = {
455 #ifndef OPENSSL_NO_DSA
456 { "DSA:dsaEncryption", "provider=fips,fips=yes", dsa_signature_functions },
458 { "RSA:rsaEncryption", "provider=fips,fips=yes", rsa_signature_functions },
459 #ifndef OPENSSL_NO_EC
460 { "ED25519", "provider=fips,fips=no", ed25519_signature_functions },
461 { "ED448", "provider=fips,fips=no", ed448_signature_functions },
462 { "ECDSA", "provider=fips,fips=yes", ecdsa_signature_functions },
467 static const OSSL_ALGORITHM fips_asym_cipher[] = {
468 { "RSA:rsaEncryption", "provider=fips,fips=yes", rsa_asym_cipher_functions },
472 static const OSSL_ALGORITHM fips_keymgmt[] = {
473 #ifndef OPENSSL_NO_DH
474 { "DH:dhKeyAgreement", "provider=fips,fips=yes", dh_keymgmt_functions },
476 #ifndef OPENSSL_NO_DSA
477 { "DSA", "provider=fips,fips=yes", dsa_keymgmt_functions },
479 { "RSA:rsaEncryption", "provider=fips,fips=yes", rsa_keymgmt_functions },
480 { "RSA-PSS:RSASSA-PSS", "provider=default", rsapss_keymgmt_functions },
481 #ifndef OPENSSL_NO_EC
482 { "EC:id-ecPublicKey", "provider=fips,fips=yes", ec_keymgmt_functions },
483 { "X25519", "provider=fips,fips=no", x25519_keymgmt_functions },
484 { "X448", "provider=fips,fips=no", x448_keymgmt_functions },
485 { "ED25519", "provider=fips,fips=no", ed25519_keymgmt_functions },
486 { "ED448", "provider=fips,fips=no", ed448_keymgmt_functions },
491 static const OSSL_ALGORITHM *fips_query(void *provctx, int operation_id,
495 switch (operation_id) {
499 ossl_prov_cache_exported_algorithms(fips_ciphers, exported_fips_ciphers);
500 return exported_fips_ciphers;
505 case OSSL_OP_KEYMGMT:
507 case OSSL_OP_KEYEXCH:
509 case OSSL_OP_SIGNATURE:
510 return fips_signature;
511 case OSSL_OP_ASYM_CIPHER:
512 return fips_asym_cipher;
517 static void fips_teardown(void *provctx)
519 OPENSSL_CTX_free(PROV_LIBRARY_CONTEXT_OF(provctx));
520 PROV_CTX_free(provctx);
523 static void fips_intern_teardown(void *provctx)
526 * We know that the library context is the same as for the outer provider,
527 * so no need to destroy it here.
529 PROV_CTX_free(provctx);
532 /* Functions we provide to the core */
533 static const OSSL_DISPATCH fips_dispatch_table[] = {
534 { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))fips_teardown },
535 { OSSL_FUNC_PROVIDER_GETTABLE_PARAMS, (void (*)(void))fips_gettable_params },
536 { OSSL_FUNC_PROVIDER_GET_PARAMS, (void (*)(void))fips_get_params },
537 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query },
541 /* Functions we provide to ourself */
542 static const OSSL_DISPATCH intern_dispatch_table[] = {
543 { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))fips_intern_teardown },
544 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query },
549 int OSSL_provider_init(const OSSL_PROVIDER *provider,
550 const OSSL_DISPATCH *in,
551 const OSSL_DISPATCH **out,
555 OPENSSL_CTX *libctx = NULL;
556 OSSL_self_test_cb_fn *stcbfn = NULL;
557 OSSL_core_get_library_context_fn *c_get_libctx = NULL;
559 for (; in->function_id != 0; in++) {
560 switch (in->function_id) {
561 case OSSL_FUNC_CORE_GET_LIBRARY_CONTEXT:
562 c_get_libctx = OSSL_get_core_get_library_context(in);
564 case OSSL_FUNC_CORE_GETTABLE_PARAMS:
565 c_gettable_params = OSSL_get_core_gettable_params(in);
567 case OSSL_FUNC_CORE_GET_PARAMS:
568 c_get_params = OSSL_get_core_get_params(in);
570 case OSSL_FUNC_CORE_THREAD_START:
571 c_thread_start = OSSL_get_core_thread_start(in);
573 case OSSL_FUNC_CORE_NEW_ERROR:
574 c_new_error = OSSL_get_core_new_error(in);
576 case OSSL_FUNC_CORE_SET_ERROR_DEBUG:
577 c_set_error_debug = OSSL_get_core_set_error_debug(in);
579 case OSSL_FUNC_CORE_VSET_ERROR:
580 c_vset_error = OSSL_get_core_vset_error(in);
582 case OSSL_FUNC_CORE_SET_ERROR_MARK:
583 c_set_error_mark = OSSL_get_core_set_error_mark(in);
585 case OSSL_FUNC_CORE_CLEAR_LAST_ERROR_MARK:
586 c_clear_last_error_mark = OSSL_get_core_clear_last_error_mark(in);
588 case OSSL_FUNC_CORE_POP_ERROR_TO_MARK:
589 c_pop_error_to_mark = OSSL_get_core_pop_error_to_mark(in);
591 case OSSL_FUNC_CRYPTO_MALLOC:
592 c_CRYPTO_malloc = OSSL_get_CRYPTO_malloc(in);
594 case OSSL_FUNC_CRYPTO_ZALLOC:
595 c_CRYPTO_zalloc = OSSL_get_CRYPTO_zalloc(in);
597 case OSSL_FUNC_CRYPTO_FREE:
598 c_CRYPTO_free = OSSL_get_CRYPTO_free(in);
600 case OSSL_FUNC_CRYPTO_CLEAR_FREE:
601 c_CRYPTO_clear_free = OSSL_get_CRYPTO_clear_free(in);
603 case OSSL_FUNC_CRYPTO_REALLOC:
604 c_CRYPTO_realloc = OSSL_get_CRYPTO_realloc(in);
606 case OSSL_FUNC_CRYPTO_CLEAR_REALLOC:
607 c_CRYPTO_clear_realloc = OSSL_get_CRYPTO_clear_realloc(in);
609 case OSSL_FUNC_CRYPTO_SECURE_MALLOC:
610 c_CRYPTO_secure_malloc = OSSL_get_CRYPTO_secure_malloc(in);
612 case OSSL_FUNC_CRYPTO_SECURE_ZALLOC:
613 c_CRYPTO_secure_zalloc = OSSL_get_CRYPTO_secure_zalloc(in);
615 case OSSL_FUNC_CRYPTO_SECURE_FREE:
616 c_CRYPTO_secure_free = OSSL_get_CRYPTO_secure_free(in);
618 case OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE:
619 c_CRYPTO_secure_clear_free = OSSL_get_CRYPTO_secure_clear_free(in);
621 case OSSL_FUNC_CRYPTO_SECURE_ALLOCATED:
622 c_CRYPTO_secure_allocated = OSSL_get_CRYPTO_secure_allocated(in);
624 case OSSL_FUNC_BIO_NEW_FILE:
625 selftest_params.bio_new_file_cb = OSSL_get_BIO_new_file(in);
627 case OSSL_FUNC_BIO_NEW_MEMBUF:
628 selftest_params.bio_new_buffer_cb = OSSL_get_BIO_new_membuf(in);
630 case OSSL_FUNC_BIO_READ_EX:
631 selftest_params.bio_read_ex_cb = OSSL_get_BIO_read_ex(in);
633 case OSSL_FUNC_BIO_FREE:
634 selftest_params.bio_free_cb = OSSL_get_BIO_free(in);
636 case OSSL_FUNC_BIO_VSNPRINTF:
637 c_BIO_vsnprintf = OSSL_get_BIO_vsnprintf(in);
639 case OSSL_FUNC_SELF_TEST_CB: {
640 stcbfn = OSSL_get_self_test_cb(in);
644 /* Just ignore anything we don't understand */
649 if (stcbfn != NULL && c_get_libctx != NULL) {
650 stcbfn(c_get_libctx(provider), &selftest_params.cb,
651 &selftest_params.cb_arg);
654 selftest_params.cb = NULL;
655 selftest_params.cb_arg = NULL;
658 if (!c_get_params(provider, core_params))
661 /* Create a context. */
662 if ((*provctx = PROV_CTX_new()) == NULL
663 || (libctx = OPENSSL_CTX_new()) == NULL) {
665 * We free libctx separately here and only here because it hasn't
666 * been attached to *provctx. All other error paths below rely
667 * solely on fips_teardown.
669 OPENSSL_CTX_free(libctx);
672 PROV_CTX_set0_library_context(*provctx, libctx);
673 PROV_CTX_set0_provider(*provctx, provider);
675 if ((fgbl = openssl_ctx_get_data(libctx, OPENSSL_CTX_FIPS_PROV_INDEX,
676 &fips_prov_ossl_ctx_method)) == NULL)
679 fgbl->prov = provider;
681 selftest_params.libctx = libctx;
682 if (!SELF_TEST_post(&selftest_params, 0))
686 * TODO(3.0): Remove me. This is just a dummy call to demonstrate making
687 * EVP calls from within the FIPS module.
689 if (!dummy_evp_call(libctx))
692 *out = fips_dispatch_table;
696 fips_teardown(*provctx);
702 * The internal init function used when the FIPS module uses EVP to call
703 * another algorithm also in the FIPS module. This is a recursive call that has
704 * been made from within the FIPS module itself. To make this work, we populate
705 * the provider context of this inner instance with the same library context
706 * that was used in the EVP call that initiated this recursive call.
708 OSSL_provider_init_fn fips_intern_provider_init;
709 int fips_intern_provider_init(const OSSL_PROVIDER *provider,
710 const OSSL_DISPATCH *in,
711 const OSSL_DISPATCH **out,
714 OSSL_core_get_library_context_fn *c_get_libctx = NULL;
716 for (; in->function_id != 0; in++) {
717 switch (in->function_id) {
718 case OSSL_FUNC_CORE_GET_LIBRARY_CONTEXT:
719 c_get_libctx = OSSL_get_core_get_library_context(in);
726 if (c_get_libctx == NULL)
729 if ((*provctx = PROV_CTX_new()) == NULL)
731 PROV_CTX_set0_library_context(*provctx, c_get_libctx(provider));
732 PROV_CTX_set0_provider(*provctx, provider);
734 *out = intern_dispatch_table;
743 void ERR_set_debug(const char *file, int line, const char *func)
745 c_set_error_debug(NULL, file, line, func);
748 void ERR_set_error(int lib, int reason, const char *fmt, ...)
753 c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args);
757 void ERR_vset_error(int lib, int reason, const char *fmt, va_list args)
759 c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args);
762 int ERR_set_mark(void)
764 return c_set_error_mark(NULL);
767 int ERR_clear_last_mark(void)
769 return c_clear_last_error_mark(NULL);
772 int ERR_pop_to_mark(void)
774 return c_pop_error_to_mark(NULL);
778 * This must take a library context, since it's called from the depths
779 * of crypto/initthread.c code, where it's (correctly) assumed that the
780 * passed caller argument is an OPENSSL_CTX pointer (since the same routine
781 * is also called from other parts of libcrypto, which all pass around a
782 * OPENSSL_CTX pointer)
784 const OSSL_PROVIDER *FIPS_get_provider(OPENSSL_CTX *libctx)
786 FIPS_GLOBAL *fgbl = openssl_ctx_get_data(libctx,
787 OPENSSL_CTX_FIPS_PROV_INDEX,
788 &fips_prov_ossl_ctx_method);
796 void *CRYPTO_malloc(size_t num, const char *file, int line)
798 return c_CRYPTO_malloc(num, file, line);
801 void *CRYPTO_zalloc(size_t num, const char *file, int line)
803 return c_CRYPTO_zalloc(num, file, line);
806 void CRYPTO_free(void *ptr, const char *file, int line)
808 c_CRYPTO_free(ptr, file, line);
811 void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line)
813 c_CRYPTO_clear_free(ptr, num, file, line);
816 void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line)
818 return c_CRYPTO_realloc(addr, num, file, line);
821 void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
822 const char *file, int line)
824 return c_CRYPTO_clear_realloc(addr, old_num, num, file, line);
827 void *CRYPTO_secure_malloc(size_t num, const char *file, int line)
829 return c_CRYPTO_secure_malloc(num, file, line);
832 void *CRYPTO_secure_zalloc(size_t num, const char *file, int line)
834 return c_CRYPTO_secure_zalloc(num, file, line);
837 void CRYPTO_secure_free(void *ptr, const char *file, int line)
839 c_CRYPTO_secure_free(ptr, file, line);
842 void CRYPTO_secure_clear_free(void *ptr, size_t num, const char *file, int line)
844 c_CRYPTO_secure_clear_free(ptr, num, file, line);
847 int CRYPTO_secure_allocated(const void *ptr)
849 return c_CRYPTO_secure_allocated(ptr);
852 int BIO_snprintf(char *buf, size_t n, const char *format, ...)
857 va_start(args, format);
858 ret = c_BIO_vsnprintf(buf, n, format, args);