1 /*
2 * Copyright 2019-2025 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 #include <assert.h>
11 #include <openssl/core_dispatch.h>
12 #include <openssl/core_names.h>
13 #include <openssl/params.h>
14 #include <openssl/fips_names.h>
15 #include <openssl/fipskey.h>
16 #include <openssl/rand.h> /* RAND_get0_public() */
17 #include <openssl/proverr.h>
18 #include <openssl/indicator.h>
19 #include "internal/cryptlib.h"
20 #include "internal/provider.h"
21 #include "prov/implementations.h"
22 #include "prov/names.h"
23 #include "prov/provider_ctx.h"
24 #include "prov/providercommon.h"
25 #include "prov/provider_util.h"
26 #include "prov/seeding.h"
27 #include "internal/nelem.h"
28 #include "self_test.h"
29 #include "crypto/context.h"
30 #include "fipscommon.h"
31 #include "internal/core.h"
32
33 static const char FIPS_DEFAULT_PROPERTIES[] = "provider=fips,fips=yes";
34 static const char FIPS_UNAPPROVED_PROPERTIES[] = "provider=fips,fips=no";
35
36 /*
37 * Forward declarations to ensure that interface functions are correctly
38 * defined.
39 */
40 static OSSL_FUNC_provider_teardown_fn fips_teardown;
41 static OSSL_FUNC_provider_gettable_params_fn fips_gettable_params;
42 static OSSL_FUNC_provider_get_params_fn fips_get_params;
43 static OSSL_FUNC_provider_query_operation_fn fips_query;
44 static OSSL_FUNC_provider_query_operation_fn fips_query_internal;
45 static OSSL_FUNC_provider_random_bytes_fn fips_random_bytes;
46
47 #define ALGC(NAMES, FUNC, CHECK) \
48 { { NAMES, FIPS_DEFAULT_PROPERTIES, FUNC }, CHECK }
49 #define ALG(NAMES, FUNC) ALGC(NAMES, FUNC, NULL)
50
51 extern OSSL_FUNC_core_thread_start_fn *c_thread_start;
52
53 /*
54 * Should these function pointers be stored in the provider side provctx? Could
55 * they ever be different from one init to the next? We assume not for now.
56 */
57
58 /* Functions provided by the core */
59 static OSSL_FUNC_core_gettable_params_fn *c_gettable_params;
60 static OSSL_FUNC_core_get_params_fn *c_get_params;
61 OSSL_FUNC_core_thread_start_fn *c_thread_start;
62 static OSSL_FUNC_core_new_error_fn *c_new_error;
63 static OSSL_FUNC_core_set_error_debug_fn *c_set_error_debug;
64 static OSSL_FUNC_core_vset_error_fn *c_vset_error;
65 static OSSL_FUNC_core_set_error_mark_fn *c_set_error_mark;
66 static OSSL_FUNC_core_clear_last_error_mark_fn *c_clear_last_error_mark;
67 static OSSL_FUNC_core_pop_error_to_mark_fn *c_pop_error_to_mark;
68 static OSSL_FUNC_CRYPTO_malloc_fn *c_CRYPTO_malloc;
69 static OSSL_FUNC_CRYPTO_zalloc_fn *c_CRYPTO_zalloc;
70 static OSSL_FUNC_CRYPTO_free_fn *c_CRYPTO_free;
71 static OSSL_FUNC_CRYPTO_clear_free_fn *c_CRYPTO_clear_free;
72 static OSSL_FUNC_CRYPTO_realloc_fn *c_CRYPTO_realloc;
73 static OSSL_FUNC_CRYPTO_clear_realloc_fn *c_CRYPTO_clear_realloc;
74 static OSSL_FUNC_CRYPTO_secure_malloc_fn *c_CRYPTO_secure_malloc;
75 static OSSL_FUNC_CRYPTO_secure_zalloc_fn *c_CRYPTO_secure_zalloc;
76 static OSSL_FUNC_CRYPTO_secure_free_fn *c_CRYPTO_secure_free;
77 static OSSL_FUNC_CRYPTO_secure_clear_free_fn *c_CRYPTO_secure_clear_free;
78 static OSSL_FUNC_CRYPTO_secure_allocated_fn *c_CRYPTO_secure_allocated;
79 static OSSL_FUNC_BIO_vsnprintf_fn *c_BIO_vsnprintf;
80 static OSSL_FUNC_self_test_cb_fn *c_stcbfn = NULL;
81 static OSSL_FUNC_indicator_cb_fn *c_indcbfn = NULL;
82 static OSSL_FUNC_core_get_libctx_fn *c_get_libctx = NULL;
83
84 typedef struct {
85 const char *option;
86 unsigned char enabled;
87 } FIPS_OPTION;
88
89 typedef struct fips_global_st {
90 const OSSL_CORE_HANDLE *handle;
91 SELF_TEST_POST_PARAMS selftest_params;
92
93 #define OSSL_FIPS_PARAM(structname, paramname, initvalue) \
94 FIPS_OPTION fips_##structname;
95 #include "fips_indicator_params.inc"
96 #undef OSSL_FIPS_PARAM
97
98 } FIPS_GLOBAL;
99
init_fips_option(FIPS_OPTION * opt,int enabled)100 static void init_fips_option(FIPS_OPTION *opt, int enabled)
101 {
102 opt->enabled = enabled;
103 opt->option = enabled ? "1" : "0";
104 }
105
ossl_fips_prov_ossl_ctx_new(OSSL_LIB_CTX * libctx)106 void *ossl_fips_prov_ossl_ctx_new(OSSL_LIB_CTX *libctx)
107 {
108 FIPS_GLOBAL *fgbl = OPENSSL_zalloc(sizeof(*fgbl));
109
110 if (fgbl == NULL)
111 return NULL;
112
113 #define OSSL_FIPS_PARAM(structname, paramname, initvalue) \
114 init_fips_option(&fgbl->fips_##structname, initvalue);
115 #include "fips_indicator_params.inc"
116 #undef OSSL_FIPS_PARAM
117
118 return fgbl;
119 }
120
ossl_fips_prov_ossl_ctx_free(void * fgbl)121 void ossl_fips_prov_ossl_ctx_free(void *fgbl)
122 {
123 OPENSSL_free(fgbl);
124 }
125
fips_random_bytes(ossl_unused void * vprov,int which,void * buf,size_t n,unsigned int strength)126 static int fips_random_bytes(ossl_unused void *vprov, int which,
127 void *buf, size_t n, unsigned int strength)
128 {
129 OSSL_LIB_CTX *libctx;
130 PROV_CTX *prov = (PROV_CTX *)vprov;
131
132 if (prov == NULL)
133 return 0;
134 libctx = ossl_prov_ctx_get0_libctx(prov);
135 if (which == OSSL_PROV_RANDOM_PRIVATE)
136 return RAND_priv_bytes_ex(libctx, buf, n, strength);
137 return RAND_bytes_ex(libctx, buf, n, strength);
138 }
139
140 /*
141 * Parameters to retrieve from the core provider
142 * NOTE: inside core_get_params() these will be loaded from config items
143 * stored inside prov->parameters
144 */
fips_get_params_from_core(FIPS_GLOBAL * fgbl)145 static int fips_get_params_from_core(FIPS_GLOBAL *fgbl)
146 {
147 OSSL_PARAM core_params[32], *p = core_params;
148
149 #define OSSL_FIPS_PARAM(structname, paramname) \
150 *p++ = OSSL_PARAM_construct_utf8_ptr( \
151 paramname, (char **)&fgbl->selftest_params.structname, \
152 sizeof(fgbl->selftest_params.structname));
153
154 /* Parameters required for self testing */
155 #include "fips_selftest_params.inc"
156 #undef OSSL_FIPS_PARAM
157
158 /* FIPS indicator options can be enabled or disabled independently */
159 #define OSSL_FIPS_PARAM(structname, paramname, initvalue) \
160 *p++ = OSSL_PARAM_construct_utf8_ptr( \
161 OSSL_PROV_PARAM_##paramname, \
162 (char **)&fgbl->fips_##structname.option, \
163 sizeof(fgbl->fips_##structname.option));
164 #include "fips_indicator_params.inc"
165 #undef OSSL_FIPS_PARAM
166
167 *p = OSSL_PARAM_construct_end();
168
169 if (!c_get_params(fgbl->handle, core_params)) {
170 ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
171 return 0;
172 }
173
174 return 1;
175 }
176
fips_gettable_params(void * provctx)177 static const OSSL_PARAM *fips_gettable_params(void *provctx)
178 {
179 /* Parameters we provide to the core */
180 static const OSSL_PARAM fips_param_types[] = {
181 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_NAME, OSSL_PARAM_UTF8_PTR, NULL, 0),
182 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_VERSION, OSSL_PARAM_UTF8_PTR, NULL, 0),
183 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_BUILDINFO, OSSL_PARAM_UTF8_PTR, NULL, 0),
184 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_STATUS, OSSL_PARAM_INTEGER, NULL, 0),
185
186 #define OSSL_FIPS_PARAM(structname, paramname, initvalue) \
187 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_##paramname, OSSL_PARAM_INTEGER, NULL, 0),
188 #include "fips_indicator_params.inc"
189 #undef OSSL_FIPS_PARAM
190
191 OSSL_PARAM_END
192 };
193 return fips_param_types;
194 }
195
fips_get_params(void * provctx,OSSL_PARAM params[])196 static int fips_get_params(void *provctx, OSSL_PARAM params[])
197 {
198 OSSL_PARAM *p;
199 FIPS_GLOBAL *fgbl = ossl_lib_ctx_get_data(ossl_prov_ctx_get0_libctx(provctx),
200 OSSL_LIB_CTX_FIPS_PROV_INDEX);
201
202 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME);
203 if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, FIPS_VENDOR))
204 return 0;
205 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_VERSION);
206 if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_VERSION_STR))
207 return 0;
208 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_BUILDINFO);
209 if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_FULL_VERSION_STR))
210 return 0;
211 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_STATUS);
212 if (p != NULL && !OSSL_PARAM_set_int(p, ossl_prov_is_running()))
213 return 0;
214
215 #define OSSL_FIPS_PARAM(structname, paramname, initvalue) \
216 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_##paramname); \
217 if (p != NULL && !OSSL_PARAM_set_int(p, fgbl->fips_##structname.enabled)) \
218 return 0;
219 #include "fips_indicator_params.inc"
220 #undef OSSL_FIPS_PARAM
221
222 return 1;
223 }
224
set_self_test_cb(FIPS_GLOBAL * fgbl)225 static void set_self_test_cb(FIPS_GLOBAL *fgbl)
226 {
227 const OSSL_CORE_HANDLE *handle =
228 FIPS_get_core_handle(fgbl->selftest_params.libctx);
229
230 if (c_stcbfn != NULL && c_get_libctx != NULL) {
231 c_stcbfn(c_get_libctx(handle), &fgbl->selftest_params.cb,
232 &fgbl->selftest_params.cb_arg);
233 } else {
234 fgbl->selftest_params.cb = NULL;
235 fgbl->selftest_params.cb_arg = NULL;
236 }
237 }
238
fips_self_test(void * provctx)239 static int fips_self_test(void *provctx)
240 {
241 FIPS_GLOBAL *fgbl = ossl_lib_ctx_get_data(ossl_prov_ctx_get0_libctx(provctx),
242 OSSL_LIB_CTX_FIPS_PROV_INDEX);
243
244 set_self_test_cb(fgbl);
245 return SELF_TEST_post(&fgbl->selftest_params, 1) ? 1 : 0;
246 }
247
248 /*
249 * For the algorithm names, we use the following formula for our primary
250 * names:
251 *
252 * ALGNAME[VERSION?][-SUBNAME[VERSION?]?][-SIZE?][-MODE?]
253 *
254 * VERSION is only present if there are multiple versions of
255 * an alg (MD2, MD4, MD5). It may be omitted if there is only
256 * one version (if a subsequent version is released in the future,
257 * we can always change the canonical name, and add the old name
258 * as an alias).
259 *
260 * SUBNAME may be present where we are combining multiple
261 * algorithms together, e.g. MD5-SHA1.
262 *
263 * SIZE is only present if multiple versions of an algorithm exist
264 * with different sizes (e.g. AES-128-CBC, AES-256-CBC)
265 *
266 * MODE is only present where applicable.
267 *
268 * We add diverse other names where applicable, such as the names that
269 * NIST uses, or that are used for ASN.1 OBJECT IDENTIFIERs, or names
270 * we have used historically.
271 */
272 static const OSSL_ALGORITHM fips_digests[] = {
273 /* Our primary name:NiST name[:our older names] */
274 { PROV_NAMES_SHA1, FIPS_DEFAULT_PROPERTIES, ossl_sha1_functions },
275 { PROV_NAMES_SHA2_224, FIPS_DEFAULT_PROPERTIES, ossl_sha224_functions },
276 { PROV_NAMES_SHA2_256, FIPS_DEFAULT_PROPERTIES, ossl_sha256_functions },
277 { PROV_NAMES_SHA2_384, FIPS_DEFAULT_PROPERTIES, ossl_sha384_functions },
278 { PROV_NAMES_SHA2_512, FIPS_DEFAULT_PROPERTIES, ossl_sha512_functions },
279 { PROV_NAMES_SHA2_512_224, FIPS_DEFAULT_PROPERTIES,
280 ossl_sha512_224_functions },
281 { PROV_NAMES_SHA2_512_256, FIPS_DEFAULT_PROPERTIES,
282 ossl_sha512_256_functions },
283
284 /* We agree with NIST here, so one name only */
285 { PROV_NAMES_SHA3_224, FIPS_DEFAULT_PROPERTIES, ossl_sha3_224_functions },
286 { PROV_NAMES_SHA3_256, FIPS_DEFAULT_PROPERTIES, ossl_sha3_256_functions },
287 { PROV_NAMES_SHA3_384, FIPS_DEFAULT_PROPERTIES, ossl_sha3_384_functions },
288 { PROV_NAMES_SHA3_512, FIPS_DEFAULT_PROPERTIES, ossl_sha3_512_functions },
289
290 { PROV_NAMES_SHAKE_128, FIPS_DEFAULT_PROPERTIES, ossl_shake_128_functions },
291 { PROV_NAMES_SHAKE_256, FIPS_DEFAULT_PROPERTIES, ossl_shake_256_functions },
292
293 /*
294 * KECCAK-KMAC-128 and KECCAK-KMAC-256 as hashes are mostly useful for
295 * KMAC128 and KMAC256.
296 */
297 { PROV_NAMES_KECCAK_KMAC_128, FIPS_DEFAULT_PROPERTIES,
298 ossl_keccak_kmac_128_functions },
299 { PROV_NAMES_KECCAK_KMAC_256, FIPS_DEFAULT_PROPERTIES,
300 ossl_keccak_kmac_256_functions },
301 { NULL, NULL, NULL }
302 };
303
304 static const OSSL_ALGORITHM_CAPABLE fips_ciphers[] = {
305 /* Our primary name[:ASN.1 OID name][:our older names] */
306 ALG(PROV_NAMES_AES_256_ECB, ossl_aes256ecb_functions),
307 ALG(PROV_NAMES_AES_192_ECB, ossl_aes192ecb_functions),
308 ALG(PROV_NAMES_AES_128_ECB, ossl_aes128ecb_functions),
309 ALG(PROV_NAMES_AES_256_CBC, ossl_aes256cbc_functions),
310 ALG(PROV_NAMES_AES_192_CBC, ossl_aes192cbc_functions),
311 ALG(PROV_NAMES_AES_128_CBC, ossl_aes128cbc_functions),
312 ALG(PROV_NAMES_AES_256_CBC_CTS, ossl_aes256cbc_cts_functions),
313 ALG(PROV_NAMES_AES_192_CBC_CTS, ossl_aes192cbc_cts_functions),
314 ALG(PROV_NAMES_AES_128_CBC_CTS, ossl_aes128cbc_cts_functions),
315 ALG(PROV_NAMES_AES_256_OFB, ossl_aes256ofb_functions),
316 ALG(PROV_NAMES_AES_192_OFB, ossl_aes192ofb_functions),
317 ALG(PROV_NAMES_AES_128_OFB, ossl_aes128ofb_functions),
318 ALG(PROV_NAMES_AES_256_CFB, ossl_aes256cfb_functions),
319 ALG(PROV_NAMES_AES_192_CFB, ossl_aes192cfb_functions),
320 ALG(PROV_NAMES_AES_128_CFB, ossl_aes128cfb_functions),
321 ALG(PROV_NAMES_AES_256_CFB1, ossl_aes256cfb1_functions),
322 ALG(PROV_NAMES_AES_192_CFB1, ossl_aes192cfb1_functions),
323 ALG(PROV_NAMES_AES_128_CFB1, ossl_aes128cfb1_functions),
324 ALG(PROV_NAMES_AES_256_CFB8, ossl_aes256cfb8_functions),
325 ALG(PROV_NAMES_AES_192_CFB8, ossl_aes192cfb8_functions),
326 ALG(PROV_NAMES_AES_128_CFB8, ossl_aes128cfb8_functions),
327 ALG(PROV_NAMES_AES_256_CTR, ossl_aes256ctr_functions),
328 ALG(PROV_NAMES_AES_192_CTR, ossl_aes192ctr_functions),
329 ALG(PROV_NAMES_AES_128_CTR, ossl_aes128ctr_functions),
330 ALG(PROV_NAMES_AES_256_XTS, ossl_aes256xts_functions),
331 ALG(PROV_NAMES_AES_128_XTS, ossl_aes128xts_functions),
332 ALG(PROV_NAMES_AES_256_GCM, ossl_aes256gcm_functions),
333 ALG(PROV_NAMES_AES_192_GCM, ossl_aes192gcm_functions),
334 ALG(PROV_NAMES_AES_128_GCM, ossl_aes128gcm_functions),
335 ALG(PROV_NAMES_AES_256_CCM, ossl_aes256ccm_functions),
336 ALG(PROV_NAMES_AES_192_CCM, ossl_aes192ccm_functions),
337 ALG(PROV_NAMES_AES_128_CCM, ossl_aes128ccm_functions),
338 ALG(PROV_NAMES_AES_256_WRAP, ossl_aes256wrap_functions),
339 ALG(PROV_NAMES_AES_192_WRAP, ossl_aes192wrap_functions),
340 ALG(PROV_NAMES_AES_128_WRAP, ossl_aes128wrap_functions),
341 ALG(PROV_NAMES_AES_256_WRAP_PAD, ossl_aes256wrappad_functions),
342 ALG(PROV_NAMES_AES_192_WRAP_PAD, ossl_aes192wrappad_functions),
343 ALG(PROV_NAMES_AES_128_WRAP_PAD, ossl_aes128wrappad_functions),
344 ALG(PROV_NAMES_AES_256_WRAP_INV, ossl_aes256wrapinv_functions),
345 ALG(PROV_NAMES_AES_192_WRAP_INV, ossl_aes192wrapinv_functions),
346 ALG(PROV_NAMES_AES_128_WRAP_INV, ossl_aes128wrapinv_functions),
347 ALG(PROV_NAMES_AES_256_WRAP_PAD_INV, ossl_aes256wrappadinv_functions),
348 ALG(PROV_NAMES_AES_192_WRAP_PAD_INV, ossl_aes192wrappadinv_functions),
349 ALG(PROV_NAMES_AES_128_WRAP_PAD_INV, ossl_aes128wrappadinv_functions),
350 ALGC(PROV_NAMES_AES_128_CBC_HMAC_SHA1, ossl_aes128cbc_hmac_sha1_functions,
351 ossl_cipher_capable_aes_cbc_hmac_sha1),
352 ALGC(PROV_NAMES_AES_256_CBC_HMAC_SHA1, ossl_aes256cbc_hmac_sha1_functions,
353 ossl_cipher_capable_aes_cbc_hmac_sha1),
354 ALGC(PROV_NAMES_AES_128_CBC_HMAC_SHA256, ossl_aes128cbc_hmac_sha256_functions,
355 ossl_cipher_capable_aes_cbc_hmac_sha256),
356 ALGC(PROV_NAMES_AES_256_CBC_HMAC_SHA256, ossl_aes256cbc_hmac_sha256_functions,
357 ossl_cipher_capable_aes_cbc_hmac_sha256),
358 #ifndef OPENSSL_NO_DES
359 ALG(PROV_NAMES_DES_EDE3_ECB, ossl_tdes_ede3_ecb_functions),
360 ALG(PROV_NAMES_DES_EDE3_CBC, ossl_tdes_ede3_cbc_functions),
361 #endif /* OPENSSL_NO_DES */
362 { { NULL, NULL, NULL }, NULL }
363 };
364 static OSSL_ALGORITHM exported_fips_ciphers[OSSL_NELEM(fips_ciphers)];
365
366 static const OSSL_ALGORITHM fips_macs[] = {
367 #ifndef OPENSSL_NO_CMAC
368 { PROV_NAMES_CMAC, FIPS_DEFAULT_PROPERTIES, ossl_cmac_functions },
369 #endif
370 { PROV_NAMES_GMAC, FIPS_DEFAULT_PROPERTIES, ossl_gmac_functions },
371 { PROV_NAMES_HMAC, FIPS_DEFAULT_PROPERTIES, ossl_hmac_functions },
372 { PROV_NAMES_KMAC_128, FIPS_DEFAULT_PROPERTIES, ossl_kmac128_functions },
373 { PROV_NAMES_KMAC_256, FIPS_DEFAULT_PROPERTIES, ossl_kmac256_functions },
374 { NULL, NULL, NULL }
375 };
376
377 static const OSSL_ALGORITHM fips_macs_internal[] = {
378 #ifndef OPENSSL_NO_CMAC
379 { PROV_NAMES_CMAC, FIPS_DEFAULT_PROPERTIES, ossl_cmac_functions },
380 #endif
381 { PROV_NAMES_HMAC, FIPS_DEFAULT_PROPERTIES, ossl_hmac_internal_functions },
382 { PROV_NAMES_KMAC_128, FIPS_DEFAULT_PROPERTIES, ossl_kmac128_internal_functions },
383 { PROV_NAMES_KMAC_256, FIPS_DEFAULT_PROPERTIES, ossl_kmac256_internal_functions },
384 { NULL, NULL, NULL }
385 };
386
387 static const OSSL_ALGORITHM fips_kdfs[] = {
388 { PROV_NAMES_HKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_hkdf_functions },
389 { PROV_NAMES_TLS1_3_KDF, FIPS_DEFAULT_PROPERTIES,
390 ossl_kdf_tls1_3_kdf_functions },
391 { PROV_NAMES_SSKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_sskdf_functions },
392 { PROV_NAMES_PBKDF2, FIPS_DEFAULT_PROPERTIES, ossl_kdf_pbkdf2_functions },
393 { PROV_NAMES_SSHKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_sshkdf_functions },
394 { PROV_NAMES_X963KDF, FIPS_DEFAULT_PROPERTIES,
395 ossl_kdf_x963_kdf_functions },
396 { PROV_NAMES_X942KDF_ASN1, FIPS_DEFAULT_PROPERTIES,
397 ossl_kdf_x942_kdf_functions },
398 { PROV_NAMES_TLS1_PRF, FIPS_DEFAULT_PROPERTIES,
399 ossl_kdf_tls1_prf_functions },
400 { PROV_NAMES_KBKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_kbkdf_functions },
401 { NULL, NULL, NULL }
402 };
403
404 static const OSSL_ALGORITHM fips_rands[] = {
405 { PROV_NAMES_CRNG_TEST, FIPS_UNAPPROVED_PROPERTIES, ossl_crng_test_functions },
406 { PROV_NAMES_CTR_DRBG, FIPS_DEFAULT_PROPERTIES, ossl_drbg_ctr_functions },
407 { PROV_NAMES_HASH_DRBG, FIPS_DEFAULT_PROPERTIES, ossl_drbg_hash_functions },
408 { PROV_NAMES_HMAC_DRBG, FIPS_DEFAULT_PROPERTIES, ossl_drbg_ossl_hmac_functions },
409 #ifndef OPENSSL_NO_FIPS_JITTER
410 { PROV_NAMES_JITTER, FIPS_DEFAULT_PROPERTIES, ossl_jitter_functions },
411 #endif
412 { PROV_NAMES_TEST_RAND, FIPS_UNAPPROVED_PROPERTIES, ossl_test_rng_functions },
413 { NULL, NULL, NULL }
414 };
415
416 static const OSSL_ALGORITHM fips_keyexch[] = {
417 #ifndef OPENSSL_NO_DH
418 { PROV_NAMES_DH, FIPS_DEFAULT_PROPERTIES, ossl_dh_keyexch_functions },
419 #endif
420 #ifndef OPENSSL_NO_EC
421 { PROV_NAMES_ECDH, FIPS_DEFAULT_PROPERTIES, ossl_ecdh_keyexch_functions },
422 # ifndef OPENSSL_NO_ECX
423 { PROV_NAMES_X25519, FIPS_UNAPPROVED_PROPERTIES, ossl_x25519_keyexch_functions },
424 { PROV_NAMES_X448, FIPS_UNAPPROVED_PROPERTIES, ossl_x448_keyexch_functions },
425 # endif
426 #endif
427 { PROV_NAMES_TLS1_PRF, FIPS_DEFAULT_PROPERTIES,
428 ossl_kdf_tls1_prf_keyexch_functions },
429 { PROV_NAMES_HKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_hkdf_keyexch_functions },
430 { NULL, NULL, NULL }
431 };
432
433 static const OSSL_ALGORITHM fips_signature[] = {
434 #ifndef OPENSSL_NO_DSA
435 { PROV_NAMES_DSA, FIPS_DEFAULT_PROPERTIES, ossl_dsa_signature_functions },
436 { PROV_NAMES_DSA_SHA1, FIPS_DEFAULT_PROPERTIES, ossl_dsa_sha1_signature_functions },
437 { PROV_NAMES_DSA_SHA224, FIPS_DEFAULT_PROPERTIES, ossl_dsa_sha224_signature_functions },
438 { PROV_NAMES_DSA_SHA256, FIPS_DEFAULT_PROPERTIES, ossl_dsa_sha256_signature_functions },
439 { PROV_NAMES_DSA_SHA384, FIPS_DEFAULT_PROPERTIES, ossl_dsa_sha384_signature_functions },
440 { PROV_NAMES_DSA_SHA512, FIPS_DEFAULT_PROPERTIES, ossl_dsa_sha512_signature_functions },
441 { PROV_NAMES_DSA_SHA3_224, FIPS_DEFAULT_PROPERTIES, ossl_dsa_sha3_224_signature_functions },
442 { PROV_NAMES_DSA_SHA3_256, FIPS_DEFAULT_PROPERTIES, ossl_dsa_sha3_256_signature_functions },
443 { PROV_NAMES_DSA_SHA3_384, FIPS_DEFAULT_PROPERTIES, ossl_dsa_sha3_384_signature_functions },
444 { PROV_NAMES_DSA_SHA3_512, FIPS_DEFAULT_PROPERTIES, ossl_dsa_sha3_512_signature_functions },
445 #endif
446 { PROV_NAMES_RSA, FIPS_DEFAULT_PROPERTIES, ossl_rsa_signature_functions },
447 { PROV_NAMES_RSA_SHA1, FIPS_DEFAULT_PROPERTIES,
448 ossl_rsa_sha1_signature_functions },
449 { PROV_NAMES_RSA_SHA224, FIPS_DEFAULT_PROPERTIES,
450 ossl_rsa_sha224_signature_functions },
451 { PROV_NAMES_RSA_SHA256, FIPS_DEFAULT_PROPERTIES,
452 ossl_rsa_sha256_signature_functions },
453 { PROV_NAMES_RSA_SHA384, FIPS_DEFAULT_PROPERTIES,
454 ossl_rsa_sha384_signature_functions },
455 { PROV_NAMES_RSA_SHA512, FIPS_DEFAULT_PROPERTIES,
456 ossl_rsa_sha512_signature_functions },
457 { PROV_NAMES_RSA_SHA512_224, FIPS_DEFAULT_PROPERTIES,
458 ossl_rsa_sha512_224_signature_functions },
459 { PROV_NAMES_RSA_SHA512_256, FIPS_DEFAULT_PROPERTIES,
460 ossl_rsa_sha512_256_signature_functions },
461 { PROV_NAMES_RSA_SHA3_224, FIPS_DEFAULT_PROPERTIES,
462 ossl_rsa_sha3_224_signature_functions },
463 { PROV_NAMES_RSA_SHA3_256, FIPS_DEFAULT_PROPERTIES,
464 ossl_rsa_sha3_256_signature_functions },
465 { PROV_NAMES_RSA_SHA3_384, FIPS_DEFAULT_PROPERTIES,
466 ossl_rsa_sha3_384_signature_functions },
467 { PROV_NAMES_RSA_SHA3_512, FIPS_DEFAULT_PROPERTIES,
468 ossl_rsa_sha3_512_signature_functions },
469 #ifndef OPENSSL_NO_EC
470 # ifndef OPENSSL_NO_ECX
471 { PROV_NAMES_ED25519, FIPS_DEFAULT_PROPERTIES,
472 ossl_ed25519_signature_functions },
473 { PROV_NAMES_ED25519ph, FIPS_DEFAULT_PROPERTIES,
474 ossl_ed25519ph_signature_functions },
475 { PROV_NAMES_ED25519ctx, FIPS_DEFAULT_PROPERTIES,
476 ossl_ed25519ctx_signature_functions },
477 { PROV_NAMES_ED448, FIPS_DEFAULT_PROPERTIES,
478 ossl_ed448_signature_functions },
479 { PROV_NAMES_ED448ph, FIPS_DEFAULT_PROPERTIES,
480 ossl_ed448ph_signature_functions },
481 # endif
482 { PROV_NAMES_ECDSA, FIPS_DEFAULT_PROPERTIES, ossl_ecdsa_signature_functions },
483 { PROV_NAMES_ECDSA_SHA1, FIPS_DEFAULT_PROPERTIES, ossl_ecdsa_sha1_signature_functions },
484 { PROV_NAMES_ECDSA_SHA224, FIPS_DEFAULT_PROPERTIES, ossl_ecdsa_sha224_signature_functions },
485 { PROV_NAMES_ECDSA_SHA256, FIPS_DEFAULT_PROPERTIES, ossl_ecdsa_sha256_signature_functions },
486 { PROV_NAMES_ECDSA_SHA384, FIPS_DEFAULT_PROPERTIES, ossl_ecdsa_sha384_signature_functions },
487 { PROV_NAMES_ECDSA_SHA512, FIPS_DEFAULT_PROPERTIES, ossl_ecdsa_sha512_signature_functions },
488 { PROV_NAMES_ECDSA_SHA3_224, FIPS_DEFAULT_PROPERTIES, ossl_ecdsa_sha3_224_signature_functions },
489 { PROV_NAMES_ECDSA_SHA3_256, FIPS_DEFAULT_PROPERTIES, ossl_ecdsa_sha3_256_signature_functions },
490 { PROV_NAMES_ECDSA_SHA3_384, FIPS_DEFAULT_PROPERTIES, ossl_ecdsa_sha3_384_signature_functions },
491 { PROV_NAMES_ECDSA_SHA3_512, FIPS_DEFAULT_PROPERTIES, ossl_ecdsa_sha3_512_signature_functions },
492 #endif
493 #ifndef OPENSSL_NO_ML_DSA
494 { PROV_NAMES_ML_DSA_44, FIPS_DEFAULT_PROPERTIES, ossl_ml_dsa_44_signature_functions },
495 { PROV_NAMES_ML_DSA_65, FIPS_DEFAULT_PROPERTIES, ossl_ml_dsa_65_signature_functions },
496 { PROV_NAMES_ML_DSA_87, FIPS_DEFAULT_PROPERTIES, ossl_ml_dsa_87_signature_functions },
497 #endif
498 { PROV_NAMES_HMAC, FIPS_DEFAULT_PROPERTIES,
499 ossl_mac_legacy_hmac_signature_functions },
500 #ifndef OPENSSL_NO_CMAC
501 { PROV_NAMES_CMAC, FIPS_DEFAULT_PROPERTIES,
502 ossl_mac_legacy_cmac_signature_functions },
503 #endif
504 #ifndef OPENSSL_NO_SLH_DSA
505 { PROV_NAMES_SLH_DSA_SHA2_128S, FIPS_DEFAULT_PROPERTIES,
506 ossl_slh_dsa_sha2_128s_signature_functions, PROV_DESCS_SLH_DSA_SHA2_128S },
507 { PROV_NAMES_SLH_DSA_SHA2_128F, FIPS_DEFAULT_PROPERTIES,
508 ossl_slh_dsa_sha2_128f_signature_functions, PROV_DESCS_SLH_DSA_SHA2_128F },
509 { PROV_NAMES_SLH_DSA_SHA2_192S, FIPS_DEFAULT_PROPERTIES,
510 ossl_slh_dsa_sha2_192s_signature_functions, PROV_DESCS_SLH_DSA_SHA2_192S },
511 { PROV_NAMES_SLH_DSA_SHA2_192F, FIPS_DEFAULT_PROPERTIES,
512 ossl_slh_dsa_sha2_192f_signature_functions, PROV_DESCS_SLH_DSA_SHA2_192F },
513 { PROV_NAMES_SLH_DSA_SHA2_256S, FIPS_DEFAULT_PROPERTIES,
514 ossl_slh_dsa_sha2_256s_signature_functions, PROV_DESCS_SLH_DSA_SHA2_256S },
515 { PROV_NAMES_SLH_DSA_SHA2_256F, FIPS_DEFAULT_PROPERTIES,
516 ossl_slh_dsa_sha2_256f_signature_functions, PROV_DESCS_SLH_DSA_SHA2_256F },
517 { PROV_NAMES_SLH_DSA_SHAKE_128S, FIPS_DEFAULT_PROPERTIES,
518 ossl_slh_dsa_shake_128s_signature_functions, PROV_DESCS_SLH_DSA_SHAKE_128S },
519 { PROV_NAMES_SLH_DSA_SHAKE_128F, FIPS_DEFAULT_PROPERTIES,
520 ossl_slh_dsa_shake_128f_signature_functions, PROV_DESCS_SLH_DSA_SHAKE_128F },
521 { PROV_NAMES_SLH_DSA_SHAKE_192S, FIPS_DEFAULT_PROPERTIES,
522 ossl_slh_dsa_shake_192s_signature_functions, PROV_DESCS_SLH_DSA_SHAKE_192S },
523 { PROV_NAMES_SLH_DSA_SHAKE_192F, FIPS_DEFAULT_PROPERTIES,
524 ossl_slh_dsa_shake_192f_signature_functions, PROV_DESCS_SLH_DSA_SHAKE_192F },
525 { PROV_NAMES_SLH_DSA_SHAKE_256S, FIPS_DEFAULT_PROPERTIES,
526 ossl_slh_dsa_shake_256s_signature_functions, PROV_DESCS_SLH_DSA_SHAKE_256S },
527 { PROV_NAMES_SLH_DSA_SHAKE_256F, FIPS_DEFAULT_PROPERTIES,
528 ossl_slh_dsa_shake_256f_signature_functions, PROV_DESCS_SLH_DSA_SHAKE_256F },
529 #endif /* OPENSSL_NO_SLH_DSA */
530 { NULL, NULL, NULL }
531 };
532
533 static const OSSL_ALGORITHM fips_asym_cipher[] = {
534 { PROV_NAMES_RSA, FIPS_DEFAULT_PROPERTIES, ossl_rsa_asym_cipher_functions },
535 { NULL, NULL, NULL }
536 };
537
538 static const OSSL_ALGORITHM fips_asym_kem[] = {
539 { PROV_NAMES_RSA, FIPS_DEFAULT_PROPERTIES, ossl_rsa_asym_kem_functions },
540 #ifndef OPENSSL_NO_ML_KEM
541 { PROV_NAMES_ML_KEM_512, FIPS_DEFAULT_PROPERTIES, ossl_ml_kem_asym_kem_functions },
542 { PROV_NAMES_ML_KEM_768, FIPS_DEFAULT_PROPERTIES, ossl_ml_kem_asym_kem_functions },
543 { PROV_NAMES_ML_KEM_1024, FIPS_DEFAULT_PROPERTIES, ossl_ml_kem_asym_kem_functions },
544 # if !defined(OPENSSL_NO_ECX)
545 { "X25519MLKEM768", FIPS_DEFAULT_PROPERTIES, ossl_mlx_kem_asym_kem_functions },
546 { "X448MLKEM1024", FIPS_DEFAULT_PROPERTIES, ossl_mlx_kem_asym_kem_functions },
547 # endif
548 # if !defined(OPENSSL_NO_EC)
549 { "SecP256r1MLKEM768", FIPS_DEFAULT_PROPERTIES, ossl_mlx_kem_asym_kem_functions },
550 { "SecP384r1MLKEM1024", FIPS_DEFAULT_PROPERTIES, ossl_mlx_kem_asym_kem_functions },
551 # endif
552 #endif
553 { NULL, NULL, NULL }
554 };
555
556 static const OSSL_ALGORITHM fips_keymgmt[] = {
557 #ifndef OPENSSL_NO_DH
558 { PROV_NAMES_DH, FIPS_DEFAULT_PROPERTIES, ossl_dh_keymgmt_functions,
559 PROV_DESCS_DH },
560 { PROV_NAMES_DHX, FIPS_DEFAULT_PROPERTIES, ossl_dhx_keymgmt_functions,
561 PROV_DESCS_DHX },
562 #endif
563 #ifndef OPENSSL_NO_DSA
564 { PROV_NAMES_DSA, FIPS_DEFAULT_PROPERTIES, ossl_dsa_keymgmt_functions,
565 PROV_DESCS_DSA },
566 #endif
567 { PROV_NAMES_RSA, FIPS_DEFAULT_PROPERTIES, ossl_rsa_keymgmt_functions,
568 PROV_DESCS_RSA },
569 { PROV_NAMES_RSA_PSS, FIPS_DEFAULT_PROPERTIES,
570 ossl_rsapss_keymgmt_functions, PROV_DESCS_RSA_PSS },
571 #ifndef OPENSSL_NO_EC
572 { PROV_NAMES_EC, FIPS_DEFAULT_PROPERTIES, ossl_ec_keymgmt_functions,
573 PROV_DESCS_EC },
574 # ifndef OPENSSL_NO_ECX
575 { PROV_NAMES_X25519, FIPS_UNAPPROVED_PROPERTIES, ossl_x25519_keymgmt_functions,
576 PROV_DESCS_X25519 },
577 { PROV_NAMES_X448, FIPS_UNAPPROVED_PROPERTIES, ossl_x448_keymgmt_functions,
578 PROV_DESCS_X448 },
579 { PROV_NAMES_ED25519, FIPS_DEFAULT_PROPERTIES, ossl_ed25519_keymgmt_functions,
580 PROV_DESCS_ED25519 },
581 { PROV_NAMES_ED448, FIPS_DEFAULT_PROPERTIES, ossl_ed448_keymgmt_functions,
582 PROV_DESCS_ED448 },
583 # endif
584 #endif
585 #ifndef OPENSSL_NO_ML_DSA
586 { PROV_NAMES_ML_DSA_44, FIPS_DEFAULT_PROPERTIES, ossl_ml_dsa_44_keymgmt_functions,
587 PROV_DESCS_ML_DSA_44 },
588 { PROV_NAMES_ML_DSA_65, FIPS_DEFAULT_PROPERTIES, ossl_ml_dsa_65_keymgmt_functions,
589 PROV_DESCS_ML_DSA_65 },
590 { PROV_NAMES_ML_DSA_87, FIPS_DEFAULT_PROPERTIES, ossl_ml_dsa_87_keymgmt_functions,
591 PROV_DESCS_ML_DSA_87 },
592 #endif /* OPENSSL_NO_ML_DSA */
593 { PROV_NAMES_TLS1_PRF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_keymgmt_functions,
594 PROV_DESCS_TLS1_PRF_SIGN },
595 { PROV_NAMES_HKDF, FIPS_DEFAULT_PROPERTIES, ossl_kdf_keymgmt_functions,
596 PROV_DESCS_HKDF_SIGN },
597 { PROV_NAMES_HMAC, FIPS_DEFAULT_PROPERTIES, ossl_mac_legacy_keymgmt_functions,
598 PROV_DESCS_HMAC_SIGN },
599 #ifndef OPENSSL_NO_CMAC
600 { PROV_NAMES_CMAC, FIPS_DEFAULT_PROPERTIES,
601 ossl_cmac_legacy_keymgmt_functions, PROV_DESCS_CMAC_SIGN },
602 #endif
603 #ifndef OPENSSL_NO_ML_KEM
604 { PROV_NAMES_ML_KEM_512, FIPS_DEFAULT_PROPERTIES, ossl_ml_kem_512_keymgmt_functions,
605 PROV_DESCS_ML_KEM_512 },
606 { PROV_NAMES_ML_KEM_768, FIPS_DEFAULT_PROPERTIES, ossl_ml_kem_768_keymgmt_functions,
607 PROV_DESCS_ML_KEM_768 },
608 { PROV_NAMES_ML_KEM_1024, FIPS_DEFAULT_PROPERTIES, ossl_ml_kem_1024_keymgmt_functions,
609 PROV_DESCS_ML_KEM_1024 },
610 # if !defined(OPENSSL_NO_ECX)
611 { PROV_NAMES_X25519MLKEM768, FIPS_DEFAULT_PROPERTIES, ossl_mlx_x25519_kem_kmgmt_functions,
612 PROV_DESCS_X25519MLKEM768 },
613 { PROV_NAMES_X448MLKEM1024, FIPS_DEFAULT_PROPERTIES, ossl_mlx_x448_kem_kmgmt_functions,
614 PROV_DESCS_X448MLKEM1024 },
615 # endif
616 # if !defined(OPENSSL_NO_EC)
617 { PROV_NAMES_SecP256r1MLKEM768, FIPS_DEFAULT_PROPERTIES, ossl_mlx_p256_kem_kmgmt_functions,
618 PROV_DESCS_SecP256r1MLKEM768 },
619 { PROV_NAMES_SecP384r1MLKEM1024, FIPS_DEFAULT_PROPERTIES, ossl_mlx_p384_kem_kmgmt_functions,
620 PROV_DESCS_SecP384r1MLKEM1024 },
621 # endif
622 #endif
623 #ifndef OPENSSL_NO_SLH_DSA
624 { PROV_NAMES_SLH_DSA_SHA2_128S, FIPS_DEFAULT_PROPERTIES,
625 ossl_slh_dsa_sha2_128s_keymgmt_functions, PROV_DESCS_SLH_DSA_SHA2_128S },
626 { PROV_NAMES_SLH_DSA_SHA2_128F, FIPS_DEFAULT_PROPERTIES,
627 ossl_slh_dsa_sha2_128f_keymgmt_functions, PROV_DESCS_SLH_DSA_SHA2_128F },
628 { PROV_NAMES_SLH_DSA_SHA2_192S, FIPS_DEFAULT_PROPERTIES,
629 ossl_slh_dsa_sha2_192s_keymgmt_functions, PROV_DESCS_SLH_DSA_SHA2_192S },
630 { PROV_NAMES_SLH_DSA_SHA2_192F, FIPS_DEFAULT_PROPERTIES,
631 ossl_slh_dsa_sha2_192f_keymgmt_functions, PROV_DESCS_SLH_DSA_SHA2_192F },
632 { PROV_NAMES_SLH_DSA_SHA2_256S, FIPS_DEFAULT_PROPERTIES,
633 ossl_slh_dsa_sha2_256s_keymgmt_functions, PROV_DESCS_SLH_DSA_SHA2_256S },
634 { PROV_NAMES_SLH_DSA_SHA2_256F, FIPS_DEFAULT_PROPERTIES,
635 ossl_slh_dsa_sha2_256f_keymgmt_functions, PROV_DESCS_SLH_DSA_SHA2_256F },
636 { PROV_NAMES_SLH_DSA_SHAKE_128S, FIPS_DEFAULT_PROPERTIES,
637 ossl_slh_dsa_shake_128s_keymgmt_functions, PROV_DESCS_SLH_DSA_SHAKE_128S },
638 { PROV_NAMES_SLH_DSA_SHAKE_128F, FIPS_DEFAULT_PROPERTIES,
639 ossl_slh_dsa_shake_128f_keymgmt_functions, PROV_DESCS_SLH_DSA_SHAKE_128F },
640 { PROV_NAMES_SLH_DSA_SHAKE_192S, FIPS_DEFAULT_PROPERTIES,
641 ossl_slh_dsa_shake_192s_keymgmt_functions, PROV_DESCS_SLH_DSA_SHAKE_192S },
642 { PROV_NAMES_SLH_DSA_SHAKE_192F, FIPS_DEFAULT_PROPERTIES,
643 ossl_slh_dsa_shake_192f_keymgmt_functions, PROV_DESCS_SLH_DSA_SHAKE_192F },
644 { PROV_NAMES_SLH_DSA_SHAKE_256S, FIPS_DEFAULT_PROPERTIES,
645 ossl_slh_dsa_shake_256s_keymgmt_functions, PROV_DESCS_SLH_DSA_SHAKE_256S },
646 { PROV_NAMES_SLH_DSA_SHAKE_256F, FIPS_DEFAULT_PROPERTIES,
647 ossl_slh_dsa_shake_256f_keymgmt_functions, PROV_DESCS_SLH_DSA_SHAKE_256F },
648 #endif /* OPENSSL_NO_SLH_DSA */
649 { NULL, NULL, NULL }
650 };
651
fips_query(void * provctx,int operation_id,int * no_cache)652 static const OSSL_ALGORITHM *fips_query(void *provctx, int operation_id,
653 int *no_cache)
654 {
655 *no_cache = 0;
656
657 if (!ossl_prov_is_running())
658 return NULL;
659
660 switch (operation_id) {
661 case OSSL_OP_DIGEST:
662 return fips_digests;
663 case OSSL_OP_CIPHER:
664 return exported_fips_ciphers;
665 case OSSL_OP_MAC:
666 return fips_macs;
667 case OSSL_OP_KDF:
668 return fips_kdfs;
669 case OSSL_OP_RAND:
670 return fips_rands;
671 case OSSL_OP_KEYMGMT:
672 return fips_keymgmt;
673 case OSSL_OP_KEYEXCH:
674 return fips_keyexch;
675 case OSSL_OP_SIGNATURE:
676 return fips_signature;
677 case OSSL_OP_ASYM_CIPHER:
678 return fips_asym_cipher;
679 case OSSL_OP_KEM:
680 return fips_asym_kem;
681 }
682 return NULL;
683 }
684
fips_query_internal(void * provctx,int operation_id,int * no_cache)685 static const OSSL_ALGORITHM *fips_query_internal(void *provctx, int operation_id,
686 int *no_cache)
687 {
688 if (operation_id == OSSL_OP_MAC) {
689 *no_cache = 0;
690 if (!ossl_prov_is_running())
691 return NULL;
692 return fips_macs_internal;
693 }
694 return fips_query(provctx, operation_id, no_cache);
695 }
696
fips_teardown(void * provctx)697 static void fips_teardown(void *provctx)
698 {
699 OSSL_LIB_CTX_free(PROV_LIBCTX_OF(provctx));
700 ossl_prov_ctx_free(provctx);
701 }
702
fips_intern_teardown(void * provctx)703 static void fips_intern_teardown(void *provctx)
704 {
705 /*
706 * We know that the library context is the same as for the outer provider,
707 * so no need to destroy it here.
708 */
709 ossl_prov_ctx_free(provctx);
710 }
711
712 /* Functions we provide to the core */
713 static const OSSL_DISPATCH fips_dispatch_table[] = {
714 { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))fips_teardown },
715 { OSSL_FUNC_PROVIDER_GETTABLE_PARAMS, (void (*)(void))fips_gettable_params },
716 { OSSL_FUNC_PROVIDER_GET_PARAMS, (void (*)(void))fips_get_params },
717 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query },
718 { OSSL_FUNC_PROVIDER_GET_CAPABILITIES,
719 (void (*)(void))ossl_prov_get_capabilities },
720 { OSSL_FUNC_PROVIDER_SELF_TEST, (void (*)(void))fips_self_test },
721 { OSSL_FUNC_PROVIDER_RANDOM_BYTES, (void (*)(void))fips_random_bytes },
722 OSSL_DISPATCH_END
723 };
724
725 /* Functions we provide to ourself */
726 static const OSSL_DISPATCH intern_dispatch_table[] = {
727 { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))fips_intern_teardown },
728 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query_internal },
729 OSSL_DISPATCH_END
730 };
731
732 /*
733 * On VMS, the provider init function name is expected to be uppercase,
734 * see the pragmas in <openssl/core.h>. Let's do the same with this
735 * internal name. This is how symbol names are treated by default
736 * by the compiler if nothing else is said, but since this is part
737 * of libfips, and we build our libraries with mixed case symbol names,
738 * we must switch back to this default explicitly here.
739 */
740 #ifdef __VMS
741 # pragma names save
742 # pragma names uppercase,truncated
743 #endif
744 OSSL_provider_init_fn OSSL_provider_init_int;
745 #ifdef __VMS
746 # pragma names restore
747 #endif
OSSL_provider_init_int(const OSSL_CORE_HANDLE * handle,const OSSL_DISPATCH * in,const OSSL_DISPATCH ** out,void ** provctx)748 int OSSL_provider_init_int(const OSSL_CORE_HANDLE *handle,
749 const OSSL_DISPATCH *in,
750 const OSSL_DISPATCH **out,
751 void **provctx)
752 {
753 FIPS_GLOBAL *fgbl;
754 OSSL_LIB_CTX *libctx = NULL;
755 SELF_TEST_POST_PARAMS selftest_params;
756
757 memset(&selftest_params, 0, sizeof(selftest_params));
758
759 if (!ossl_prov_seeding_from_dispatch(in))
760 goto err;
761 for (; in->function_id != 0; in++) {
762 /*
763 * We do not support the scenario of an application linked against
764 * multiple versions of libcrypto (e.g. one static and one dynamic), but
765 * sharing a single fips.so. We do a simple sanity check here.
766 */
767 #define set_func(c, f) if (c == NULL) c = f; else if (c != f) return 0;
768 switch (in->function_id) {
769 case OSSL_FUNC_CORE_GET_LIBCTX:
770 set_func(c_get_libctx, OSSL_FUNC_core_get_libctx(in));
771 break;
772 case OSSL_FUNC_CORE_GETTABLE_PARAMS:
773 set_func(c_gettable_params, OSSL_FUNC_core_gettable_params(in));
774 break;
775 case OSSL_FUNC_CORE_GET_PARAMS:
776 set_func(c_get_params, OSSL_FUNC_core_get_params(in));
777 break;
778 case OSSL_FUNC_CORE_THREAD_START:
779 set_func(c_thread_start, OSSL_FUNC_core_thread_start(in));
780 break;
781 case OSSL_FUNC_CORE_NEW_ERROR:
782 set_func(c_new_error, OSSL_FUNC_core_new_error(in));
783 break;
784 case OSSL_FUNC_CORE_SET_ERROR_DEBUG:
785 set_func(c_set_error_debug, OSSL_FUNC_core_set_error_debug(in));
786 break;
787 case OSSL_FUNC_CORE_VSET_ERROR:
788 set_func(c_vset_error, OSSL_FUNC_core_vset_error(in));
789 break;
790 case OSSL_FUNC_CORE_SET_ERROR_MARK:
791 set_func(c_set_error_mark, OSSL_FUNC_core_set_error_mark(in));
792 break;
793 case OSSL_FUNC_CORE_CLEAR_LAST_ERROR_MARK:
794 set_func(c_clear_last_error_mark,
795 OSSL_FUNC_core_clear_last_error_mark(in));
796 break;
797 case OSSL_FUNC_CORE_POP_ERROR_TO_MARK:
798 set_func(c_pop_error_to_mark, OSSL_FUNC_core_pop_error_to_mark(in));
799 break;
800 case OSSL_FUNC_CRYPTO_MALLOC:
801 set_func(c_CRYPTO_malloc, OSSL_FUNC_CRYPTO_malloc(in));
802 break;
803 case OSSL_FUNC_CRYPTO_ZALLOC:
804 set_func(c_CRYPTO_zalloc, OSSL_FUNC_CRYPTO_zalloc(in));
805 break;
806 case OSSL_FUNC_CRYPTO_FREE:
807 set_func(c_CRYPTO_free, OSSL_FUNC_CRYPTO_free(in));
808 break;
809 case OSSL_FUNC_CRYPTO_CLEAR_FREE:
810 set_func(c_CRYPTO_clear_free, OSSL_FUNC_CRYPTO_clear_free(in));
811 break;
812 case OSSL_FUNC_CRYPTO_REALLOC:
813 set_func(c_CRYPTO_realloc, OSSL_FUNC_CRYPTO_realloc(in));
814 break;
815 case OSSL_FUNC_CRYPTO_CLEAR_REALLOC:
816 set_func(c_CRYPTO_clear_realloc,
817 OSSL_FUNC_CRYPTO_clear_realloc(in));
818 break;
819 case OSSL_FUNC_CRYPTO_SECURE_MALLOC:
820 set_func(c_CRYPTO_secure_malloc,
821 OSSL_FUNC_CRYPTO_secure_malloc(in));
822 break;
823 case OSSL_FUNC_CRYPTO_SECURE_ZALLOC:
824 set_func(c_CRYPTO_secure_zalloc,
825 OSSL_FUNC_CRYPTO_secure_zalloc(in));
826 break;
827 case OSSL_FUNC_CRYPTO_SECURE_FREE:
828 set_func(c_CRYPTO_secure_free,
829 OSSL_FUNC_CRYPTO_secure_free(in));
830 break;
831 case OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE:
832 set_func(c_CRYPTO_secure_clear_free,
833 OSSL_FUNC_CRYPTO_secure_clear_free(in));
834 break;
835 case OSSL_FUNC_CRYPTO_SECURE_ALLOCATED:
836 set_func(c_CRYPTO_secure_allocated,
837 OSSL_FUNC_CRYPTO_secure_allocated(in));
838 break;
839 case OSSL_FUNC_BIO_NEW_FILE:
840 set_func(selftest_params.bio_new_file_cb,
841 OSSL_FUNC_BIO_new_file(in));
842 break;
843 case OSSL_FUNC_BIO_NEW_MEMBUF:
844 set_func(selftest_params.bio_new_buffer_cb,
845 OSSL_FUNC_BIO_new_membuf(in));
846 break;
847 case OSSL_FUNC_BIO_READ_EX:
848 set_func(selftest_params.bio_read_ex_cb,
849 OSSL_FUNC_BIO_read_ex(in));
850 break;
851 case OSSL_FUNC_BIO_FREE:
852 set_func(selftest_params.bio_free_cb, OSSL_FUNC_BIO_free(in));
853 break;
854 case OSSL_FUNC_BIO_VSNPRINTF:
855 set_func(c_BIO_vsnprintf, OSSL_FUNC_BIO_vsnprintf(in));
856 break;
857 case OSSL_FUNC_SELF_TEST_CB:
858 set_func(c_stcbfn, OSSL_FUNC_self_test_cb(in));
859 break;
860 case OSSL_FUNC_INDICATOR_CB:
861 set_func(c_indcbfn, OSSL_FUNC_indicator_cb(in));
862 break;
863 default:
864 /* Just ignore anything we don't understand */
865 break;
866 }
867 }
868
869 OPENSSL_cpuid_setup();
870
871 /* Create a context. */
872 if ((*provctx = ossl_prov_ctx_new()) == NULL
873 || (libctx = OSSL_LIB_CTX_new()) == NULL)
874 goto err;
875
876 if ((fgbl = ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_FIPS_PROV_INDEX)) == NULL)
877 goto err;
878
879 fgbl->handle = handle;
880
881 /*
882 * We need to register this thread to receive thread lifecycle callbacks.
883 * This wouldn't matter if the current thread is also the same thread that
884 * closes the FIPS provider down. But if that happens on a different thread
885 * then memory leaks could otherwise occur.
886 */
887 if (!ossl_thread_register_fips(libctx))
888 goto err;
889
890 /*
891 * Ensure our internal provider is loaded. We use this whenever the FIPS
892 * provider internally uses the EVP API. We proactively load this now
893 * rather than waiting for lazy loading to ensure it is always present when
894 * we need it.
895 */
896 if (!ossl_provider_activate_fallbacks(libctx))
897 goto err;
898
899 /*
900 * We did initial set up of selftest_params in a local copy, because we
901 * could not create fgbl until c_CRYPTO_zalloc was defined in the loop
902 * above.
903 */
904 fgbl->selftest_params = selftest_params;
905
906 fgbl->selftest_params.libctx = libctx;
907
908 set_self_test_cb(fgbl);
909
910 if (!fips_get_params_from_core(fgbl)) {
911 /* Error already raised */
912 goto err;
913 }
914 /*
915 * Disable the conditional error check if it's disabled in the fips config
916 * file.
917 */
918 if (fgbl->selftest_params.conditional_error_check != NULL
919 && strcmp(fgbl->selftest_params.conditional_error_check, "0") == 0)
920 SELF_TEST_disable_conditional_error_state();
921
922 /* Enable or disable FIPS provider options */
923 #define OSSL_FIPS_PARAM(structname, paramname, unused) \
924 if (fgbl->fips_##structname.option != NULL) { \
925 if (strcmp(fgbl->fips_##structname.option, "1") == 0) \
926 fgbl->fips_##structname.enabled = 1; \
927 else if (strcmp(fgbl->fips_##structname.option, "0") == 0) \
928 fgbl->fips_##structname.enabled = 0; \
929 else \
930 goto err; \
931 }
932 #include "fips_indicator_params.inc"
933 #undef OSSL_FIPS_PARAM
934
935 ossl_prov_cache_exported_algorithms(fips_ciphers, exported_fips_ciphers);
936
937 if (!SELF_TEST_post(&fgbl->selftest_params, 0)) {
938 ERR_raise(ERR_LIB_PROV, PROV_R_SELF_TEST_POST_FAILURE);
939 goto err;
940 }
941
942 ossl_prov_ctx_set0_libctx(*provctx, libctx);
943 ossl_prov_ctx_set0_core_get_params(*provctx, c_get_params);
944 ossl_prov_ctx_set0_handle(*provctx, handle);
945
946 *out = fips_dispatch_table;
947 return 1;
948 err:
949 fips_teardown(*provctx);
950 OSSL_LIB_CTX_free(libctx);
951 *provctx = NULL;
952 return 0;
953 }
954
955 /*
956 * The internal init function used when the FIPS module uses EVP to call
957 * another algorithm also in the FIPS module. This is a recursive call that has
958 * been made from within the FIPS module itself. To make this work, we populate
959 * the provider context of this inner instance with the same library context
960 * that was used in the EVP call that initiated this recursive call.
961 */
962 OSSL_provider_init_fn ossl_fips_intern_provider_init;
ossl_fips_intern_provider_init(const OSSL_CORE_HANDLE * handle,const OSSL_DISPATCH * in,const OSSL_DISPATCH ** out,void ** provctx)963 int ossl_fips_intern_provider_init(const OSSL_CORE_HANDLE *handle,
964 const OSSL_DISPATCH *in,
965 const OSSL_DISPATCH **out,
966 void **provctx)
967 {
968 OSSL_FUNC_core_get_libctx_fn *c_internal_get_libctx = NULL;
969
970 for (; in->function_id != 0; in++) {
971 switch (in->function_id) {
972 case OSSL_FUNC_CORE_GET_LIBCTX:
973 c_internal_get_libctx = OSSL_FUNC_core_get_libctx(in);
974 break;
975 default:
976 break;
977 }
978 }
979
980 if (c_internal_get_libctx == NULL)
981 return 0;
982
983 if ((*provctx = ossl_prov_ctx_new()) == NULL)
984 return 0;
985
986 /*
987 * Using the parent library context only works because we are a built-in
988 * internal provider. This is not something that most providers would be
989 * able to do.
990 */
991 ossl_prov_ctx_set0_libctx(*provctx,
992 (OSSL_LIB_CTX *)c_internal_get_libctx(handle));
993 ossl_prov_ctx_set0_handle(*provctx, handle);
994
995 *out = intern_dispatch_table;
996 return 1;
997 }
998
ERR_new(void)999 void ERR_new(void)
1000 {
1001 c_new_error(NULL);
1002 }
1003
ERR_set_debug(const char * file,int line,const char * func)1004 void ERR_set_debug(const char *file, int line, const char *func)
1005 {
1006 c_set_error_debug(NULL, file, line, func);
1007 }
1008
ERR_set_error(int lib,int reason,const char * fmt,...)1009 void ERR_set_error(int lib, int reason, const char *fmt, ...)
1010 {
1011 va_list args;
1012
1013 va_start(args, fmt);
1014 c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args);
1015 va_end(args);
1016 }
1017
ERR_vset_error(int lib,int reason,const char * fmt,va_list args)1018 void ERR_vset_error(int lib, int reason, const char *fmt, va_list args)
1019 {
1020 c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args);
1021 }
1022
ERR_set_mark(void)1023 int ERR_set_mark(void)
1024 {
1025 return c_set_error_mark(NULL);
1026 }
1027
ERR_clear_last_mark(void)1028 int ERR_clear_last_mark(void)
1029 {
1030 return c_clear_last_error_mark(NULL);
1031 }
1032
ERR_pop_to_mark(void)1033 int ERR_pop_to_mark(void)
1034 {
1035 return c_pop_error_to_mark(NULL);
1036 }
1037
1038 /*
1039 * This must take a library context, since it's called from the depths
1040 * of crypto/initthread.c code, where it's (correctly) assumed that the
1041 * passed caller argument is an OSSL_LIB_CTX pointer (since the same routine
1042 * is also called from other parts of libcrypto, which all pass around a
1043 * OSSL_LIB_CTX pointer)
1044 */
FIPS_get_core_handle(OSSL_LIB_CTX * libctx)1045 const OSSL_CORE_HANDLE *FIPS_get_core_handle(OSSL_LIB_CTX *libctx)
1046 {
1047 FIPS_GLOBAL *fgbl = ossl_lib_ctx_get_data(libctx,
1048 OSSL_LIB_CTX_FIPS_PROV_INDEX);
1049
1050 if (fgbl == NULL)
1051 return NULL;
1052
1053 return fgbl->handle;
1054 }
1055
CRYPTO_malloc(size_t num,const char * file,int line)1056 void *CRYPTO_malloc(size_t num, const char *file, int line)
1057 {
1058 return c_CRYPTO_malloc(num, file, line);
1059 }
1060
CRYPTO_zalloc(size_t num,const char * file,int line)1061 void *CRYPTO_zalloc(size_t num, const char *file, int line)
1062 {
1063 return c_CRYPTO_zalloc(num, file, line);
1064 }
1065
CRYPTO_free(void * ptr,const char * file,int line)1066 void CRYPTO_free(void *ptr, const char *file, int line)
1067 {
1068 c_CRYPTO_free(ptr, file, line);
1069 }
1070
CRYPTO_clear_free(void * ptr,size_t num,const char * file,int line)1071 void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line)
1072 {
1073 c_CRYPTO_clear_free(ptr, num, file, line);
1074 }
1075
CRYPTO_realloc(void * addr,size_t num,const char * file,int line)1076 void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line)
1077 {
1078 return c_CRYPTO_realloc(addr, num, file, line);
1079 }
1080
CRYPTO_clear_realloc(void * addr,size_t old_num,size_t num,const char * file,int line)1081 void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
1082 const char *file, int line)
1083 {
1084 return c_CRYPTO_clear_realloc(addr, old_num, num, file, line);
1085 }
1086
CRYPTO_secure_malloc(size_t num,const char * file,int line)1087 void *CRYPTO_secure_malloc(size_t num, const char *file, int line)
1088 {
1089 return c_CRYPTO_secure_malloc(num, file, line);
1090 }
1091
CRYPTO_secure_zalloc(size_t num,const char * file,int line)1092 void *CRYPTO_secure_zalloc(size_t num, const char *file, int line)
1093 {
1094 return c_CRYPTO_secure_zalloc(num, file, line);
1095 }
1096
CRYPTO_secure_free(void * ptr,const char * file,int line)1097 void CRYPTO_secure_free(void *ptr, const char *file, int line)
1098 {
1099 c_CRYPTO_secure_free(ptr, file, line);
1100 }
1101
CRYPTO_secure_clear_free(void * ptr,size_t num,const char * file,int line)1102 void CRYPTO_secure_clear_free(void *ptr, size_t num, const char *file, int line)
1103 {
1104 c_CRYPTO_secure_clear_free(ptr, num, file, line);
1105 }
1106
CRYPTO_secure_allocated(const void * ptr)1107 int CRYPTO_secure_allocated(const void *ptr)
1108 {
1109 return c_CRYPTO_secure_allocated(ptr);
1110 }
1111
CRYPTO_aligned_alloc(size_t num,size_t align,void ** freeptr,const char * file,int line)1112 void *CRYPTO_aligned_alloc(size_t num, size_t align, void **freeptr,
1113 const char *file, int line)
1114 {
1115 return NULL;
1116 }
1117
BIO_snprintf(char * buf,size_t n,const char * format,...)1118 int BIO_snprintf(char *buf, size_t n, const char *format, ...)
1119 {
1120 va_list args;
1121 int ret;
1122
1123 va_start(args, format);
1124 ret = c_BIO_vsnprintf(buf, n, format, args);
1125 va_end(args);
1126 return ret;
1127 }
1128
1129 #define OSSL_FIPS_PARAM(structname, paramname, unused) \
1130 int ossl_fips_config_##structname(OSSL_LIB_CTX *libctx) \
1131 { \
1132 FIPS_GLOBAL *fgbl = \
1133 ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_FIPS_PROV_INDEX); \
1134 \
1135 return fgbl->fips_##structname.enabled; \
1136 }
1137 #include "fips_indicator_params.inc"
1138 #undef OSSL_FIPS_PARAM
1139
OSSL_SELF_TEST_get_callback(OSSL_LIB_CTX * libctx,OSSL_CALLBACK ** cb,void ** cbarg)1140 void OSSL_SELF_TEST_get_callback(OSSL_LIB_CTX *libctx, OSSL_CALLBACK **cb,
1141 void **cbarg)
1142 {
1143 assert(libctx != NULL);
1144
1145 if (c_stcbfn != NULL && c_get_libctx != NULL) {
1146 /* Get the parent libctx */
1147 c_stcbfn(c_get_libctx(FIPS_get_core_handle(libctx)), cb, cbarg);
1148 } else {
1149 if (cb != NULL)
1150 *cb = NULL;
1151 if (cbarg != NULL)
1152 *cbarg = NULL;
1153 }
1154 }
1155
OSSL_INDICATOR_get_callback(OSSL_LIB_CTX * libctx,OSSL_INDICATOR_CALLBACK ** cb)1156 void OSSL_INDICATOR_get_callback(OSSL_LIB_CTX *libctx,
1157 OSSL_INDICATOR_CALLBACK **cb)
1158 {
1159 assert(libctx != NULL);
1160
1161 if (c_indcbfn != NULL && c_get_libctx != NULL) {
1162 /* Get the parent libctx */
1163 c_indcbfn(c_get_libctx(FIPS_get_core_handle(libctx)), cb);
1164 } else {
1165 if (cb != NULL)
1166 *cb = NULL;
1167 }
1168 }
1169