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_CORE_HANDLE
*handle
;
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
117 * OSSL_PROV_PARAM_CORE_MODULE_FILENAME).
119 static OSSL_PARAM core_params
[] =
121 OSSL_PARAM_utf8_ptr(OSSL_PROV_PARAM_CORE_MODULE_FILENAME
,
122 selftest_params
.module_filename
,
123 sizeof(selftest_params
.module_filename
)),
124 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_MODULE_MAC
,
125 selftest_params
.module_checksum_data
,
126 sizeof(selftest_params
.module_checksum_data
)),
127 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_MAC
,
128 selftest_params
.indicator_checksum_data
,
129 sizeof(selftest_params
.indicator_checksum_data
)),
130 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_STATUS
,
131 selftest_params
.indicator_data
,
132 sizeof(selftest_params
.indicator_data
)),
133 OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_VERSION
,
134 selftest_params
.indicator_version
,
135 sizeof(selftest_params
.indicator_version
)),
139 /* TODO(3.0): To be removed */
140 static int dummy_evp_call(OPENSSL_CTX
*libctx
)
142 EVP_MD_CTX
*ctx
= EVP_MD_CTX_new();
143 EVP_MD
*sha256
= EVP_MD_fetch(libctx
, "SHA256", NULL
);
144 EVP_KDF
*kdf
= EVP_KDF_fetch(libctx
, OSSL_KDF_NAME_PBKDF2
, NULL
);
145 unsigned char dgst
[SHA256_DIGEST_LENGTH
];
146 unsigned int dgstlen
;
148 BN_CTX
*bnctx
= NULL
;
149 BIGNUM
*a
= NULL
, *b
= NULL
;
150 unsigned char randbuf
[128];
151 RAND_DRBG
*drbg
= OPENSSL_CTX_get0_public_drbg(libctx
);
152 #ifndef OPENSSL_NO_EC
156 static const char msg
[] = "Hello World!";
157 static const unsigned char exptd
[] = {
158 0x7f, 0x83, 0xb1, 0x65, 0x7f, 0xf1, 0xfc, 0x53, 0xb9, 0x2d, 0xc1, 0x81,
159 0x48, 0xa1, 0xd6, 0x5d, 0xfc, 0x2d, 0x4b, 0x1f, 0xa3, 0xd6, 0x77, 0x28,
160 0x4a, 0xdd, 0xd2, 0x00, 0x12, 0x6d, 0x90, 0x69
163 if (ctx
== NULL
|| sha256
== NULL
|| drbg
== NULL
|| kdf
== NULL
)
166 if (!EVP_DigestInit_ex(ctx
, sha256
, NULL
))
168 if (!EVP_DigestUpdate(ctx
, msg
, sizeof(msg
) - 1))
170 if (!EVP_DigestFinal(ctx
, dgst
, &dgstlen
))
172 if (dgstlen
!= sizeof(exptd
) || memcmp(dgst
, exptd
, sizeof(exptd
)) != 0)
175 bnctx
= BN_CTX_new_ex(libctx
);
179 a
= BN_CTX_get(bnctx
);
180 b
= BN_CTX_get(bnctx
);
186 || BN_cmp(a
, b
) != 0)
189 if (RAND_DRBG_bytes(drbg
, randbuf
, sizeof(randbuf
)) <= 0)
192 if (!BN_rand_ex(a
, 256, BN_RAND_TOP_ANY
, BN_RAND_BOTTOM_ANY
, bnctx
))
195 #ifndef OPENSSL_NO_EC
196 /* Do some dummy EC calls */
197 key
= EC_KEY_new_by_curve_name_ex(libctx
, NID_X9_62_prime256v1
);
201 if (!EC_KEY_generate_key(key
))
211 EVP_MD_CTX_free(ctx
);
214 #ifndef OPENSSL_NO_EC
220 static const OSSL_PARAM
*fips_gettable_params(void *provctx
)
222 return fips_param_types
;
225 static int fips_get_params(void *provctx
, OSSL_PARAM params
[])
229 p
= OSSL_PARAM_locate(params
, OSSL_PROV_PARAM_NAME
);
230 if (p
!= NULL
&& !OSSL_PARAM_set_utf8_ptr(p
, "OpenSSL FIPS Provider"))
232 p
= OSSL_PARAM_locate(params
, OSSL_PROV_PARAM_VERSION
);
233 if (p
!= NULL
&& !OSSL_PARAM_set_utf8_ptr(p
, OPENSSL_VERSION_STR
))
235 p
= OSSL_PARAM_locate(params
, OSSL_PROV_PARAM_BUILDINFO
);
236 if (p
!= NULL
&& !OSSL_PARAM_set_utf8_ptr(p
, OPENSSL_FULL_VERSION_STR
))
242 /* FIPS specific version of the function of the same name in provlib.c */
243 const char *ossl_prov_util_nid_to_name(int nid
)
245 /* We don't have OBJ_nid2n() in FIPS_MODULE so we have an explicit list */
260 return "SHA-512/224";
262 return "SHA-512/256";
273 case NID_aes_256_ecb
:
274 return "AES-256-ECB";
275 case NID_aes_192_ecb
:
276 return "AES-192-ECB";
277 case NID_aes_128_ecb
:
278 return "AES-128-ECB";
279 case NID_aes_256_cbc
:
280 return "AES-256-CBC";
281 case NID_aes_192_cbc
:
282 return "AES-192-CBC";
283 case NID_aes_128_cbc
:
284 return "AES-128-CBC";
285 case NID_aes_256_ctr
:
286 return "AES-256-CTR";
287 case NID_aes_192_ctr
:
288 return "AES-192-CTR";
289 case NID_aes_128_ctr
:
290 return "AES-128-CTR";
291 case NID_aes_256_xts
:
292 return "AES-256-XTS";
293 case NID_aes_128_xts
:
294 return "AES-128-XTS";
295 case NID_aes_256_gcm
:
296 return "AES-256-GCM";
297 case NID_aes_192_gcm
:
298 return "AES-192-GCM";
299 case NID_aes_128_gcm
:
300 return "AES-128-GCM";
301 case NID_aes_256_ccm
:
302 return "AES-256-CCM";
303 case NID_aes_192_ccm
:
304 return "AES-192-CCM";
305 case NID_aes_128_ccm
:
306 return "AES-128-CCM";
307 case NID_id_aes256_wrap
:
308 return "AES-256-WRAP";
309 case NID_id_aes192_wrap
:
310 return "AES-192-WRAP";
311 case NID_id_aes128_wrap
:
312 return "AES-128-WRAP";
313 case NID_id_aes256_wrap_pad
:
314 return "AES-256-WRAP-PAD";
315 case NID_id_aes192_wrap_pad
:
316 return "AES-192-WRAP-PAD";
317 case NID_id_aes128_wrap_pad
:
318 return "AES-128-WRAP-PAD";
319 case NID_des_ede3_ecb
:
321 case NID_des_ede3_cbc
:
322 return "DES-EDE3-CBC";
323 case NID_aes_256_cbc_hmac_sha256
:
324 return "AES-256-CBC-HMAC-SHA256";
325 case NID_aes_128_cbc_hmac_sha256
:
326 return "AES-128-CBC-HMAC-SHA256";
327 case NID_aes_256_cbc_hmac_sha1
:
328 return "AES-256-CBC-HMAC-SHA1";
329 case NID_aes_128_cbc_hmac_sha1
:
330 return "AES-128-CBC-HMAC-SHA1";
339 * For the algorithm names, we use the following formula for our primary
342 * ALGNAME[VERSION?][-SUBNAME[VERSION?]?][-SIZE?][-MODE?]
344 * VERSION is only present if there are multiple versions of
345 * an alg (MD2, MD4, MD5). It may be omitted if there is only
346 * one version (if a subsequent version is released in the future,
347 * we can always change the canonical name, and add the old name
350 * SUBNAME may be present where we are combining multiple
351 * algorithms together, e.g. MD5-SHA1.
353 * SIZE is only present if multiple versions of an algorithm exist
354 * with different sizes (e.g. AES-128-CBC, AES-256-CBC)
356 * MODE is only present where applicable.
358 * We add diverse other names where applicable, such as the names that
359 * NIST uses, or that are used for ASN.1 OBJECT IDENTIFIERs, or names
360 * we have used historically.
362 static const OSSL_ALGORITHM fips_digests
[] = {
363 /* Our primary name:NiST name[:our older names] */
364 { "SHA1:SHA-1", "provider=fips,fips=yes", sha1_functions
},
365 { "SHA2-224:SHA-224:SHA224", "provider=fips,fips=yes", sha224_functions
},
366 { "SHA2-256:SHA-256:SHA256", "provider=fips,fips=yes", sha256_functions
},
367 { "SHA2-384:SHA-384:SHA384", "provider=fips,fips=yes", sha384_functions
},
368 { "SHA2-512:SHA-512:SHA512", "provider=fips,fips=yes", sha512_functions
},
369 { "SHA2-512/224:SHA-512/224:SHA512-224", "provider=fips,fips=yes",
370 sha512_224_functions
},
371 { "SHA2-512/256:SHA-512/256:SHA512-256", "provider=fips,fips=yes",
372 sha512_256_functions
},
374 /* We agree with NIST here, so one name only */
375 { "SHA3-224", "provider=fips,fips=yes", sha3_224_functions
},
376 { "SHA3-256", "provider=fips,fips=yes", sha3_256_functions
},
377 { "SHA3-384", "provider=fips,fips=yes", sha3_384_functions
},
378 { "SHA3-512", "provider=fips,fips=yes", sha3_512_functions
},
380 /* Non-FIPS algorithm to support oneshot_hash in the Ed448 code */
381 { "SHAKE-256:SHAKE256", "provider=fips,fips=no", shake_256_functions
},
385 static const OSSL_ALGORITHM_CAPABLE fips_ciphers
[] = {
386 /* Our primary name[:ASN.1 OID name][:our older names] */
387 ALG("AES-256-ECB", aes256ecb_functions
),
388 ALG("AES-192-ECB", aes192ecb_functions
),
389 ALG("AES-128-ECB", aes128ecb_functions
),
390 ALG("AES-256-CBC", aes256cbc_functions
),
391 ALG("AES-192-CBC", aes192cbc_functions
),
392 ALG("AES-128-CBC", aes128cbc_functions
),
393 ALG("AES-256-CFB", aes256cfb_functions
),
394 ALG("AES-192-CFB", aes192cfb_functions
),
395 ALG("AES-128-CFB", aes128cfb_functions
),
396 ALG("AES-256-CFB1", aes256cfb1_functions
),
397 ALG("AES-192-CFB1", aes192cfb1_functions
),
398 ALG("AES-128-CFB1", aes128cfb1_functions
),
399 ALG("AES-256-CFB8", aes256cfb8_functions
),
400 ALG("AES-192-CFB8", aes192cfb8_functions
),
401 ALG("AES-128-CFB8", aes128cfb8_functions
),
402 ALG("AES-256-CTR", aes256ctr_functions
),
403 ALG("AES-192-CTR", aes192ctr_functions
),
404 ALG("AES-128-CTR", aes128ctr_functions
),
405 ALG("AES-256-XTS", aes256xts_functions
),
406 ALG("AES-128-XTS", aes128xts_functions
),
407 ALG("AES-256-GCM:id-aes256-GCM", aes256gcm_functions
),
408 ALG("AES-192-GCM:id-aes192-GCM", aes192gcm_functions
),
409 ALG("AES-128-GCM:id-aes128-GCM", aes128gcm_functions
),
410 ALG("AES-256-CCM:id-aes256-CCM", aes256ccm_functions
),
411 ALG("AES-192-CCM:id-aes192-CCM", aes192ccm_functions
),
412 ALG("AES-128-CCM:id-aes128-CCM", aes128ccm_functions
),
413 ALG("AES-256-WRAP:id-aes256-wrap:AES256-WRAP", aes256wrap_functions
),
414 ALG("AES-192-WRAP:id-aes192-wrap:AES192-WRAP", aes192wrap_functions
),
415 ALG("AES-128-WRAP:id-aes128-wrap:AES128-WRAP", aes128wrap_functions
),
416 ALG("AES-256-WRAP-PAD:id-aes256-wrap-pad:AES256-WRAP-PAD",
417 aes256wrappad_functions
),
418 ALG("AES-192-WRAP-PAD:id-aes192-wrap-pad:AES192-WRAP-PAD",
419 aes192wrappad_functions
),
420 ALG("AES-128-WRAP-PAD:id-aes128-wrap-pad:AES128-WRAP-PAD",
421 aes128wrappad_functions
),
422 ALGC("AES-128-CBC-HMAC-SHA1", aes128cbc_hmac_sha1_functions
,
423 cipher_capable_aes_cbc_hmac_sha1
),
424 ALGC("AES-256-CBC-HMAC-SHA1", aes256cbc_hmac_sha1_functions
,
425 cipher_capable_aes_cbc_hmac_sha1
),
426 ALGC("AES-128-CBC-HMAC-SHA256", aes128cbc_hmac_sha256_functions
,
427 cipher_capable_aes_cbc_hmac_sha256
),
428 ALGC("AES-256-CBC-HMAC-SHA256", aes256cbc_hmac_sha256_functions
,
429 cipher_capable_aes_cbc_hmac_sha256
),
430 #ifndef OPENSSL_NO_DES
431 ALG("DES-EDE3-ECB:DES-EDE3", tdes_ede3_ecb_functions
),
432 ALG("DES-EDE3-CBC:DES3", tdes_ede3_cbc_functions
),
433 #endif /* OPENSSL_NO_DES */
434 { { NULL
, NULL
, NULL
}, NULL
}
436 static OSSL_ALGORITHM exported_fips_ciphers
[OSSL_NELEM(fips_ciphers
)];
438 static const OSSL_ALGORITHM fips_macs
[] = {
439 { "GMAC", "provider=fips,fips=yes", gmac_functions
},
440 { "HMAC", "provider=fips,fips=yes", hmac_functions
},
444 static const OSSL_ALGORITHM fips_kdfs
[] = {
445 { "HKDF", "provider=fips,fips=yes", kdf_hkdf_functions
},
446 { "SSKDF", "provider=fips,fips=yes", kdf_sskdf_functions
},
447 { "PBKDF2", "provider=fips,fips=yes", kdf_pbkdf2_functions
},
448 { "TLS1-PRF", "provider=fips,fips=yes", kdf_tls1_prf_functions
},
452 static const OSSL_ALGORITHM fips_keyexch
[] = {
453 #ifndef OPENSSL_NO_DH
454 { "DH:dhKeyAgreement", "provider=fips,fips=yes", dh_keyexch_functions
},
456 #ifndef OPENSSL_NO_EC
457 { "ECDH", "provider=fips,fips=yes", ecdh_keyexch_functions
},
458 { "X25519", "provider=fips,fips=no", x25519_keyexch_functions
},
459 { "X448", "provider=fips,fips=no", x448_keyexch_functions
},
464 static const OSSL_ALGORITHM fips_signature
[] = {
465 #ifndef OPENSSL_NO_DSA
466 { "DSA:dsaEncryption", "provider=fips,fips=yes", dsa_signature_functions
},
468 { "RSA:rsaEncryption", "provider=fips,fips=yes", rsa_signature_functions
},
469 #ifndef OPENSSL_NO_EC
470 { "ED25519", "provider=fips,fips=no", ed25519_signature_functions
},
471 { "ED448", "provider=fips,fips=no", ed448_signature_functions
},
472 { "ECDSA", "provider=fips,fips=yes", ecdsa_signature_functions
},
477 static const OSSL_ALGORITHM fips_asym_cipher
[] = {
478 { "RSA:rsaEncryption", "provider=fips,fips=yes", rsa_asym_cipher_functions
},
482 static const OSSL_ALGORITHM fips_keymgmt
[] = {
483 #ifndef OPENSSL_NO_DH
484 { "DH:dhKeyAgreement", "provider=fips,fips=yes", dh_keymgmt_functions
},
486 #ifndef OPENSSL_NO_DSA
487 { "DSA", "provider=fips,fips=yes", dsa_keymgmt_functions
},
489 { "RSA:rsaEncryption", "provider=fips,fips=yes", rsa_keymgmt_functions
},
490 { "RSA-PSS:RSASSA-PSS", "provider=default", rsapss_keymgmt_functions
},
491 #ifndef OPENSSL_NO_EC
492 { "EC:id-ecPublicKey", "provider=fips,fips=yes", ec_keymgmt_functions
},
493 { "X25519", "provider=fips,fips=no", x25519_keymgmt_functions
},
494 { "X448", "provider=fips,fips=no", x448_keymgmt_functions
},
495 { "ED25519", "provider=fips,fips=no", ed25519_keymgmt_functions
},
496 { "ED448", "provider=fips,fips=no", ed448_keymgmt_functions
},
501 static const OSSL_ALGORITHM
*fips_query(void *provctx
, int operation_id
,
505 switch (operation_id
) {
509 ossl_prov_cache_exported_algorithms(fips_ciphers
, exported_fips_ciphers
);
510 return exported_fips_ciphers
;
515 case OSSL_OP_KEYMGMT
:
517 case OSSL_OP_KEYEXCH
:
519 case OSSL_OP_SIGNATURE
:
520 return fips_signature
;
521 case OSSL_OP_ASYM_CIPHER
:
522 return fips_asym_cipher
;
527 static void fips_teardown(void *provctx
)
529 OPENSSL_CTX_free(PROV_LIBRARY_CONTEXT_OF(provctx
));
530 PROV_CTX_free(provctx
);
533 static void fips_intern_teardown(void *provctx
)
536 * We know that the library context is the same as for the outer provider,
537 * so no need to destroy it here.
539 PROV_CTX_free(provctx
);
542 /* Functions we provide to the core */
543 static const OSSL_DISPATCH fips_dispatch_table
[] = {
544 { OSSL_FUNC_PROVIDER_TEARDOWN
, (void (*)(void))fips_teardown
},
545 { OSSL_FUNC_PROVIDER_GETTABLE_PARAMS
, (void (*)(void))fips_gettable_params
},
546 { OSSL_FUNC_PROVIDER_GET_PARAMS
, (void (*)(void))fips_get_params
},
547 { OSSL_FUNC_PROVIDER_QUERY_OPERATION
, (void (*)(void))fips_query
},
551 /* Functions we provide to ourself */
552 static const OSSL_DISPATCH intern_dispatch_table
[] = {
553 { OSSL_FUNC_PROVIDER_TEARDOWN
, (void (*)(void))fips_intern_teardown
},
554 { OSSL_FUNC_PROVIDER_QUERY_OPERATION
, (void (*)(void))fips_query
},
559 int OSSL_provider_init(const OSSL_CORE_HANDLE
*handle
,
560 const OSSL_DISPATCH
*in
,
561 const OSSL_DISPATCH
**out
,
565 OPENSSL_CTX
*libctx
= NULL
;
566 OSSL_self_test_cb_fn
*stcbfn
= NULL
;
567 OSSL_core_get_library_context_fn
*c_get_libctx
= NULL
;
569 for (; in
->function_id
!= 0; in
++) {
570 switch (in
->function_id
) {
571 case OSSL_FUNC_CORE_GET_LIBRARY_CONTEXT
:
572 c_get_libctx
= OSSL_get_core_get_library_context(in
);
574 case OSSL_FUNC_CORE_GETTABLE_PARAMS
:
575 c_gettable_params
= OSSL_get_core_gettable_params(in
);
577 case OSSL_FUNC_CORE_GET_PARAMS
:
578 c_get_params
= OSSL_get_core_get_params(in
);
580 case OSSL_FUNC_CORE_THREAD_START
:
581 c_thread_start
= OSSL_get_core_thread_start(in
);
583 case OSSL_FUNC_CORE_NEW_ERROR
:
584 c_new_error
= OSSL_get_core_new_error(in
);
586 case OSSL_FUNC_CORE_SET_ERROR_DEBUG
:
587 c_set_error_debug
= OSSL_get_core_set_error_debug(in
);
589 case OSSL_FUNC_CORE_VSET_ERROR
:
590 c_vset_error
= OSSL_get_core_vset_error(in
);
592 case OSSL_FUNC_CORE_SET_ERROR_MARK
:
593 c_set_error_mark
= OSSL_get_core_set_error_mark(in
);
595 case OSSL_FUNC_CORE_CLEAR_LAST_ERROR_MARK
:
596 c_clear_last_error_mark
= OSSL_get_core_clear_last_error_mark(in
);
598 case OSSL_FUNC_CORE_POP_ERROR_TO_MARK
:
599 c_pop_error_to_mark
= OSSL_get_core_pop_error_to_mark(in
);
601 case OSSL_FUNC_CRYPTO_MALLOC
:
602 c_CRYPTO_malloc
= OSSL_get_CRYPTO_malloc(in
);
604 case OSSL_FUNC_CRYPTO_ZALLOC
:
605 c_CRYPTO_zalloc
= OSSL_get_CRYPTO_zalloc(in
);
607 case OSSL_FUNC_CRYPTO_FREE
:
608 c_CRYPTO_free
= OSSL_get_CRYPTO_free(in
);
610 case OSSL_FUNC_CRYPTO_CLEAR_FREE
:
611 c_CRYPTO_clear_free
= OSSL_get_CRYPTO_clear_free(in
);
613 case OSSL_FUNC_CRYPTO_REALLOC
:
614 c_CRYPTO_realloc
= OSSL_get_CRYPTO_realloc(in
);
616 case OSSL_FUNC_CRYPTO_CLEAR_REALLOC
:
617 c_CRYPTO_clear_realloc
= OSSL_get_CRYPTO_clear_realloc(in
);
619 case OSSL_FUNC_CRYPTO_SECURE_MALLOC
:
620 c_CRYPTO_secure_malloc
= OSSL_get_CRYPTO_secure_malloc(in
);
622 case OSSL_FUNC_CRYPTO_SECURE_ZALLOC
:
623 c_CRYPTO_secure_zalloc
= OSSL_get_CRYPTO_secure_zalloc(in
);
625 case OSSL_FUNC_CRYPTO_SECURE_FREE
:
626 c_CRYPTO_secure_free
= OSSL_get_CRYPTO_secure_free(in
);
628 case OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE
:
629 c_CRYPTO_secure_clear_free
= OSSL_get_CRYPTO_secure_clear_free(in
);
631 case OSSL_FUNC_CRYPTO_SECURE_ALLOCATED
:
632 c_CRYPTO_secure_allocated
= OSSL_get_CRYPTO_secure_allocated(in
);
634 case OSSL_FUNC_BIO_NEW_FILE
:
635 selftest_params
.bio_new_file_cb
= OSSL_get_BIO_new_file(in
);
637 case OSSL_FUNC_BIO_NEW_MEMBUF
:
638 selftest_params
.bio_new_buffer_cb
= OSSL_get_BIO_new_membuf(in
);
640 case OSSL_FUNC_BIO_READ_EX
:
641 selftest_params
.bio_read_ex_cb
= OSSL_get_BIO_read_ex(in
);
643 case OSSL_FUNC_BIO_FREE
:
644 selftest_params
.bio_free_cb
= OSSL_get_BIO_free(in
);
646 case OSSL_FUNC_BIO_VSNPRINTF
:
647 c_BIO_vsnprintf
= OSSL_get_BIO_vsnprintf(in
);
649 case OSSL_FUNC_SELF_TEST_CB
: {
650 stcbfn
= OSSL_get_self_test_cb(in
);
654 /* Just ignore anything we don't understand */
659 if (stcbfn
!= NULL
&& c_get_libctx
!= NULL
) {
660 stcbfn(c_get_libctx(handle
), &selftest_params
.cb
,
661 &selftest_params
.cb_arg
);
664 selftest_params
.cb
= NULL
;
665 selftest_params
.cb_arg
= NULL
;
668 if (!c_get_params(handle
, core_params
))
671 /* Create a context. */
672 if ((*provctx
= PROV_CTX_new()) == NULL
673 || (libctx
= OPENSSL_CTX_new()) == NULL
) {
675 * We free libctx separately here and only here because it hasn't
676 * been attached to *provctx. All other error paths below rely
677 * solely on fips_teardown.
679 OPENSSL_CTX_free(libctx
);
682 PROV_CTX_set0_library_context(*provctx
, libctx
);
683 PROV_CTX_set0_handle(*provctx
, handle
);
685 if ((fgbl
= openssl_ctx_get_data(libctx
, OPENSSL_CTX_FIPS_PROV_INDEX
,
686 &fips_prov_ossl_ctx_method
)) == NULL
)
689 fgbl
->handle
= handle
;
691 selftest_params
.libctx
= libctx
;
692 if (!SELF_TEST_post(&selftest_params
, 0))
696 * TODO(3.0): Remove me. This is just a dummy call to demonstrate making
697 * EVP calls from within the FIPS module.
699 if (!dummy_evp_call(libctx
))
702 *out
= fips_dispatch_table
;
706 fips_teardown(*provctx
);
712 * The internal init function used when the FIPS module uses EVP to call
713 * another algorithm also in the FIPS module. This is a recursive call that has
714 * been made from within the FIPS module itself. To make this work, we populate
715 * the provider context of this inner instance with the same library context
716 * that was used in the EVP call that initiated this recursive call.
718 OSSL_provider_init_fn fips_intern_provider_init
;
719 int fips_intern_provider_init(const OSSL_CORE_HANDLE
*handle
,
720 const OSSL_DISPATCH
*in
,
721 const OSSL_DISPATCH
**out
,
724 OSSL_core_get_library_context_fn
*c_get_libctx
= NULL
;
726 for (; in
->function_id
!= 0; in
++) {
727 switch (in
->function_id
) {
728 case OSSL_FUNC_CORE_GET_LIBRARY_CONTEXT
:
729 c_get_libctx
= OSSL_get_core_get_library_context(in
);
736 if (c_get_libctx
== NULL
)
739 if ((*provctx
= PROV_CTX_new()) == NULL
)
742 * Using the parent library context only works because we are a built-in
743 * internal provider. This is not something that most providers would be
746 PROV_CTX_set0_library_context(*provctx
, (OPENSSL_CTX
*)c_get_libctx(handle
));
747 PROV_CTX_set0_handle(*provctx
, handle
);
749 *out
= intern_dispatch_table
;
758 void ERR_set_debug(const char *file
, int line
, const char *func
)
760 c_set_error_debug(NULL
, file
, line
, func
);
763 void ERR_set_error(int lib
, int reason
, const char *fmt
, ...)
768 c_vset_error(NULL
, ERR_PACK(lib
, 0, reason
), fmt
, args
);
772 void ERR_vset_error(int lib
, int reason
, const char *fmt
, va_list args
)
774 c_vset_error(NULL
, ERR_PACK(lib
, 0, reason
), fmt
, args
);
777 int ERR_set_mark(void)
779 return c_set_error_mark(NULL
);
782 int ERR_clear_last_mark(void)
784 return c_clear_last_error_mark(NULL
);
787 int ERR_pop_to_mark(void)
789 return c_pop_error_to_mark(NULL
);
793 * This must take a library context, since it's called from the depths
794 * of crypto/initthread.c code, where it's (correctly) assumed that the
795 * passed caller argument is an OPENSSL_CTX pointer (since the same routine
796 * is also called from other parts of libcrypto, which all pass around a
797 * OPENSSL_CTX pointer)
799 const OSSL_CORE_HANDLE
*FIPS_get_core_handle(OPENSSL_CTX
*libctx
)
801 FIPS_GLOBAL
*fgbl
= openssl_ctx_get_data(libctx
,
802 OPENSSL_CTX_FIPS_PROV_INDEX
,
803 &fips_prov_ossl_ctx_method
);
811 void *CRYPTO_malloc(size_t num
, const char *file
, int line
)
813 return c_CRYPTO_malloc(num
, file
, line
);
816 void *CRYPTO_zalloc(size_t num
, const char *file
, int line
)
818 return c_CRYPTO_zalloc(num
, file
, line
);
821 void CRYPTO_free(void *ptr
, const char *file
, int line
)
823 c_CRYPTO_free(ptr
, file
, line
);
826 void CRYPTO_clear_free(void *ptr
, size_t num
, const char *file
, int line
)
828 c_CRYPTO_clear_free(ptr
, num
, file
, line
);
831 void *CRYPTO_realloc(void *addr
, size_t num
, const char *file
, int line
)
833 return c_CRYPTO_realloc(addr
, num
, file
, line
);
836 void *CRYPTO_clear_realloc(void *addr
, size_t old_num
, size_t num
,
837 const char *file
, int line
)
839 return c_CRYPTO_clear_realloc(addr
, old_num
, num
, file
, line
);
842 void *CRYPTO_secure_malloc(size_t num
, const char *file
, int line
)
844 return c_CRYPTO_secure_malloc(num
, file
, line
);
847 void *CRYPTO_secure_zalloc(size_t num
, const char *file
, int line
)
849 return c_CRYPTO_secure_zalloc(num
, file
, line
);
852 void CRYPTO_secure_free(void *ptr
, const char *file
, int line
)
854 c_CRYPTO_secure_free(ptr
, file
, line
);
857 void CRYPTO_secure_clear_free(void *ptr
, size_t num
, const char *file
, int line
)
859 c_CRYPTO_secure_clear_free(ptr
, num
, file
, line
);
862 int CRYPTO_secure_allocated(const void *ptr
)
864 return c_CRYPTO_secure_allocated(ptr
);
867 int BIO_snprintf(char *buf
, size_t n
, const char *format
, ...)
872 va_start(args
, format
);
873 ret
= c_BIO_vsnprintf(buf
, n
, format
, args
);