]>
Commit | Line | Data |
---|---|---|
9efa0ae0 | 1 | /* |
fecb3aae | 2 | * Copyright 2019-2022 The OpenSSL Project Authors. All Rights Reserved. |
9efa0ae0 MC |
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 | ||
6ce58488 | 10 | #include <assert.h> |
23c48d94 | 11 | #include <openssl/core_dispatch.h> |
9efa0ae0 MC |
12 | #include <openssl/core_names.h> |
13 | #include <openssl/params.h> | |
25e60144 | 14 | #include <openssl/fips_names.h> |
7d615e21 | 15 | #include <openssl/rand.h> /* RAND_get0_public() */ |
2741128e | 16 | #include <openssl/proverr.h> |
3593266d | 17 | #include "internal/cryptlib.h" |
af3e7e1b | 18 | #include "prov/implementations.h" |
e2f5df36 | 19 | #include "prov/names.h" |
ddd21319 RL |
20 | #include "prov/provider_ctx.h" |
21 | #include "prov/providercommon.h" | |
0d2bfe52 | 22 | #include "prov/provider_util.h" |
08edd447 | 23 | #include "prov/seeding.h" |
30ab7747 | 24 | #include "prov/fipscommon.h" |
f2a6f838 | 25 | #include "internal/nelem.h" |
36fc5fc6 | 26 | #include "self_test.h" |
927d0566 | 27 | #include "crypto/context.h" |
c5e7de5d | 28 | #include "internal/core.h" |
9efa0ae0 | 29 | |
dcb71e1c SL |
30 | static const char FIPS_DEFAULT_PROPERTIES[] = "provider=fips,fips=yes"; |
31 | static const char FIPS_UNAPPROVED_PROPERTIES[] = "provider=fips,fips=no"; | |
32 | ||
fdaad3f1 RL |
33 | /* |
34 | * Forward declarations to ensure that interface functions are correctly | |
35 | * defined. | |
36 | */ | |
363b1e5d DMSP |
37 | static OSSL_FUNC_provider_teardown_fn fips_teardown; |
38 | static OSSL_FUNC_provider_gettable_params_fn fips_gettable_params; | |
39 | static OSSL_FUNC_provider_get_params_fn fips_get_params; | |
40 | static OSSL_FUNC_provider_query_operation_fn fips_query; | |
fdaad3f1 | 41 | |
a0ea8ac1 P |
42 | #define ALGC(NAMES, FUNC, CHECK) \ |
43 | { { NAMES, FIPS_DEFAULT_PROPERTIES, FUNC }, CHECK } | |
44 | #define UNAPPROVED_ALGC(NAMES, FUNC, CHECK) \ | |
45 | { { NAMES, FIPS_UNAPPROVED_PROPERTIES, FUNC }, CHECK } | |
0d2bfe52 | 46 | #define ALG(NAMES, FUNC) ALGC(NAMES, FUNC, NULL) |
a0ea8ac1 | 47 | #define UNAPPROVED_ALG(NAMES, FUNC) UNAPPROVED_ALGC(NAMES, FUNC, NULL) |
0d2bfe52 | 48 | |
363b1e5d | 49 | extern OSSL_FUNC_core_thread_start_fn *c_thread_start; |
b60cba3c | 50 | |
da747958 | 51 | /* |
6ce58488 MC |
52 | * Should these function pointers be stored in the provider side provctx? Could |
53 | * they ever be different from one init to the next? We assume not for now. | |
da747958 | 54 | */ |
25e60144 | 55 | |
9efa0ae0 | 56 | /* Functions provided by the core */ |
363b1e5d DMSP |
57 | static OSSL_FUNC_core_gettable_params_fn *c_gettable_params; |
58 | static OSSL_FUNC_core_get_params_fn *c_get_params; | |
59 | OSSL_FUNC_core_thread_start_fn *c_thread_start; | |
60 | static OSSL_FUNC_core_new_error_fn *c_new_error; | |
61 | static OSSL_FUNC_core_set_error_debug_fn *c_set_error_debug; | |
62 | static OSSL_FUNC_core_vset_error_fn *c_vset_error; | |
63 | static OSSL_FUNC_core_set_error_mark_fn *c_set_error_mark; | |
64 | static OSSL_FUNC_core_clear_last_error_mark_fn *c_clear_last_error_mark; | |
65 | static OSSL_FUNC_core_pop_error_to_mark_fn *c_pop_error_to_mark; | |
66 | static OSSL_FUNC_CRYPTO_malloc_fn *c_CRYPTO_malloc; | |
67 | static OSSL_FUNC_CRYPTO_zalloc_fn *c_CRYPTO_zalloc; | |
68 | static OSSL_FUNC_CRYPTO_free_fn *c_CRYPTO_free; | |
69 | static OSSL_FUNC_CRYPTO_clear_free_fn *c_CRYPTO_clear_free; | |
70 | static OSSL_FUNC_CRYPTO_realloc_fn *c_CRYPTO_realloc; | |
71 | static OSSL_FUNC_CRYPTO_clear_realloc_fn *c_CRYPTO_clear_realloc; | |
72 | static OSSL_FUNC_CRYPTO_secure_malloc_fn *c_CRYPTO_secure_malloc; | |
73 | static OSSL_FUNC_CRYPTO_secure_zalloc_fn *c_CRYPTO_secure_zalloc; | |
74 | static OSSL_FUNC_CRYPTO_secure_free_fn *c_CRYPTO_secure_free; | |
75 | static OSSL_FUNC_CRYPTO_secure_clear_free_fn *c_CRYPTO_secure_clear_free; | |
76 | static OSSL_FUNC_CRYPTO_secure_allocated_fn *c_CRYPTO_secure_allocated; | |
77 | static OSSL_FUNC_BIO_vsnprintf_fn *c_BIO_vsnprintf; | |
04cb5ec0 | 78 | static OSSL_FUNC_self_test_cb_fn *c_stcbfn = NULL; |
a829b735 | 79 | static OSSL_FUNC_core_get_libctx_fn *c_get_libctx = NULL; |
9efa0ae0 | 80 | |
83ccf81b P |
81 | typedef struct { |
82 | const char *option; | |
83 | unsigned char enabled; | |
84 | } FIPS_OPTION; | |
85 | ||
da747958 | 86 | typedef struct fips_global_st { |
d40b42ab | 87 | const OSSL_CORE_HANDLE *handle; |
6ce58488 | 88 | SELF_TEST_POST_PARAMS selftest_params; |
83ccf81b P |
89 | FIPS_OPTION fips_security_checks; |
90 | FIPS_OPTION fips_tls1_prf_ems_check; | |
91 | FIPS_OPTION fips_restricted_drgb_digests; | |
da747958 MC |
92 | } FIPS_GLOBAL; |
93 | ||
83ccf81b P |
94 | static void init_fips_option(FIPS_OPTION *opt, int enabled) |
95 | { | |
96 | opt->enabled = enabled; | |
97 | opt->option = enabled ? "1" : "0"; | |
98 | } | |
99 | ||
927d0566 | 100 | void *ossl_fips_prov_ossl_ctx_new(OSSL_LIB_CTX *libctx) |
da747958 MC |
101 | { |
102 | FIPS_GLOBAL *fgbl = OPENSSL_zalloc(sizeof(*fgbl)); | |
103 | ||
6ce58488 MC |
104 | if (fgbl == NULL) |
105 | return NULL; | |
83ccf81b P |
106 | init_fips_option(&fgbl->fips_security_checks, 1); |
107 | init_fips_option(&fgbl->fips_tls1_prf_ems_check, 0); /* Disabled by default */ | |
108 | init_fips_option(&fgbl->fips_restricted_drgb_digests, 0); | |
da747958 MC |
109 | return fgbl; |
110 | } | |
111 | ||
927d0566 | 112 | void ossl_fips_prov_ossl_ctx_free(void *fgbl) |
da747958 MC |
113 | { |
114 | OPENSSL_free(fgbl); | |
115 | } | |
116 | ||
9efa0ae0 | 117 | /* Parameters we provide to the core */ |
26175013 RL |
118 | static const OSSL_PARAM fips_param_types[] = { |
119 | OSSL_PARAM_DEFN(OSSL_PROV_PARAM_NAME, OSSL_PARAM_UTF8_PTR, NULL, 0), | |
120 | OSSL_PARAM_DEFN(OSSL_PROV_PARAM_VERSION, OSSL_PARAM_UTF8_PTR, NULL, 0), | |
121 | OSSL_PARAM_DEFN(OSSL_PROV_PARAM_BUILDINFO, OSSL_PARAM_UTF8_PTR, NULL, 0), | |
6cf37302 | 122 | OSSL_PARAM_DEFN(OSSL_PROV_PARAM_STATUS, OSSL_PARAM_INTEGER, NULL, 0), |
991a6bb5 | 123 | OSSL_PARAM_DEFN(OSSL_PROV_PARAM_SECURITY_CHECKS, OSSL_PARAM_INTEGER, NULL, 0), |
50ea5cdc | 124 | OSSL_PARAM_DEFN(OSSL_PROV_PARAM_TLS1_PRF_EMS_CHECK, OSSL_PARAM_INTEGER, NULL, 0), |
83ccf81b | 125 | OSSL_PARAM_DEFN(OSSL_PROV_PARAM_DRBG_TRUNC_DIGEST, OSSL_PARAM_INTEGER, NULL, 0), |
26175013 | 126 | OSSL_PARAM_END |
9efa0ae0 MC |
127 | }; |
128 | ||
6ce58488 MC |
129 | static int fips_get_params_from_core(FIPS_GLOBAL *fgbl) |
130 | { | |
131 | /* | |
132 | * Parameters to retrieve from the core provider - required for self testing. | |
133 | * NOTE: inside core_get_params() these will be loaded from config items | |
134 | * stored inside prov->parameters (except for | |
135 | * OSSL_PROV_PARAM_CORE_MODULE_FILENAME). | |
50ea5cdc | 136 | * OSSL_PROV_FIPS_PARAM_SECURITY_CHECKS and |
137 | * OSSL_PROV_FIPS_PARAM_TLS1_PRF_EMS_CHECK are not self test parameters. | |
6ce58488 | 138 | */ |
83ccf81b | 139 | OSSL_PARAM core_params[10], *p = core_params; |
6ce58488 MC |
140 | |
141 | *p++ = OSSL_PARAM_construct_utf8_ptr( | |
142 | OSSL_PROV_PARAM_CORE_MODULE_FILENAME, | |
143 | (char **)&fgbl->selftest_params.module_filename, | |
144 | sizeof(fgbl->selftest_params.module_filename)); | |
145 | *p++ = OSSL_PARAM_construct_utf8_ptr( | |
146 | OSSL_PROV_FIPS_PARAM_MODULE_MAC, | |
147 | (char **)&fgbl->selftest_params.module_checksum_data, | |
148 | sizeof(fgbl->selftest_params.module_checksum_data)); | |
149 | *p++ = OSSL_PARAM_construct_utf8_ptr( | |
150 | OSSL_PROV_FIPS_PARAM_INSTALL_MAC, | |
151 | (char **)&fgbl->selftest_params.indicator_checksum_data, | |
152 | sizeof(fgbl->selftest_params.indicator_checksum_data)); | |
153 | *p++ = OSSL_PARAM_construct_utf8_ptr( | |
154 | OSSL_PROV_FIPS_PARAM_INSTALL_STATUS, | |
155 | (char **)&fgbl->selftest_params.indicator_data, | |
156 | sizeof(fgbl->selftest_params.indicator_data)); | |
157 | *p++ = OSSL_PARAM_construct_utf8_ptr( | |
158 | OSSL_PROV_FIPS_PARAM_INSTALL_VERSION, | |
159 | (char **)&fgbl->selftest_params.indicator_version, | |
160 | sizeof(fgbl->selftest_params.indicator_version)); | |
161 | *p++ = OSSL_PARAM_construct_utf8_ptr( | |
162 | OSSL_PROV_FIPS_PARAM_CONDITIONAL_ERRORS, | |
163 | (char **)&fgbl->selftest_params.conditional_error_check, | |
164 | sizeof(fgbl->selftest_params.conditional_error_check)); | |
83ccf81b P |
165 | |
166 | /* FIPS features can be enabled or disabled independently */ | |
167 | #define FIPS_FEATURE_OPTION(fgbl, pname, field) \ | |
168 | *p++ = OSSL_PARAM_construct_utf8_ptr( \ | |
169 | pname, (char **)&fgbl->field.option, \ | |
170 | sizeof(fgbl->field.option)) | |
171 | ||
172 | FIPS_FEATURE_OPTION(fgbl, OSSL_PROV_FIPS_PARAM_SECURITY_CHECKS, | |
173 | fips_security_checks); | |
174 | FIPS_FEATURE_OPTION(fgbl, OSSL_PROV_FIPS_PARAM_TLS1_PRF_EMS_CHECK, | |
175 | fips_tls1_prf_ems_check); | |
176 | FIPS_FEATURE_OPTION(fgbl, OSSL_PROV_FIPS_PARAM_DRBG_TRUNC_DIGEST, | |
177 | fips_restricted_drgb_digests); | |
178 | #undef FIPS_FEATURE_OPTION | |
179 | ||
6ce58488 MC |
180 | *p = OSSL_PARAM_construct_end(); |
181 | ||
182 | if (!c_get_params(fgbl->handle, core_params)) { | |
183 | ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); | |
184 | return 0; | |
185 | } | |
186 | ||
187 | return 1; | |
188 | } | |
25e60144 | 189 | |
fdaad3f1 | 190 | static const OSSL_PARAM *fips_gettable_params(void *provctx) |
9efa0ae0 MC |
191 | { |
192 | return fips_param_types; | |
193 | } | |
194 | ||
fdaad3f1 | 195 | static int fips_get_params(void *provctx, OSSL_PARAM params[]) |
9efa0ae0 | 196 | { |
4e7991b4 | 197 | OSSL_PARAM *p; |
6ce58488 | 198 | FIPS_GLOBAL *fgbl = ossl_lib_ctx_get_data(ossl_prov_ctx_get0_libctx(provctx), |
927d0566 | 199 | OSSL_LIB_CTX_FIPS_PROV_INDEX); |
9efa0ae0 MC |
200 | |
201 | p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME); | |
202 | if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL FIPS Provider")) | |
203 | return 0; | |
204 | p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_VERSION); | |
205 | if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_VERSION_STR)) | |
206 | return 0; | |
207 | p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_BUILDINFO); | |
208 | if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_FULL_VERSION_STR)) | |
209 | return 0; | |
04cb5ec0 | 210 | p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_STATUS); |
6cf37302 | 211 | if (p != NULL && !OSSL_PARAM_set_int(p, ossl_prov_is_running())) |
04cb5ec0 | 212 | return 0; |
83ccf81b P |
213 | |
214 | #define FIPS_FEATURE_GET(fgbl, pname, field) \ | |
215 | p = OSSL_PARAM_locate(params, pname); \ | |
216 | if (p != NULL && !OSSL_PARAM_set_int(p, fgbl->field.enabled)) \ | |
217 | return 0 | |
218 | ||
219 | FIPS_FEATURE_GET(fgbl, OSSL_PROV_PARAM_SECURITY_CHECKS, | |
220 | fips_security_checks); | |
221 | FIPS_FEATURE_GET(fgbl, OSSL_PROV_PARAM_TLS1_PRF_EMS_CHECK, | |
222 | fips_tls1_prf_ems_check); | |
223 | FIPS_FEATURE_GET(fgbl, OSSL_PROV_PARAM_DRBG_TRUNC_DIGEST, | |
224 | fips_restricted_drgb_digests); | |
225 | #undef FIPS_FEATURE_GET | |
9efa0ae0 MC |
226 | return 1; |
227 | } | |
228 | ||
6ce58488 | 229 | static void set_self_test_cb(FIPS_GLOBAL *fgbl) |
04cb5ec0 | 230 | { |
6ce58488 MC |
231 | const OSSL_CORE_HANDLE *handle = |
232 | FIPS_get_core_handle(fgbl->selftest_params.libctx); | |
233 | ||
04cb5ec0 | 234 | if (c_stcbfn != NULL && c_get_libctx != NULL) { |
6ce58488 MC |
235 | c_stcbfn(c_get_libctx(handle), &fgbl->selftest_params.cb, |
236 | &fgbl->selftest_params.cb_arg); | |
04cb5ec0 | 237 | } else { |
6ce58488 MC |
238 | fgbl->selftest_params.cb = NULL; |
239 | fgbl->selftest_params.cb_arg = NULL; | |
04cb5ec0 SL |
240 | } |
241 | } | |
242 | ||
243 | static int fips_self_test(void *provctx) | |
244 | { | |
6ce58488 | 245 | FIPS_GLOBAL *fgbl = ossl_lib_ctx_get_data(ossl_prov_ctx_get0_libctx(provctx), |
927d0566 | 246 | OSSL_LIB_CTX_FIPS_PROV_INDEX); |
6ce58488 MC |
247 | |
248 | set_self_test_cb(fgbl); | |
249 | return SELF_TEST_post(&fgbl->selftest_params, 1) ? 1 : 0; | |
04cb5ec0 SL |
250 | } |
251 | ||
df553b79 RL |
252 | /* |
253 | * For the algorithm names, we use the following formula for our primary | |
254 | * names: | |
255 | * | |
256 | * ALGNAME[VERSION?][-SUBNAME[VERSION?]?][-SIZE?][-MODE?] | |
257 | * | |
258 | * VERSION is only present if there are multiple versions of | |
259 | * an alg (MD2, MD4, MD5). It may be omitted if there is only | |
260 | * one version (if a subsequent version is released in the future, | |
261 | * we can always change the canonical name, and add the old name | |
262 | * as an alias). | |
263 | * | |
264 | * SUBNAME may be present where we are combining multiple | |
265 | * algorithms together, e.g. MD5-SHA1. | |
266 | * | |
267 | * SIZE is only present if multiple versions of an algorithm exist | |
268 | * with different sizes (e.g. AES-128-CBC, AES-256-CBC) | |
269 | * | |
270 | * MODE is only present where applicable. | |
271 | * | |
272 | * We add diverse other names where applicable, such as the names that | |
273 | * NIST uses, or that are used for ASN.1 OBJECT IDENTIFIERs, or names | |
274 | * we have used historically. | |
275 | */ | |
9efa0ae0 | 276 | static const OSSL_ALGORITHM fips_digests[] = { |
df553b79 | 277 | /* Our primary name:NiST name[:our older names] */ |
e2f5df36 RL |
278 | { PROV_NAMES_SHA1, FIPS_DEFAULT_PROPERTIES, ossl_sha1_functions }, |
279 | { PROV_NAMES_SHA2_224, FIPS_DEFAULT_PROPERTIES, ossl_sha224_functions }, | |
280 | { PROV_NAMES_SHA2_256, FIPS_DEFAULT_PROPERTIES, ossl_sha256_functions }, | |
281 | { PROV_NAMES_SHA2_384, FIPS_DEFAULT_PROPERTIES, ossl_sha384_functions }, | |
282 | { PROV_NAMES_SHA2_512, FIPS_DEFAULT_PROPERTIES, ossl_sha512_functions }, | |
283 | { PROV_NAMES_SHA2_512_224, FIPS_DEFAULT_PROPERTIES, | |
1be63951 | 284 | ossl_sha512_224_functions }, |
e2f5df36 | 285 | { PROV_NAMES_SHA2_512_256, FIPS_DEFAULT_PROPERTIES, |
1be63951 | 286 | ossl_sha512_256_functions }, |
df553b79 RL |
287 | |
288 | /* We agree with NIST here, so one name only */ | |
e2f5df36 RL |
289 | { PROV_NAMES_SHA3_224, FIPS_DEFAULT_PROPERTIES, ossl_sha3_224_functions }, |
290 | { PROV_NAMES_SHA3_256, FIPS_DEFAULT_PROPERTIES, ossl_sha3_256_functions }, | |
291 | { PROV_NAMES_SHA3_384, FIPS_DEFAULT_PROPERTIES, ossl_sha3_384_functions }, | |
292 | { PROV_NAMES_SHA3_512, FIPS_DEFAULT_PROPERTIES, ossl_sha3_512_functions }, | |
d5e5e2ff | 293 | |
e2f5df36 RL |
294 | { PROV_NAMES_SHAKE_128, FIPS_DEFAULT_PROPERTIES, ossl_shake_128_functions }, |
295 | { PROV_NAMES_SHAKE_256, FIPS_DEFAULT_PROPERTIES, ossl_shake_256_functions }, | |
b1c21b27 P |
296 | |
297 | /* | |
298 | * KECCAK-KMAC-128 and KECCAK-KMAC-256 as hashes are mostly useful for | |
299 | * KMAC128 and KMAC256. | |
300 | */ | |
e2f5df36 | 301 | { PROV_NAMES_KECCAK_KMAC_128, FIPS_DEFAULT_PROPERTIES, |
1be63951 | 302 | ossl_keccak_kmac_128_functions }, |
e2f5df36 | 303 | { PROV_NAMES_KECCAK_KMAC_256, FIPS_DEFAULT_PROPERTIES, |
1be63951 | 304 | ossl_keccak_kmac_256_functions }, |
9efa0ae0 MC |
305 | { NULL, NULL, NULL } |
306 | }; | |
307 | ||
0d2bfe52 | 308 | static const OSSL_ALGORITHM_CAPABLE fips_ciphers[] = { |
df553b79 | 309 | /* Our primary name[:ASN.1 OID name][:our older names] */ |
e2f5df36 RL |
310 | ALG(PROV_NAMES_AES_256_ECB, ossl_aes256ecb_functions), |
311 | ALG(PROV_NAMES_AES_192_ECB, ossl_aes192ecb_functions), | |
312 | ALG(PROV_NAMES_AES_128_ECB, ossl_aes128ecb_functions), | |
313 | ALG(PROV_NAMES_AES_256_CBC, ossl_aes256cbc_functions), | |
314 | ALG(PROV_NAMES_AES_192_CBC, ossl_aes192cbc_functions), | |
315 | ALG(PROV_NAMES_AES_128_CBC, ossl_aes128cbc_functions), | |
316 | ALG(PROV_NAMES_AES_256_CBC_CTS, ossl_aes256cbc_cts_functions), | |
317 | ALG(PROV_NAMES_AES_192_CBC_CTS, ossl_aes192cbc_cts_functions), | |
318 | ALG(PROV_NAMES_AES_128_CBC_CTS, ossl_aes128cbc_cts_functions), | |
319 | ALG(PROV_NAMES_AES_256_OFB, ossl_aes256ofb_functions), | |
320 | ALG(PROV_NAMES_AES_192_OFB, ossl_aes192ofb_functions), | |
321 | ALG(PROV_NAMES_AES_128_OFB, ossl_aes128ofb_functions), | |
322 | ALG(PROV_NAMES_AES_256_CFB, ossl_aes256cfb_functions), | |
323 | ALG(PROV_NAMES_AES_192_CFB, ossl_aes192cfb_functions), | |
324 | ALG(PROV_NAMES_AES_128_CFB, ossl_aes128cfb_functions), | |
325 | ALG(PROV_NAMES_AES_256_CFB1, ossl_aes256cfb1_functions), | |
326 | ALG(PROV_NAMES_AES_192_CFB1, ossl_aes192cfb1_functions), | |
327 | ALG(PROV_NAMES_AES_128_CFB1, ossl_aes128cfb1_functions), | |
328 | ALG(PROV_NAMES_AES_256_CFB8, ossl_aes256cfb8_functions), | |
329 | ALG(PROV_NAMES_AES_192_CFB8, ossl_aes192cfb8_functions), | |
330 | ALG(PROV_NAMES_AES_128_CFB8, ossl_aes128cfb8_functions), | |
331 | ALG(PROV_NAMES_AES_256_CTR, ossl_aes256ctr_functions), | |
332 | ALG(PROV_NAMES_AES_192_CTR, ossl_aes192ctr_functions), | |
333 | ALG(PROV_NAMES_AES_128_CTR, ossl_aes128ctr_functions), | |
334 | ALG(PROV_NAMES_AES_256_XTS, ossl_aes256xts_functions), | |
335 | ALG(PROV_NAMES_AES_128_XTS, ossl_aes128xts_functions), | |
336 | ALG(PROV_NAMES_AES_256_GCM, ossl_aes256gcm_functions), | |
337 | ALG(PROV_NAMES_AES_192_GCM, ossl_aes192gcm_functions), | |
338 | ALG(PROV_NAMES_AES_128_GCM, ossl_aes128gcm_functions), | |
339 | ALG(PROV_NAMES_AES_256_CCM, ossl_aes256ccm_functions), | |
340 | ALG(PROV_NAMES_AES_192_CCM, ossl_aes192ccm_functions), | |
341 | ALG(PROV_NAMES_AES_128_CCM, ossl_aes128ccm_functions), | |
342 | ALG(PROV_NAMES_AES_256_WRAP, ossl_aes256wrap_functions), | |
343 | ALG(PROV_NAMES_AES_192_WRAP, ossl_aes192wrap_functions), | |
344 | ALG(PROV_NAMES_AES_128_WRAP, ossl_aes128wrap_functions), | |
345 | ALG(PROV_NAMES_AES_256_WRAP_PAD, ossl_aes256wrappad_functions), | |
346 | ALG(PROV_NAMES_AES_192_WRAP_PAD, ossl_aes192wrappad_functions), | |
347 | ALG(PROV_NAMES_AES_128_WRAP_PAD, ossl_aes128wrappad_functions), | |
348 | ALG(PROV_NAMES_AES_256_WRAP_INV, ossl_aes256wrapinv_functions), | |
349 | ALG(PROV_NAMES_AES_192_WRAP_INV, ossl_aes192wrapinv_functions), | |
350 | ALG(PROV_NAMES_AES_128_WRAP_INV, ossl_aes128wrapinv_functions), | |
351 | ALG(PROV_NAMES_AES_256_WRAP_PAD_INV, ossl_aes256wrappadinv_functions), | |
352 | ALG(PROV_NAMES_AES_192_WRAP_PAD_INV, ossl_aes192wrappadinv_functions), | |
353 | ALG(PROV_NAMES_AES_128_WRAP_PAD_INV, ossl_aes128wrappadinv_functions), | |
354 | ALGC(PROV_NAMES_AES_128_CBC_HMAC_SHA1, ossl_aes128cbc_hmac_sha1_functions, | |
592dcfd3 | 355 | ossl_cipher_capable_aes_cbc_hmac_sha1), |
e2f5df36 | 356 | ALGC(PROV_NAMES_AES_256_CBC_HMAC_SHA1, ossl_aes256cbc_hmac_sha1_functions, |
592dcfd3 | 357 | ossl_cipher_capable_aes_cbc_hmac_sha1), |
e2f5df36 | 358 | ALGC(PROV_NAMES_AES_128_CBC_HMAC_SHA256, ossl_aes128cbc_hmac_sha256_functions, |
592dcfd3 | 359 | ossl_cipher_capable_aes_cbc_hmac_sha256), |
e2f5df36 | 360 | ALGC(PROV_NAMES_AES_256_CBC_HMAC_SHA256, ossl_aes256cbc_hmac_sha256_functions, |
592dcfd3 | 361 | ossl_cipher_capable_aes_cbc_hmac_sha256), |
a0ea8ac1 P |
362 | #ifndef OPENSSL_NO_DES |
363 | UNAPPROVED_ALG(PROV_NAMES_DES_EDE3_ECB, ossl_tdes_ede3_ecb_functions), | |
364 | UNAPPROVED_ALG(PROV_NAMES_DES_EDE3_CBC, ossl_tdes_ede3_cbc_functions), | |
365 | #endif /* OPENSSL_NO_DES */ | |
0d2bfe52 | 366 | { { NULL, NULL, NULL }, NULL } |
66ad63e8 | 367 | }; |
0d2bfe52 | 368 | static OSSL_ALGORITHM exported_fips_ciphers[OSSL_NELEM(fips_ciphers)]; |
66ad63e8 | 369 | |
2e5db6ad | 370 | static const OSSL_ALGORITHM fips_macs[] = { |
b1c21b27 | 371 | #ifndef OPENSSL_NO_CMAC |
e2f5df36 | 372 | { PROV_NAMES_CMAC, FIPS_DEFAULT_PROPERTIES, ossl_cmac_functions }, |
b1c21b27 | 373 | #endif |
e2f5df36 RL |
374 | { PROV_NAMES_GMAC, FIPS_DEFAULT_PROPERTIES, ossl_gmac_functions }, |
375 | { PROV_NAMES_HMAC, FIPS_DEFAULT_PROPERTIES, ossl_hmac_functions }, | |
376 | { PROV_NAMES_KMAC_128, FIPS_DEFAULT_PROPERTIES, ossl_kmac128_functions }, | |
377 | { PROV_NAMES_KMAC_256, FIPS_DEFAULT_PROPERTIES, ossl_kmac256_functions }, | |
2e5db6ad RL |
378 | { NULL, NULL, NULL } |
379 | }; | |
380 | ||
e3405a4a | 381 | static const OSSL_ALGORITHM fips_kdfs[] = { |
e2f5df36 | 382 | { PROV_NAMES_HKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_hkdf_functions }, |
736dba01 P |
383 | { PROV_NAMES_TLS1_3_KDF, FIPS_DEFAULT_PROPERTIES, |
384 | ossl_kdf_tls1_3_kdf_functions }, | |
e2f5df36 RL |
385 | { PROV_NAMES_SSKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_sskdf_functions }, |
386 | { PROV_NAMES_PBKDF2, FIPS_DEFAULT_PROPERTIES, ossl_kdf_pbkdf2_functions }, | |
387 | { PROV_NAMES_SSHKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_sshkdf_functions }, | |
388 | { PROV_NAMES_X963KDF, FIPS_DEFAULT_PROPERTIES, | |
89cccbea | 389 | ossl_kdf_x963_kdf_functions }, |
e2f5df36 | 390 | { PROV_NAMES_X942KDF_ASN1, FIPS_DEFAULT_PROPERTIES, |
89cccbea | 391 | ossl_kdf_x942_kdf_functions }, |
e2f5df36 RL |
392 | { PROV_NAMES_TLS1_PRF, FIPS_DEFAULT_PROPERTIES, |
393 | ossl_kdf_tls1_prf_functions }, | |
394 | { PROV_NAMES_KBKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_kbkdf_functions }, | |
df553b79 | 395 | { NULL, NULL, NULL } |
e3405a4a P |
396 | }; |
397 | ||
bcc4ae67 | 398 | static const OSSL_ALGORITHM fips_rands[] = { |
e2f5df36 RL |
399 | { PROV_NAMES_CTR_DRBG, FIPS_DEFAULT_PROPERTIES, ossl_drbg_ctr_functions }, |
400 | { PROV_NAMES_HASH_DRBG, FIPS_DEFAULT_PROPERTIES, ossl_drbg_hash_functions }, | |
401 | { PROV_NAMES_HMAC_DRBG, FIPS_DEFAULT_PROPERTIES, ossl_drbg_ossl_hmac_functions }, | |
402 | { PROV_NAMES_TEST_RAND, FIPS_UNAPPROVED_PROPERTIES, ossl_test_rng_functions }, | |
bcc4ae67 P |
403 | { NULL, NULL, NULL } |
404 | }; | |
405 | ||
62f49b90 SL |
406 | static const OSSL_ALGORITHM fips_keyexch[] = { |
407 | #ifndef OPENSSL_NO_DH | |
e2f5df36 | 408 | { PROV_NAMES_DH, FIPS_DEFAULT_PROPERTIES, ossl_dh_keyexch_functions }, |
1c725f46 SL |
409 | #endif |
410 | #ifndef OPENSSL_NO_EC | |
e2f5df36 | 411 | { PROV_NAMES_ECDH, FIPS_DEFAULT_PROPERTIES, ossl_ecdh_keyexch_functions }, |
4032cd9a | 412 | # ifndef OPENSSL_NO_ECX |
8948b574 P |
413 | { PROV_NAMES_X25519, FIPS_DEFAULT_PROPERTIES, ossl_x25519_keyexch_functions }, |
414 | { PROV_NAMES_X448, FIPS_DEFAULT_PROPERTIES, ossl_x448_keyexch_functions }, | |
4032cd9a | 415 | # endif |
62f49b90 | 416 | #endif |
e2f5df36 | 417 | { PROV_NAMES_TLS1_PRF, FIPS_DEFAULT_PROPERTIES, |
1be63951 | 418 | ossl_kdf_tls1_prf_keyexch_functions }, |
e2f5df36 | 419 | { PROV_NAMES_HKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_hkdf_keyexch_functions }, |
62f49b90 SL |
420 | { NULL, NULL, NULL } |
421 | }; | |
422 | ||
e683582b SL |
423 | static const OSSL_ALGORITHM fips_signature[] = { |
424 | #ifndef OPENSSL_NO_DSA | |
e2f5df36 | 425 | { PROV_NAMES_DSA, FIPS_DEFAULT_PROPERTIES, ossl_dsa_signature_functions }, |
e683582b | 426 | #endif |
e2f5df36 | 427 | { PROV_NAMES_RSA, FIPS_DEFAULT_PROPERTIES, ossl_rsa_signature_functions }, |
edd3b7a3 | 428 | #ifndef OPENSSL_NO_EC |
4032cd9a | 429 | # ifndef OPENSSL_NO_ECX |
759ab598 | 430 | { PROV_NAMES_ED25519, FIPS_UNAPPROVED_PROPERTIES, |
9fa55324 | 431 | ossl_ed25519_signature_functions }, |
759ab598 | 432 | { PROV_NAMES_ED448, FIPS_UNAPPROVED_PROPERTIES, ossl_ed448_signature_functions }, |
4032cd9a | 433 | # endif |
e2f5df36 | 434 | { PROV_NAMES_ECDSA, FIPS_DEFAULT_PROPERTIES, ossl_ecdsa_signature_functions }, |
edd3b7a3 | 435 | #endif |
e2f5df36 | 436 | { PROV_NAMES_HMAC, FIPS_DEFAULT_PROPERTIES, |
1be63951 | 437 | ossl_mac_legacy_hmac_signature_functions }, |
a540ef90 | 438 | #ifndef OPENSSL_NO_CMAC |
e2f5df36 | 439 | { PROV_NAMES_CMAC, FIPS_DEFAULT_PROPERTIES, |
1be63951 | 440 | ossl_mac_legacy_cmac_signature_functions }, |
a540ef90 | 441 | #endif |
e683582b SL |
442 | { NULL, NULL, NULL } |
443 | }; | |
444 | ||
afb638f1 | 445 | static const OSSL_ALGORITHM fips_asym_cipher[] = { |
e2f5df36 | 446 | { PROV_NAMES_RSA, FIPS_DEFAULT_PROPERTIES, ossl_rsa_asym_cipher_functions }, |
afb638f1 MC |
447 | { NULL, NULL, NULL } |
448 | }; | |
449 | ||
80f4fd18 | 450 | static const OSSL_ALGORITHM fips_asym_kem[] = { |
e2f5df36 | 451 | { PROV_NAMES_RSA, FIPS_DEFAULT_PROPERTIES, ossl_rsa_asym_kem_functions }, |
80f4fd18 SL |
452 | { NULL, NULL, NULL } |
453 | }; | |
454 | ||
e683582b | 455 | static const OSSL_ALGORITHM fips_keymgmt[] = { |
62f49b90 | 456 | #ifndef OPENSSL_NO_DH |
e2f5df36 RL |
457 | { PROV_NAMES_DH, FIPS_DEFAULT_PROPERTIES, ossl_dh_keymgmt_functions, |
458 | PROV_DESCS_DH }, | |
459 | { PROV_NAMES_DHX, FIPS_DEFAULT_PROPERTIES, ossl_dhx_keymgmt_functions, | |
460 | PROV_DESCS_DHX }, | |
62f49b90 | 461 | #endif |
e683582b | 462 | #ifndef OPENSSL_NO_DSA |
e2f5df36 RL |
463 | { PROV_NAMES_DSA, FIPS_DEFAULT_PROPERTIES, ossl_dsa_keymgmt_functions, |
464 | PROV_DESCS_DSA }, | |
e683582b | 465 | #endif |
e2f5df36 RL |
466 | { PROV_NAMES_RSA, FIPS_DEFAULT_PROPERTIES, ossl_rsa_keymgmt_functions, |
467 | PROV_DESCS_RSA }, | |
468 | { PROV_NAMES_RSA_PSS, FIPS_DEFAULT_PROPERTIES, | |
469 | ossl_rsapss_keymgmt_functions, PROV_DESCS_RSA_PSS }, | |
1c725f46 | 470 | #ifndef OPENSSL_NO_EC |
e2f5df36 RL |
471 | { PROV_NAMES_EC, FIPS_DEFAULT_PROPERTIES, ossl_ec_keymgmt_functions, |
472 | PROV_DESCS_EC }, | |
4032cd9a | 473 | # ifndef OPENSSL_NO_ECX |
8948b574 | 474 | { PROV_NAMES_X25519, FIPS_DEFAULT_PROPERTIES, ossl_x25519_keymgmt_functions, |
e2f5df36 | 475 | PROV_DESCS_X25519 }, |
8948b574 | 476 | { PROV_NAMES_X448, FIPS_DEFAULT_PROPERTIES, ossl_x448_keymgmt_functions, |
e2f5df36 | 477 | PROV_DESCS_X448 }, |
759ab598 | 478 | { PROV_NAMES_ED25519, FIPS_UNAPPROVED_PROPERTIES, ossl_ed25519_keymgmt_functions, |
e2f5df36 | 479 | PROV_DESCS_ED25519 }, |
759ab598 | 480 | { PROV_NAMES_ED448, FIPS_UNAPPROVED_PROPERTIES, ossl_ed448_keymgmt_functions, |
e2f5df36 | 481 | PROV_DESCS_ED448 }, |
4032cd9a | 482 | # endif |
1c725f46 | 483 | #endif |
e2f5df36 RL |
484 | { PROV_NAMES_TLS1_PRF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_keymgmt_functions, |
485 | PROV_DESCS_TLS1_PRF_SIGN }, | |
486 | { PROV_NAMES_HKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_keymgmt_functions, | |
487 | PROV_DESCS_HKDF_SIGN }, | |
488 | { PROV_NAMES_HMAC, FIPS_DEFAULT_PROPERTIES, ossl_mac_legacy_keymgmt_functions, | |
489 | PROV_DESCS_HMAC_SIGN }, | |
a540ef90 | 490 | #ifndef OPENSSL_NO_CMAC |
e2f5df36 RL |
491 | { PROV_NAMES_CMAC, FIPS_DEFAULT_PROPERTIES, |
492 | ossl_cmac_legacy_keymgmt_functions, PROV_DESCS_CMAC_SIGN }, | |
a540ef90 | 493 | #endif |
e683582b SL |
494 | { NULL, NULL, NULL } |
495 | }; | |
0d2bfe52 | 496 | |
fdaad3f1 RL |
497 | static const OSSL_ALGORITHM *fips_query(void *provctx, int operation_id, |
498 | int *no_cache) | |
9efa0ae0 MC |
499 | { |
500 | *no_cache = 0; | |
04cb5ec0 | 501 | |
6cf37302 | 502 | if (!ossl_prov_is_running()) |
04cb5ec0 SL |
503 | return NULL; |
504 | ||
9efa0ae0 MC |
505 | switch (operation_id) { |
506 | case OSSL_OP_DIGEST: | |
507 | return fips_digests; | |
66ad63e8 | 508 | case OSSL_OP_CIPHER: |
0d2bfe52 | 509 | return exported_fips_ciphers; |
2e5db6ad RL |
510 | case OSSL_OP_MAC: |
511 | return fips_macs; | |
e3405a4a P |
512 | case OSSL_OP_KDF: |
513 | return fips_kdfs; | |
bcc4ae67 P |
514 | case OSSL_OP_RAND: |
515 | return fips_rands; | |
e683582b SL |
516 | case OSSL_OP_KEYMGMT: |
517 | return fips_keymgmt; | |
62f49b90 SL |
518 | case OSSL_OP_KEYEXCH: |
519 | return fips_keyexch; | |
e683582b SL |
520 | case OSSL_OP_SIGNATURE: |
521 | return fips_signature; | |
afb638f1 MC |
522 | case OSSL_OP_ASYM_CIPHER: |
523 | return fips_asym_cipher; | |
80f4fd18 SL |
524 | case OSSL_OP_KEM: |
525 | return fips_asym_kem; | |
9efa0ae0 MC |
526 | } |
527 | return NULL; | |
528 | } | |
529 | ||
fdaad3f1 RL |
530 | static void fips_teardown(void *provctx) |
531 | { | |
a829b735 | 532 | OSSL_LIB_CTX_free(PROV_LIBCTX_OF(provctx)); |
7d6766cb | 533 | ossl_prov_ctx_free(provctx); |
78906fff RL |
534 | } |
535 | ||
536 | static void fips_intern_teardown(void *provctx) | |
537 | { | |
538 | /* | |
539 | * We know that the library context is the same as for the outer provider, | |
540 | * so no need to destroy it here. | |
541 | */ | |
7d6766cb | 542 | ossl_prov_ctx_free(provctx); |
fdaad3f1 RL |
543 | } |
544 | ||
9efa0ae0 MC |
545 | /* Functions we provide to the core */ |
546 | static const OSSL_DISPATCH fips_dispatch_table[] = { | |
fdaad3f1 | 547 | { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))fips_teardown }, |
dca97d00 | 548 | { OSSL_FUNC_PROVIDER_GETTABLE_PARAMS, (void (*)(void))fips_gettable_params }, |
9efa0ae0 MC |
549 | { OSSL_FUNC_PROVIDER_GET_PARAMS, (void (*)(void))fips_get_params }, |
550 | { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query }, | |
04cb5ec0 | 551 | { OSSL_FUNC_PROVIDER_GET_CAPABILITIES, |
c8830891 | 552 | (void (*)(void))ossl_prov_get_capabilities }, |
04cb5ec0 | 553 | { OSSL_FUNC_PROVIDER_SELF_TEST, (void (*)(void))fips_self_test }, |
1e6bd31e | 554 | OSSL_DISPATCH_END |
9efa0ae0 MC |
555 | }; |
556 | ||
319e518a MC |
557 | /* Functions we provide to ourself */ |
558 | static const OSSL_DISPATCH intern_dispatch_table[] = { | |
78906fff | 559 | { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))fips_intern_teardown }, |
319e518a | 560 | { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query }, |
1e6bd31e | 561 | OSSL_DISPATCH_END |
319e518a MC |
562 | }; |
563 | ||
b9385449 RL |
564 | /* |
565 | * On VMS, the provider init function name is expected to be uppercase, | |
566 | * see the pragmas in <openssl/core.h>. Let's do the same with this | |
567 | * internal name. This is how symbol names are treated by default | |
568 | * by the compiler if nothing else is said, but since this is part | |
569 | * of libfips, and we build our libraries with mixed case symbol names, | |
570 | * we must switch back to this default explicitly here. | |
571 | */ | |
572 | #ifdef __VMS | |
573 | # pragma names save | |
574 | # pragma names uppercase,truncated | |
575 | #endif | |
576 | OSSL_provider_init_fn OSSL_provider_init_int; | |
577 | #ifdef __VMS | |
578 | # pragma names restore | |
579 | #endif | |
580 | int OSSL_provider_init_int(const OSSL_CORE_HANDLE *handle, | |
581 | const OSSL_DISPATCH *in, | |
582 | const OSSL_DISPATCH **out, | |
583 | void **provctx) | |
9efa0ae0 | 584 | { |
da747958 | 585 | FIPS_GLOBAL *fgbl; |
b4250010 | 586 | OSSL_LIB_CTX *libctx = NULL; |
6ce58488 MC |
587 | SELF_TEST_POST_PARAMS selftest_params; |
588 | ||
589 | memset(&selftest_params, 0, sizeof(selftest_params)); | |
319e518a | 590 | |
08edd447 | 591 | if (!ossl_prov_seeding_from_dispatch(in)) |
26ccb0e4 | 592 | goto err; |
9efa0ae0 | 593 | for (; in->function_id != 0; in++) { |
7b9f0279 MC |
594 | /* |
595 | * We do not support the scenario of an application linked against | |
596 | * multiple versions of libcrypto (e.g. one static and one dynamic), but | |
597 | * sharing a single fips.so. We do a simple sanity check here. | |
598 | */ | |
599 | #define set_func(c, f) if (c == NULL) c = f; else if (c != f) return 0; | |
9efa0ae0 | 600 | switch (in->function_id) { |
a829b735 | 601 | case OSSL_FUNC_CORE_GET_LIBCTX: |
7b9f0279 | 602 | set_func(c_get_libctx, OSSL_FUNC_core_get_libctx(in)); |
36fc5fc6 | 603 | break; |
dca97d00 | 604 | case OSSL_FUNC_CORE_GETTABLE_PARAMS: |
7b9f0279 | 605 | set_func(c_gettable_params, OSSL_FUNC_core_gettable_params(in)); |
9efa0ae0 MC |
606 | break; |
607 | case OSSL_FUNC_CORE_GET_PARAMS: | |
7b9f0279 | 608 | set_func(c_get_params, OSSL_FUNC_core_get_params(in)); |
9efa0ae0 | 609 | break; |
da747958 | 610 | case OSSL_FUNC_CORE_THREAD_START: |
7b9f0279 | 611 | set_func(c_thread_start, OSSL_FUNC_core_thread_start(in)); |
da747958 | 612 | break; |
036913b1 | 613 | case OSSL_FUNC_CORE_NEW_ERROR: |
7b9f0279 | 614 | set_func(c_new_error, OSSL_FUNC_core_new_error(in)); |
3593266d | 615 | break; |
036913b1 | 616 | case OSSL_FUNC_CORE_SET_ERROR_DEBUG: |
7b9f0279 | 617 | set_func(c_set_error_debug, OSSL_FUNC_core_set_error_debug(in)); |
036913b1 RL |
618 | break; |
619 | case OSSL_FUNC_CORE_VSET_ERROR: | |
7b9f0279 | 620 | set_func(c_vset_error, OSSL_FUNC_core_vset_error(in)); |
3593266d | 621 | break; |
7b131de2 | 622 | case OSSL_FUNC_CORE_SET_ERROR_MARK: |
7b9f0279 | 623 | set_func(c_set_error_mark, OSSL_FUNC_core_set_error_mark(in)); |
7b131de2 RL |
624 | break; |
625 | case OSSL_FUNC_CORE_CLEAR_LAST_ERROR_MARK: | |
7b9f0279 MC |
626 | set_func(c_clear_last_error_mark, |
627 | OSSL_FUNC_core_clear_last_error_mark(in)); | |
7b131de2 RL |
628 | break; |
629 | case OSSL_FUNC_CORE_POP_ERROR_TO_MARK: | |
7b9f0279 | 630 | set_func(c_pop_error_to_mark, OSSL_FUNC_core_pop_error_to_mark(in)); |
7b131de2 | 631 | break; |
b60cba3c | 632 | case OSSL_FUNC_CRYPTO_MALLOC: |
7b9f0279 | 633 | set_func(c_CRYPTO_malloc, OSSL_FUNC_CRYPTO_malloc(in)); |
b60cba3c RS |
634 | break; |
635 | case OSSL_FUNC_CRYPTO_ZALLOC: | |
7b9f0279 | 636 | set_func(c_CRYPTO_zalloc, OSSL_FUNC_CRYPTO_zalloc(in)); |
b60cba3c | 637 | break; |
b60cba3c | 638 | case OSSL_FUNC_CRYPTO_FREE: |
7b9f0279 | 639 | set_func(c_CRYPTO_free, OSSL_FUNC_CRYPTO_free(in)); |
b60cba3c RS |
640 | break; |
641 | case OSSL_FUNC_CRYPTO_CLEAR_FREE: | |
7b9f0279 | 642 | set_func(c_CRYPTO_clear_free, OSSL_FUNC_CRYPTO_clear_free(in)); |
b60cba3c RS |
643 | break; |
644 | case OSSL_FUNC_CRYPTO_REALLOC: | |
7b9f0279 | 645 | set_func(c_CRYPTO_realloc, OSSL_FUNC_CRYPTO_realloc(in)); |
b60cba3c RS |
646 | break; |
647 | case OSSL_FUNC_CRYPTO_CLEAR_REALLOC: | |
7b9f0279 MC |
648 | set_func(c_CRYPTO_clear_realloc, |
649 | OSSL_FUNC_CRYPTO_clear_realloc(in)); | |
b60cba3c RS |
650 | break; |
651 | case OSSL_FUNC_CRYPTO_SECURE_MALLOC: | |
7b9f0279 MC |
652 | set_func(c_CRYPTO_secure_malloc, |
653 | OSSL_FUNC_CRYPTO_secure_malloc(in)); | |
b60cba3c RS |
654 | break; |
655 | case OSSL_FUNC_CRYPTO_SECURE_ZALLOC: | |
7b9f0279 MC |
656 | set_func(c_CRYPTO_secure_zalloc, |
657 | OSSL_FUNC_CRYPTO_secure_zalloc(in)); | |
b60cba3c RS |
658 | break; |
659 | case OSSL_FUNC_CRYPTO_SECURE_FREE: | |
7b9f0279 MC |
660 | set_func(c_CRYPTO_secure_free, |
661 | OSSL_FUNC_CRYPTO_secure_free(in)); | |
b60cba3c RS |
662 | break; |
663 | case OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE: | |
7b9f0279 MC |
664 | set_func(c_CRYPTO_secure_clear_free, |
665 | OSSL_FUNC_CRYPTO_secure_clear_free(in)); | |
b60cba3c RS |
666 | break; |
667 | case OSSL_FUNC_CRYPTO_SECURE_ALLOCATED: | |
7b9f0279 MC |
668 | set_func(c_CRYPTO_secure_allocated, |
669 | OSSL_FUNC_CRYPTO_secure_allocated(in)); | |
b60cba3c | 670 | break; |
25e60144 | 671 | case OSSL_FUNC_BIO_NEW_FILE: |
7b9f0279 MC |
672 | set_func(selftest_params.bio_new_file_cb, |
673 | OSSL_FUNC_BIO_new_file(in)); | |
25e60144 SL |
674 | break; |
675 | case OSSL_FUNC_BIO_NEW_MEMBUF: | |
7b9f0279 MC |
676 | set_func(selftest_params.bio_new_buffer_cb, |
677 | OSSL_FUNC_BIO_new_membuf(in)); | |
25e60144 | 678 | break; |
7bb82f92 | 679 | case OSSL_FUNC_BIO_READ_EX: |
7b9f0279 MC |
680 | set_func(selftest_params.bio_read_ex_cb, |
681 | OSSL_FUNC_BIO_read_ex(in)); | |
25e60144 SL |
682 | break; |
683 | case OSSL_FUNC_BIO_FREE: | |
7b9f0279 | 684 | set_func(selftest_params.bio_free_cb, OSSL_FUNC_BIO_free(in)); |
25e60144 | 685 | break; |
d16d0b71 | 686 | case OSSL_FUNC_BIO_VSNPRINTF: |
7b9f0279 | 687 | set_func(c_BIO_vsnprintf, OSSL_FUNC_BIO_vsnprintf(in)); |
d16d0b71 | 688 | break; |
08edd447 | 689 | case OSSL_FUNC_SELF_TEST_CB: |
7b9f0279 | 690 | set_func(c_stcbfn, OSSL_FUNC_self_test_cb(in)); |
36fc5fc6 | 691 | break; |
9efa0ae0 | 692 | default: |
b60cba3c | 693 | /* Just ignore anything we don't understand */ |
9efa0ae0 MC |
694 | break; |
695 | } | |
696 | } | |
697 | ||
b60cba3c | 698 | /* Create a context. */ |
7d6766cb | 699 | if ((*provctx = ossl_prov_ctx_new()) == NULL |
b4250010 | 700 | || (libctx = OSSL_LIB_CTX_new()) == NULL) { |
78906fff RL |
701 | /* |
702 | * We free libctx separately here and only here because it hasn't | |
703 | * been attached to *provctx. All other error paths below rely | |
704 | * solely on fips_teardown. | |
705 | */ | |
b4250010 | 706 | OSSL_LIB_CTX_free(libctx); |
78906fff RL |
707 | goto err; |
708 | } | |
fdaad3f1 | 709 | |
927d0566 | 710 | if ((fgbl = ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_FIPS_PROV_INDEX)) == NULL) |
fdaad3f1 | 711 | goto err; |
7bb82f92 | 712 | |
d40b42ab | 713 | fgbl->handle = handle; |
7bb82f92 | 714 | |
6ce58488 MC |
715 | /* |
716 | * We did initial set up of selftest_params in a local copy, because we | |
717 | * could not create fgbl until c_CRYPTO_zalloc was defined in the loop | |
718 | * above. | |
719 | */ | |
720 | fgbl->selftest_params = selftest_params; | |
721 | ||
722 | fgbl->selftest_params.libctx = libctx; | |
723 | ||
724 | set_self_test_cb(fgbl); | |
725 | ||
726 | if (!fips_get_params_from_core(fgbl)) { | |
727 | /* Error already raised */ | |
dea76175 | 728 | goto err; |
6ce58488 MC |
729 | } |
730 | /* | |
6d418dbc DB |
731 | * Disable the conditional error check if it's disabled in the fips config |
732 | * file. | |
6ce58488 MC |
733 | */ |
734 | if (fgbl->selftest_params.conditional_error_check != NULL | |
735 | && strcmp(fgbl->selftest_params.conditional_error_check, "0") == 0) | |
736 | SELF_TEST_disable_conditional_error_state(); | |
737 | ||
83ccf81b P |
738 | /* Enable or disable FIPS provider options */ |
739 | #define FIPS_SET_OPTION(fgbl, field) \ | |
740 | if (fgbl->field.option != NULL) { \ | |
741 | if (strcmp(fgbl->field.option, "1") == 0) \ | |
742 | fgbl->field.enabled = 1; \ | |
743 | else if (strcmp(fgbl->field.option, "0") == 0) \ | |
744 | fgbl->field.enabled = 0; \ | |
745 | else \ | |
746 | goto err; \ | |
747 | } | |
6ce58488 | 748 | |
83ccf81b P |
749 | FIPS_SET_OPTION(fgbl, fips_security_checks); |
750 | FIPS_SET_OPTION(fgbl, fips_tls1_prf_ems_check); | |
751 | FIPS_SET_OPTION(fgbl, fips_restricted_drgb_digests); | |
752 | #undef FIPS_SET_OPTION | |
50ea5cdc | 753 | |
b233ea82 MC |
754 | ossl_prov_cache_exported_algorithms(fips_ciphers, exported_fips_ciphers); |
755 | ||
6ce58488 | 756 | if (!SELF_TEST_post(&fgbl->selftest_params, 0)) { |
9f7bdcf3 | 757 | ERR_raise(ERR_LIB_PROV, PROV_R_SELF_TEST_POST_FAILURE); |
fdaad3f1 | 758 | goto err; |
9f7bdcf3 | 759 | } |
7bb82f92 | 760 | |
43dbe3b7 P |
761 | ossl_prov_ctx_set0_libctx(*provctx, libctx); |
762 | ossl_prov_ctx_set0_handle(*provctx, handle); | |
763 | ||
e683582b | 764 | *out = fips_dispatch_table; |
9efa0ae0 | 765 | return 1; |
fdaad3f1 RL |
766 | err: |
767 | fips_teardown(*provctx); | |
09f38299 | 768 | OSSL_LIB_CTX_free(libctx); |
fdaad3f1 RL |
769 | *provctx = NULL; |
770 | return 0; | |
9efa0ae0 | 771 | } |
3593266d | 772 | |
319e518a MC |
773 | /* |
774 | * The internal init function used when the FIPS module uses EVP to call | |
b1eb3fd7 | 775 | * another algorithm also in the FIPS module. This is a recursive call that has |
bb751e11 RL |
776 | * been made from within the FIPS module itself. To make this work, we populate |
777 | * the provider context of this inner instance with the same library context | |
778 | * that was used in the EVP call that initiated this recursive call. | |
319e518a | 779 | */ |
c8830891 SL |
780 | OSSL_provider_init_fn ossl_fips_intern_provider_init; |
781 | int ossl_fips_intern_provider_init(const OSSL_CORE_HANDLE *handle, | |
782 | const OSSL_DISPATCH *in, | |
783 | const OSSL_DISPATCH **out, | |
784 | void **provctx) | |
3593266d | 785 | { |
a829b735 | 786 | OSSL_FUNC_core_get_libctx_fn *c_internal_get_libctx = NULL; |
bb751e11 RL |
787 | |
788 | for (; in->function_id != 0; in++) { | |
789 | switch (in->function_id) { | |
a829b735 DMSP |
790 | case OSSL_FUNC_CORE_GET_LIBCTX: |
791 | c_internal_get_libctx = OSSL_FUNC_core_get_libctx(in); | |
bb751e11 RL |
792 | break; |
793 | default: | |
794 | break; | |
795 | } | |
796 | } | |
797 | ||
04cb5ec0 | 798 | if (c_internal_get_libctx == NULL) |
bb751e11 RL |
799 | return 0; |
800 | ||
7d6766cb | 801 | if ((*provctx = ossl_prov_ctx_new()) == NULL) |
bb751e11 | 802 | return 0; |
04cb5ec0 | 803 | |
d40b42ab MC |
804 | /* |
805 | * Using the parent library context only works because we are a built-in | |
806 | * internal provider. This is not something that most providers would be | |
807 | * able to do. | |
808 | */ | |
a829b735 DMSP |
809 | ossl_prov_ctx_set0_libctx(*provctx, |
810 | (OSSL_LIB_CTX *)c_internal_get_libctx(handle)); | |
7d6766cb | 811 | ossl_prov_ctx_set0_handle(*provctx, handle); |
bb751e11 | 812 | |
319e518a | 813 | *out = intern_dispatch_table; |
3593266d MC |
814 | return 1; |
815 | } | |
816 | ||
036913b1 | 817 | void ERR_new(void) |
3593266d | 818 | { |
036913b1 RL |
819 | c_new_error(NULL); |
820 | } | |
821 | ||
822 | void ERR_set_debug(const char *file, int line, const char *func) | |
823 | { | |
824 | c_set_error_debug(NULL, file, line, func); | |
3593266d MC |
825 | } |
826 | ||
036913b1 | 827 | void ERR_set_error(int lib, int reason, const char *fmt, ...) |
3593266d MC |
828 | { |
829 | va_list args; | |
8908d18c | 830 | |
036913b1 RL |
831 | va_start(args, fmt); |
832 | c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args); | |
3593266d MC |
833 | va_end(args); |
834 | } | |
835 | ||
036913b1 | 836 | void ERR_vset_error(int lib, int reason, const char *fmt, va_list args) |
3593266d | 837 | { |
036913b1 | 838 | c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args); |
3593266d | 839 | } |
da747958 | 840 | |
7b131de2 RL |
841 | int ERR_set_mark(void) |
842 | { | |
843 | return c_set_error_mark(NULL); | |
844 | } | |
845 | ||
846 | int ERR_clear_last_mark(void) | |
847 | { | |
848 | return c_clear_last_error_mark(NULL); | |
849 | } | |
850 | ||
851 | int ERR_pop_to_mark(void) | |
852 | { | |
853 | return c_pop_error_to_mark(NULL); | |
854 | } | |
855 | ||
fdaad3f1 RL |
856 | /* |
857 | * This must take a library context, since it's called from the depths | |
858 | * of crypto/initthread.c code, where it's (correctly) assumed that the | |
b4250010 | 859 | * passed caller argument is an OSSL_LIB_CTX pointer (since the same routine |
fdaad3f1 | 860 | * is also called from other parts of libcrypto, which all pass around a |
b4250010 | 861 | * OSSL_LIB_CTX pointer) |
fdaad3f1 | 862 | */ |
b4250010 | 863 | const OSSL_CORE_HANDLE *FIPS_get_core_handle(OSSL_LIB_CTX *libctx) |
da747958 | 864 | { |
b4250010 | 865 | FIPS_GLOBAL *fgbl = ossl_lib_ctx_get_data(libctx, |
927d0566 | 866 | OSSL_LIB_CTX_FIPS_PROV_INDEX); |
da747958 MC |
867 | |
868 | if (fgbl == NULL) | |
869 | return NULL; | |
870 | ||
d40b42ab | 871 | return fgbl->handle; |
da747958 | 872 | } |
b60cba3c RS |
873 | |
874 | void *CRYPTO_malloc(size_t num, const char *file, int line) | |
875 | { | |
876 | return c_CRYPTO_malloc(num, file, line); | |
877 | } | |
878 | ||
879 | void *CRYPTO_zalloc(size_t num, const char *file, int line) | |
880 | { | |
881 | return c_CRYPTO_zalloc(num, file, line); | |
882 | } | |
883 | ||
b60cba3c RS |
884 | void CRYPTO_free(void *ptr, const char *file, int line) |
885 | { | |
886 | c_CRYPTO_free(ptr, file, line); | |
887 | } | |
888 | ||
889 | void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line) | |
890 | { | |
891 | c_CRYPTO_clear_free(ptr, num, file, line); | |
892 | } | |
893 | ||
894 | void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line) | |
895 | { | |
896 | return c_CRYPTO_realloc(addr, num, file, line); | |
897 | } | |
898 | ||
899 | void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num, | |
900 | const char *file, int line) | |
901 | { | |
902 | return c_CRYPTO_clear_realloc(addr, old_num, num, file, line); | |
903 | } | |
904 | ||
905 | void *CRYPTO_secure_malloc(size_t num, const char *file, int line) | |
906 | { | |
907 | return c_CRYPTO_secure_malloc(num, file, line); | |
908 | } | |
909 | ||
910 | void *CRYPTO_secure_zalloc(size_t num, const char *file, int line) | |
911 | { | |
912 | return c_CRYPTO_secure_zalloc(num, file, line); | |
913 | } | |
914 | ||
915 | void CRYPTO_secure_free(void *ptr, const char *file, int line) | |
916 | { | |
917 | c_CRYPTO_secure_free(ptr, file, line); | |
918 | } | |
919 | ||
920 | void CRYPTO_secure_clear_free(void *ptr, size_t num, const char *file, int line) | |
921 | { | |
922 | c_CRYPTO_secure_clear_free(ptr, num, file, line); | |
923 | } | |
924 | ||
b60cba3c RS |
925 | int CRYPTO_secure_allocated(const void *ptr) |
926 | { | |
927 | return c_CRYPTO_secure_allocated(ptr); | |
928 | } | |
d16d0b71 SL |
929 | |
930 | int BIO_snprintf(char *buf, size_t n, const char *format, ...) | |
931 | { | |
932 | va_list args; | |
933 | int ret; | |
934 | ||
935 | va_start(args, format); | |
936 | ret = c_BIO_vsnprintf(buf, n, format, args); | |
937 | va_end(args); | |
938 | return ret; | |
939 | } | |
991a6bb5 | 940 | |
83ccf81b | 941 | #define FIPS_FEATURE_CHECK(fname, field) \ |
83ccf81b P |
942 | int fname(OSSL_LIB_CTX *libctx) \ |
943 | { \ | |
944 | FIPS_GLOBAL *fgbl = \ | |
945 | ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_FIPS_PROV_INDEX); \ | |
946 | return fgbl->field.enabled; \ | |
947 | } | |
50ea5cdc | 948 | |
83ccf81b P |
949 | FIPS_FEATURE_CHECK(FIPS_security_check_enabled, fips_security_checks) |
950 | FIPS_FEATURE_CHECK(FIPS_tls_prf_ems_check, fips_tls1_prf_ems_check) | |
951 | FIPS_FEATURE_CHECK(FIPS_restricted_drbg_digests_enabled, | |
952 | fips_restricted_drgb_digests) | |
953 | #undef FIPS_FEATURE_CHECK | |
50ea5cdc | 954 | |
b4250010 | 955 | void OSSL_SELF_TEST_get_callback(OSSL_LIB_CTX *libctx, OSSL_CALLBACK **cb, |
f8e74747 SL |
956 | void **cbarg) |
957 | { | |
6ce58488 | 958 | assert(libctx != NULL); |
f8e74747 SL |
959 | |
960 | if (c_stcbfn != NULL && c_get_libctx != NULL) { | |
961 | /* Get the parent libctx */ | |
962 | c_stcbfn(c_get_libctx(FIPS_get_core_handle(libctx)), cb, cbarg); | |
963 | } else { | |
964 | if (cb != NULL) | |
965 | *cb = NULL; | |
966 | if (cbarg != NULL) | |
967 | *cbarg = NULL; | |
968 | } | |
969 | } |