FIPS: remove algorithms that are not being validated.
[openssl.git] / providers / fips / fipsprov.c
1 /*
2  * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <string.h>
11 #include <stdio.h>
12 #include <openssl/core.h>
13 #include <openssl/core_numbers.h>
14 #include <openssl/core_names.h>
15 #include <openssl/params.h>
16 #include <openssl/err.h>
17 #include <openssl/evp.h>
18 #include <openssl/kdf.h>
19
20 /* TODO(3.0): Needed for dummy_evp_call(). To be removed */
21 #include <openssl/sha.h>
22 #include <openssl/rand_drbg.h>
23 #include <openssl/ec.h>
24 #include <openssl/fips_names.h>
25
26 #include "internal/cryptlib.h"
27 #include "internal/property.h"
28 #include "internal/nelem.h"
29 #include "openssl/param_build.h"
30 #include "crypto/evp.h"
31 #include "prov/implementations.h"
32 #include "prov/provider_ctx.h"
33 #include "prov/providercommon.h"
34 #include "prov/provider_util.h"
35 #include "self_test.h"
36
37 #define ALGC(NAMES, FUNC, CHECK) { { NAMES, "provider=fips,fips=yes", FUNC }, CHECK }
38 #define ALG(NAMES, FUNC) ALGC(NAMES, FUNC, NULL)
39
40 extern OSSL_core_thread_start_fn *c_thread_start;
41
42 /*
43  * TODO(3.0): Should these be stored in the provider side provctx? Could they
44  * ever be different from one init to the next? Unfortunately we can't do this
45  * at the moment because c_put_error/c_add_error_vdata do not provide
46  * us with the OPENSSL_CTX as a parameter.
47  */
48
49 static SELF_TEST_POST_PARAMS selftest_params;
50
51 /* Functions provided by the core */
52 static OSSL_core_gettable_params_fn *c_gettable_params;
53 static OSSL_core_get_params_fn *c_get_params;
54 OSSL_core_thread_start_fn *c_thread_start;
55 static OSSL_core_new_error_fn *c_new_error;
56 static OSSL_core_set_error_debug_fn *c_set_error_debug;
57 static OSSL_core_vset_error_fn *c_vset_error;
58 static OSSL_core_set_error_mark_fn *c_set_error_mark;
59 static OSSL_core_clear_last_error_mark_fn *c_clear_last_error_mark;
60 static OSSL_core_pop_error_to_mark_fn *c_pop_error_to_mark;
61 static OSSL_CRYPTO_malloc_fn *c_CRYPTO_malloc;
62 static OSSL_CRYPTO_zalloc_fn *c_CRYPTO_zalloc;
63 static OSSL_CRYPTO_free_fn *c_CRYPTO_free;
64 static OSSL_CRYPTO_clear_free_fn *c_CRYPTO_clear_free;
65 static OSSL_CRYPTO_realloc_fn *c_CRYPTO_realloc;
66 static OSSL_CRYPTO_clear_realloc_fn *c_CRYPTO_clear_realloc;
67 static OSSL_CRYPTO_secure_malloc_fn *c_CRYPTO_secure_malloc;
68 static OSSL_CRYPTO_secure_zalloc_fn *c_CRYPTO_secure_zalloc;
69 static OSSL_CRYPTO_secure_free_fn *c_CRYPTO_secure_free;
70 static OSSL_CRYPTO_secure_clear_free_fn *c_CRYPTO_secure_clear_free;
71 static OSSL_CRYPTO_secure_allocated_fn *c_CRYPTO_secure_allocated;
72 static OSSL_BIO_vsnprintf_fn *c_BIO_vsnprintf;
73
74 typedef struct fips_global_st {
75     const OSSL_PROVIDER *prov;
76 } FIPS_GLOBAL;
77
78 static void *fips_prov_ossl_ctx_new(OPENSSL_CTX *libctx)
79 {
80     FIPS_GLOBAL *fgbl = OPENSSL_zalloc(sizeof(*fgbl));
81
82     return fgbl;
83 }
84
85 static void fips_prov_ossl_ctx_free(void *fgbl)
86 {
87     OPENSSL_free(fgbl);
88 }
89
90 static const OPENSSL_CTX_METHOD fips_prov_ossl_ctx_method = {
91     fips_prov_ossl_ctx_new,
92     fips_prov_ossl_ctx_free,
93 };
94
95
96 /* Parameters we provide to the core */
97 static const OSSL_PARAM fips_param_types[] = {
98     OSSL_PARAM_DEFN(OSSL_PROV_PARAM_NAME, OSSL_PARAM_UTF8_PTR, NULL, 0),
99     OSSL_PARAM_DEFN(OSSL_PROV_PARAM_VERSION, OSSL_PARAM_UTF8_PTR, NULL, 0),
100     OSSL_PARAM_DEFN(OSSL_PROV_PARAM_BUILDINFO, OSSL_PARAM_UTF8_PTR, NULL, 0),
101     OSSL_PARAM_END
102 };
103
104 /*
105  * Parameters to retrieve from the core provider - required for self testing.
106  * NOTE: inside core_get_params() these will be loaded from config items
107  * stored inside prov->parameters (except for OSSL_PROV_PARAM_MODULE_FILENAME).
108  */
109 static OSSL_PARAM core_params[] =
110 {
111     OSSL_PARAM_utf8_ptr(OSSL_PROV_PARAM_MODULE_FILENAME,
112                         selftest_params.module_filename,
113                         sizeof(selftest_params.module_filename)),
114     OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_MODULE_MAC,
115                         selftest_params.module_checksum_data,
116                         sizeof(selftest_params.module_checksum_data)),
117     OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_MAC,
118                         selftest_params.indicator_checksum_data,
119                         sizeof(selftest_params.indicator_checksum_data)),
120     OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_STATUS,
121                         selftest_params.indicator_data,
122                         sizeof(selftest_params.indicator_data)),
123     OSSL_PARAM_utf8_ptr(OSSL_PROV_FIPS_PARAM_INSTALL_VERSION,
124                         selftest_params.indicator_version,
125                         sizeof(selftest_params.indicator_version)),
126     OSSL_PARAM_END
127 };
128
129 /* TODO(3.0): To be removed */
130 static int dummy_evp_call(void *provctx)
131 {
132     OPENSSL_CTX *libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
133     EVP_MD_CTX *ctx = EVP_MD_CTX_new();
134     EVP_MD *sha256 = EVP_MD_fetch(libctx, "SHA256", NULL);
135     EVP_KDF *kdf = EVP_KDF_fetch(libctx, OSSL_KDF_NAME_PBKDF2, NULL);
136     unsigned char dgst[SHA256_DIGEST_LENGTH];
137     unsigned int dgstlen;
138     int ret = 0;
139     BN_CTX *bnctx = NULL;
140     BIGNUM *a = NULL, *b = NULL;
141     unsigned char randbuf[128];
142     RAND_DRBG *drbg = OPENSSL_CTX_get0_public_drbg(libctx);
143 #ifndef OPENSSL_NO_EC
144     EC_KEY *key = NULL;
145 #endif
146
147     static const char msg[] = "Hello World!";
148     static const unsigned char exptd[] = {
149         0x7f, 0x83, 0xb1, 0x65, 0x7f, 0xf1, 0xfc, 0x53, 0xb9, 0x2d, 0xc1, 0x81,
150         0x48, 0xa1, 0xd6, 0x5d, 0xfc, 0x2d, 0x4b, 0x1f, 0xa3, 0xd6, 0x77, 0x28,
151         0x4a, 0xdd, 0xd2, 0x00, 0x12, 0x6d, 0x90, 0x69
152     };
153
154     if (ctx == NULL || sha256 == NULL || drbg == NULL || kdf == NULL)
155         goto err;
156
157     if (!EVP_DigestInit_ex(ctx, sha256, NULL))
158         goto err;
159     if (!EVP_DigestUpdate(ctx, msg, sizeof(msg) - 1))
160         goto err;
161     if (!EVP_DigestFinal(ctx, dgst, &dgstlen))
162         goto err;
163     if (dgstlen != sizeof(exptd) || memcmp(dgst, exptd, sizeof(exptd)) != 0)
164         goto err;
165
166     bnctx = BN_CTX_new_ex(libctx);
167     if (bnctx == NULL)
168         goto err;
169     BN_CTX_start(bnctx);
170     a = BN_CTX_get(bnctx);
171     b = BN_CTX_get(bnctx);
172     if (b == NULL)
173         goto err;
174     BN_zero(a);
175     if (!BN_one(b)
176         || !BN_add(a, a, b)
177         || BN_cmp(a, b) != 0)
178         goto err;
179
180     if (RAND_DRBG_bytes(drbg, randbuf, sizeof(randbuf)) <= 0)
181         goto err;
182
183     if (!BN_rand_ex(a, 256, BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY, bnctx))
184         goto err;
185
186 #ifndef OPENSSL_NO_EC
187     /* Do some dummy EC calls */
188     key = EC_KEY_new_by_curve_name_ex(libctx, NID_X9_62_prime256v1);
189     if (key == NULL)
190         goto err;
191
192     if (!EC_KEY_generate_key(key))
193         goto err;
194 #endif
195
196     ret = 1;
197  err:
198     BN_CTX_end(bnctx);
199     BN_CTX_free(bnctx);
200
201     EVP_KDF_free(kdf);
202     EVP_MD_CTX_free(ctx);
203     EVP_MD_free(sha256);
204
205 #ifndef OPENSSL_NO_EC
206     EC_KEY_free(key);
207 #endif
208     return ret;
209 }
210
211 static const OSSL_PARAM *fips_gettable_params(const OSSL_PROVIDER *prov)
212 {
213     return fips_param_types;
214 }
215
216 static int fips_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[])
217 {
218     OSSL_PARAM *p;
219
220     p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME);
221     if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL FIPS Provider"))
222         return 0;
223     p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_VERSION);
224     if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_VERSION_STR))
225         return 0;
226     p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_BUILDINFO);
227     if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_FULL_VERSION_STR))
228         return 0;
229
230     return 1;
231 }
232
233 /* FIPS specific version of the function of the same name in provlib.c */
234 const char *ossl_prov_util_nid_to_name(int nid)
235 {
236     /* We don't have OBJ_nid2n() in FIPS_MODE so we have an explicit list */
237
238     switch (nid) {
239     /* Digests */
240     case NID_sha1:
241         return "SHA1";
242     case NID_sha224:
243         return "SHA-224";
244     case NID_sha256:
245         return "SHA-256";
246     case NID_sha384:
247         return "SHA-384";
248     case NID_sha512:
249         return "SHA-512";
250     case NID_sha512_224:
251         return "SHA-512/224";
252     case NID_sha512_256:
253         return "SHA-512/256";
254     case NID_sha3_224:
255         return "SHA3-224";
256     case NID_sha3_256:
257         return "SHA3-256";
258     case NID_sha3_384:
259         return "SHA3-384";
260     case NID_sha3_512:
261         return "SHA3-512";
262
263     /* Ciphers */
264     case NID_aes_256_ecb:
265         return "AES-256-ECB";
266     case NID_aes_192_ecb:
267         return "AES-192-ECB";
268     case NID_aes_128_ecb:
269         return "AES-128-ECB";
270     case NID_aes_256_cbc:
271         return "AES-256-CBC";
272     case NID_aes_192_cbc:
273         return "AES-192-CBC";
274     case NID_aes_128_cbc:
275         return "AES-128-CBC";
276     case NID_aes_256_ctr:
277         return "AES-256-CTR";
278     case NID_aes_192_ctr:
279         return "AES-192-CTR";
280     case NID_aes_128_ctr:
281         return "AES-128-CTR";
282     case NID_aes_256_xts:
283         return "AES-256-XTS";
284     case NID_aes_128_xts:
285         return "AES-128-XTS";
286     case NID_aes_256_gcm:
287         return "AES-256-GCM";
288     case NID_aes_192_gcm:
289         return "AES-192-GCM";
290     case NID_aes_128_gcm:
291         return "AES-128-GCM";
292     case NID_aes_256_ccm:
293         return "AES-256-CCM";
294     case NID_aes_192_ccm:
295         return "AES-192-CCM";
296     case NID_aes_128_ccm:
297         return "AES-128-CCM";
298     case NID_id_aes256_wrap:
299         return "AES-256-WRAP";
300     case NID_id_aes192_wrap:
301         return "AES-192-WRAP";
302     case NID_id_aes128_wrap:
303         return "AES-128-WRAP";
304     case NID_id_aes256_wrap_pad:
305         return "AES-256-WRAP-PAD";
306     case NID_id_aes192_wrap_pad:
307         return "AES-192-WRAP-PAD";
308     case NID_id_aes128_wrap_pad:
309         return "AES-128-WRAP-PAD";
310     case NID_des_ede3_ecb:
311         return "DES-EDE3";
312     case NID_des_ede3_cbc:
313         return "DES-EDE3-CBC";
314     case NID_aes_256_cbc_hmac_sha256:
315         return "AES-256-CBC-HMAC-SHA256";
316     case NID_aes_128_cbc_hmac_sha256:
317         return "AES-128-CBC-HMAC-SHA256";
318     case NID_aes_256_cbc_hmac_sha1:
319         return "AES-256-CBC-HMAC-SHA1";
320     case NID_aes_128_cbc_hmac_sha1:
321         return "AES-128-CBC-HMAC-SHA1";
322     default:
323         break;
324     }
325
326     return NULL;
327 }
328
329 /*
330  * For the algorithm names, we use the following formula for our primary
331  * names:
332  *
333  *     ALGNAME[VERSION?][-SUBNAME[VERSION?]?][-SIZE?][-MODE?]
334  *
335  *     VERSION is only present if there are multiple versions of
336  *     an alg (MD2, MD4, MD5).  It may be omitted if there is only
337  *     one version (if a subsequent version is released in the future,
338  *     we can always change the canonical name, and add the old name
339  *     as an alias).
340  *
341  *     SUBNAME may be present where we are combining multiple
342  *     algorithms together, e.g. MD5-SHA1.
343  *
344  *     SIZE is only present if multiple versions of an algorithm exist
345  *     with different sizes (e.g. AES-128-CBC, AES-256-CBC)
346  *
347  *     MODE is only present where applicable.
348  *
349  * We add diverse other names where applicable, such as the names that
350  * NIST uses, or that are used for ASN.1 OBJECT IDENTIFIERs, or names
351  * we have used historically.
352  */
353 static const OSSL_ALGORITHM fips_digests[] = {
354     /* Our primary name:NiST name[:our older names] */
355     { "SHA1:SHA-1", "provider=fips,fips=yes", sha1_functions },
356     { "SHA2-224:SHA-224:SHA224", "provider=fips,fips=yes", sha224_functions },
357     { "SHA2-256:SHA-256:SHA256", "provider=fips,fips=yes", sha256_functions },
358     { "SHA2-384:SHA-384:SHA384", "provider=fips,fips=yes", sha384_functions },
359     { "SHA2-512:SHA-512:SHA512", "provider=fips,fips=yes", sha512_functions },
360     { "SHA2-512/224:SHA-512/224:SHA512-224", "provider=fips,fips=yes",
361       sha512_224_functions },
362     { "SHA2-512/256:SHA-512/256:SHA512-256", "provider=fips,fips=yes",
363       sha512_256_functions },
364
365     /* We agree with NIST here, so one name only */
366     { "SHA3-224", "provider=fips,fips=yes", sha3_224_functions },
367     { "SHA3-256", "provider=fips,fips=yes", sha3_256_functions },
368     { "SHA3-384", "provider=fips,fips=yes", sha3_384_functions },
369     { "SHA3-512", "provider=fips,fips=yes", sha3_512_functions },
370
371     /* Non-FIPS algorithm to support oneshot_hash in the Ed448 code */
372     { "SHAKE-256:SHAKE256", "provider=fips,fips=no", shake_256_functions },
373     { NULL, NULL, NULL }
374 };
375
376 static const OSSL_ALGORITHM_CAPABLE fips_ciphers[] = {
377     /* Our primary name[:ASN.1 OID name][:our older names] */
378     ALG("AES-256-ECB", aes256ecb_functions),
379     ALG("AES-192-ECB", aes192ecb_functions),
380     ALG("AES-128-ECB", aes128ecb_functions),
381     ALG("AES-256-CBC", aes256cbc_functions),
382     ALG("AES-192-CBC", aes192cbc_functions),
383     ALG("AES-128-CBC", aes128cbc_functions),
384     ALG("AES-256-CTR", aes256ctr_functions),
385     ALG("AES-192-CTR", aes192ctr_functions),
386     ALG("AES-128-CTR", aes128ctr_functions),
387     ALG("AES-256-XTS", aes256xts_functions),
388     ALG("AES-128-XTS", aes128xts_functions),
389     ALG("AES-256-GCM:id-aes256-GCM", aes256gcm_functions),
390     ALG("AES-192-GCM:id-aes192-GCM", aes192gcm_functions),
391     ALG("AES-128-GCM:id-aes128-GCM", aes128gcm_functions),
392     ALG("AES-256-CCM:id-aes256-CCM", aes256ccm_functions),
393     ALG("AES-192-CCM:id-aes192-CCM", aes192ccm_functions),
394     ALG("AES-128-CCM:id-aes128-CCM", aes128ccm_functions),
395     ALG("AES-256-WRAP:id-aes256-wrap:AES256-WRAP", aes256wrap_functions),
396     ALG("AES-192-WRAP:id-aes192-wrap:AES192-WRAP", aes192wrap_functions),
397     ALG("AES-128-WRAP:id-aes128-wrap:AES128-WRAP", aes128wrap_functions),
398     ALG("AES-256-WRAP-PAD:id-aes256-wrap-pad:AES256-WRAP-PAD",
399         aes256wrappad_functions),
400     ALG("AES-192-WRAP-PAD:id-aes192-wrap-pad:AES192-WRAP-PAD",
401         aes192wrappad_functions),
402     ALG("AES-128-WRAP-PAD:id-aes128-wrap-pad:AES128-WRAP-PAD",
403         aes128wrappad_functions),
404     ALGC("AES-128-CBC-HMAC-SHA1", aes128cbc_hmac_sha1_functions,
405          cipher_capable_aes_cbc_hmac_sha1),
406     ALGC("AES-256-CBC-HMAC-SHA1", aes256cbc_hmac_sha1_functions,
407          cipher_capable_aes_cbc_hmac_sha1),
408     ALGC("AES-128-CBC-HMAC-SHA256", aes128cbc_hmac_sha256_functions,
409          cipher_capable_aes_cbc_hmac_sha256),
410     ALGC("AES-256-CBC-HMAC-SHA256", aes256cbc_hmac_sha256_functions,
411          cipher_capable_aes_cbc_hmac_sha256),
412 #ifndef OPENSSL_NO_DES
413     ALG("DES-EDE3-ECB:DES-EDE3", tdes_ede3_ecb_functions),
414     ALG("DES-EDE3-CBC:DES3", tdes_ede3_cbc_functions),
415 #endif  /* OPENSSL_NO_DES */
416     { { NULL, NULL, NULL }, NULL }
417 };
418 static OSSL_ALGORITHM exported_fips_ciphers[OSSL_NELEM(fips_ciphers)];
419
420 static const OSSL_ALGORITHM fips_macs[] = {
421     { "GMAC", "provider=fips,fips=yes", gmac_functions },
422     { "HMAC", "provider=fips,fips=yes", hmac_functions },
423     { NULL, NULL, NULL }
424 };
425
426 static const OSSL_ALGORITHM fips_kdfs[] = {
427     { "HKDF", "provider=fips,fips=yes", kdf_hkdf_functions },
428     { "SSKDF", "provider=fips,fips=yes", kdf_sskdf_functions },
429     { "PBKDF2", "provider=fips,fips=yes", kdf_pbkdf2_functions },
430     { "TLS1-PRF", "provider=fips,fips=yes", kdf_tls1_prf_functions },
431     { NULL, NULL, NULL }
432 };
433
434 static const OSSL_ALGORITHM fips_keyexch[] = {
435 #ifndef OPENSSL_NO_DH
436     { "DH:dhKeyAgreement", "provider=fips,fips=yes", dh_keyexch_functions },
437 #endif
438 #ifndef OPENSSL_NO_EC
439     { "ECDH", "provider=fips,fips=yes", ecdh_keyexch_functions },
440     { "X25519", "provider=fips,fips=no", x25519_keyexch_functions },
441     { "X448", "provider=fips,fips=no", x448_keyexch_functions },
442 #endif
443     { NULL, NULL, NULL }
444 };
445
446 static const OSSL_ALGORITHM fips_signature[] = {
447 #ifndef OPENSSL_NO_DSA
448     { "DSA:dsaEncryption", "provider=fips,fips=yes", dsa_signature_functions },
449 #endif
450     { "RSA:rsaEncryption", "provider=fips,fips=yes", rsa_signature_functions },
451 #ifndef OPENSSL_NO_EC
452     { "ED25519", "provider=fips,fips=no", ed25519_signature_functions },
453     { "ED448", "provider=fips,fips=no", ed448_signature_functions },
454     { "ECDSA", "provider=fips,fips=yes", ecdsa_signature_functions },
455 #endif
456     { NULL, NULL, NULL }
457 };
458
459 static const OSSL_ALGORITHM fips_asym_cipher[] = {
460     { "RSA:rsaEncryption", "provider=fips,fips=yes", rsa_asym_cipher_functions },
461     { NULL, NULL, NULL }
462 };
463
464 static const OSSL_ALGORITHM fips_keymgmt[] = {
465 #ifndef OPENSSL_NO_DH
466     { "DH:dhKeyAgreement", "provider=fips,fips=yes", dh_keymgmt_functions },
467 #endif
468 #ifndef OPENSSL_NO_DSA
469     { "DSA", "provider=fips,fips=yes", dsa_keymgmt_functions },
470 #endif
471     { "RSA:rsaEncryption", "provider=fips,fips=yes", rsa_keymgmt_functions },
472 #ifndef OPENSSL_NO_EC
473     { "EC:id-ecPublicKey", "provider=fips,fips=yes", ec_keymgmt_functions },
474     { "X25519", "provider=fips,fips=no", x25519_keymgmt_functions },
475     { "X448", "provider=fips,fips=no", x448_keymgmt_functions },
476     { "ED25519", "provider=fips,fips=no", ed25519_keymgmt_functions },
477     { "ED448", "provider=fips,fips=no", ed448_keymgmt_functions },
478 #endif
479     { NULL, NULL, NULL }
480 };
481
482 static const OSSL_ALGORITHM *fips_query(OSSL_PROVIDER *prov,
483                                          int operation_id,
484                                          int *no_cache)
485 {
486     *no_cache = 0;
487     switch (operation_id) {
488     case OSSL_OP_DIGEST:
489         return fips_digests;
490     case OSSL_OP_CIPHER:
491         ossl_prov_cache_exported_algorithms(fips_ciphers, exported_fips_ciphers);
492         return exported_fips_ciphers;
493     case OSSL_OP_MAC:
494         return fips_macs;
495     case OSSL_OP_KDF:
496         return fips_kdfs;
497     case OSSL_OP_KEYMGMT:
498         return fips_keymgmt;
499     case OSSL_OP_KEYEXCH:
500         return fips_keyexch;
501     case OSSL_OP_SIGNATURE:
502         return fips_signature;
503     case OSSL_OP_ASYM_CIPHER:
504         return fips_asym_cipher;
505     }
506     return NULL;
507 }
508
509 /* Functions we provide to the core */
510 static const OSSL_DISPATCH fips_dispatch_table[] = {
511     /*
512      * To release our resources we just need to free the OPENSSL_CTX so we just
513      * use OPENSSL_CTX_free directly as our teardown function
514      */
515     { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))OPENSSL_CTX_free },
516     { OSSL_FUNC_PROVIDER_GETTABLE_PARAMS, (void (*)(void))fips_gettable_params },
517     { OSSL_FUNC_PROVIDER_GET_PARAMS, (void (*)(void))fips_get_params },
518     { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query },
519     { 0, NULL }
520 };
521
522 /* Functions we provide to ourself */
523 static const OSSL_DISPATCH intern_dispatch_table[] = {
524     { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fips_query },
525     { 0, NULL }
526 };
527
528
529 int OSSL_provider_init(const OSSL_PROVIDER *provider,
530                        const OSSL_DISPATCH *in,
531                        const OSSL_DISPATCH **out,
532                        void **provctx)
533 {
534     FIPS_GLOBAL *fgbl;
535     OPENSSL_CTX *ctx;
536     OSSL_self_test_cb_fn *stcbfn = NULL;
537     OSSL_core_get_library_context_fn *c_get_libctx = NULL;
538
539     for (; in->function_id != 0; in++) {
540         switch (in->function_id) {
541         case OSSL_FUNC_CORE_GET_LIBRARY_CONTEXT:
542             c_get_libctx = OSSL_get_core_get_library_context(in);
543             break;
544         case OSSL_FUNC_CORE_GETTABLE_PARAMS:
545             c_gettable_params = OSSL_get_core_gettable_params(in);
546             break;
547         case OSSL_FUNC_CORE_GET_PARAMS:
548             c_get_params = OSSL_get_core_get_params(in);
549             break;
550         case OSSL_FUNC_CORE_THREAD_START:
551             c_thread_start = OSSL_get_core_thread_start(in);
552             break;
553         case OSSL_FUNC_CORE_NEW_ERROR:
554             c_new_error = OSSL_get_core_new_error(in);
555             break;
556         case OSSL_FUNC_CORE_SET_ERROR_DEBUG:
557             c_set_error_debug = OSSL_get_core_set_error_debug(in);
558             break;
559         case OSSL_FUNC_CORE_VSET_ERROR:
560             c_vset_error = OSSL_get_core_vset_error(in);
561             break;
562         case OSSL_FUNC_CORE_SET_ERROR_MARK:
563             c_set_error_mark = OSSL_get_core_set_error_mark(in);
564             break;
565         case OSSL_FUNC_CORE_CLEAR_LAST_ERROR_MARK:
566             c_clear_last_error_mark = OSSL_get_core_clear_last_error_mark(in);
567             break;
568         case OSSL_FUNC_CORE_POP_ERROR_TO_MARK:
569             c_pop_error_to_mark = OSSL_get_core_pop_error_to_mark(in);
570             break;
571         case OSSL_FUNC_CRYPTO_MALLOC:
572             c_CRYPTO_malloc = OSSL_get_CRYPTO_malloc(in);
573             break;
574         case OSSL_FUNC_CRYPTO_ZALLOC:
575             c_CRYPTO_zalloc = OSSL_get_CRYPTO_zalloc(in);
576             break;
577         case OSSL_FUNC_CRYPTO_FREE:
578             c_CRYPTO_free = OSSL_get_CRYPTO_free(in);
579             break;
580         case OSSL_FUNC_CRYPTO_CLEAR_FREE:
581             c_CRYPTO_clear_free = OSSL_get_CRYPTO_clear_free(in);
582             break;
583         case OSSL_FUNC_CRYPTO_REALLOC:
584             c_CRYPTO_realloc = OSSL_get_CRYPTO_realloc(in);
585             break;
586         case OSSL_FUNC_CRYPTO_CLEAR_REALLOC:
587             c_CRYPTO_clear_realloc = OSSL_get_CRYPTO_clear_realloc(in);
588             break;
589         case OSSL_FUNC_CRYPTO_SECURE_MALLOC:
590             c_CRYPTO_secure_malloc = OSSL_get_CRYPTO_secure_malloc(in);
591             break;
592         case OSSL_FUNC_CRYPTO_SECURE_ZALLOC:
593             c_CRYPTO_secure_zalloc = OSSL_get_CRYPTO_secure_zalloc(in);
594             break;
595         case OSSL_FUNC_CRYPTO_SECURE_FREE:
596             c_CRYPTO_secure_free = OSSL_get_CRYPTO_secure_free(in);
597             break;
598         case OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE:
599             c_CRYPTO_secure_clear_free = OSSL_get_CRYPTO_secure_clear_free(in);
600             break;
601         case OSSL_FUNC_CRYPTO_SECURE_ALLOCATED:
602             c_CRYPTO_secure_allocated = OSSL_get_CRYPTO_secure_allocated(in);
603             break;
604         case OSSL_FUNC_BIO_NEW_FILE:
605             selftest_params.bio_new_file_cb = OSSL_get_BIO_new_file(in);
606             break;
607         case OSSL_FUNC_BIO_NEW_MEMBUF:
608             selftest_params.bio_new_buffer_cb = OSSL_get_BIO_new_membuf(in);
609             break;
610         case OSSL_FUNC_BIO_READ_EX:
611             selftest_params.bio_read_ex_cb = OSSL_get_BIO_read_ex(in);
612             break;
613         case OSSL_FUNC_BIO_FREE:
614             selftest_params.bio_free_cb = OSSL_get_BIO_free(in);
615             break;
616         case OSSL_FUNC_BIO_VSNPRINTF:
617             c_BIO_vsnprintf = OSSL_get_BIO_vsnprintf(in);
618             break;
619         case OSSL_FUNC_SELF_TEST_CB: {
620             stcbfn = OSSL_get_self_test_cb(in);
621             break;
622         }
623         default:
624             /* Just ignore anything we don't understand */
625             break;
626         }
627     }
628
629     if (stcbfn != NULL && c_get_libctx != NULL) {
630         stcbfn(c_get_libctx(provider), &selftest_params.cb,
631                &selftest_params.cb_arg);
632     }
633     else {
634         selftest_params.cb = NULL;
635         selftest_params.cb_arg = NULL;
636     }
637
638     if (!c_get_params(provider, core_params))
639         return 0;
640
641     /*  Create a context. */
642     if ((ctx = OPENSSL_CTX_new()) == NULL)
643         return 0;
644     if ((fgbl = openssl_ctx_get_data(ctx, OPENSSL_CTX_FIPS_PROV_INDEX,
645                                      &fips_prov_ossl_ctx_method)) == NULL) {
646         OPENSSL_CTX_free(ctx);
647         return 0;
648     }
649
650     fgbl->prov = provider;
651
652     selftest_params.libctx = PROV_LIBRARY_CONTEXT_OF(ctx);
653     if (!SELF_TEST_post(&selftest_params, 0)) {
654         OPENSSL_CTX_free(ctx);
655         return 0;
656     }
657
658     /*
659      * TODO(3.0): Remove me. This is just a dummy call to demonstrate making
660      * EVP calls from within the FIPS module.
661      */
662     if (!dummy_evp_call(ctx)) {
663         OPENSSL_CTX_free(ctx);
664         return 0;
665     }
666
667     *out = fips_dispatch_table;
668     *provctx = ctx;
669
670     return 1;
671 }
672
673 /*
674  * The internal init function used when the FIPS module uses EVP to call
675  * another algorithm also in the FIPS module. This is a recursive call that has
676  * been made from within the FIPS module itself. To make this work, we populate
677  * the provider context of this inner instance with the same library context
678  * that was used in the EVP call that initiated this recursive call.
679  */
680 OSSL_provider_init_fn fips_intern_provider_init;
681 int fips_intern_provider_init(const OSSL_PROVIDER *provider,
682                               const OSSL_DISPATCH *in,
683                               const OSSL_DISPATCH **out,
684                               void **provctx)
685 {
686     OSSL_core_get_library_context_fn *c_get_libctx = NULL;
687
688     for (; in->function_id != 0; in++) {
689         switch (in->function_id) {
690         case OSSL_FUNC_CORE_GET_LIBRARY_CONTEXT:
691             c_get_libctx = OSSL_get_core_get_library_context(in);
692             break;
693         default:
694             break;
695         }
696     }
697
698     if (c_get_libctx == NULL)
699         return 0;
700
701     *provctx = c_get_libctx(provider);
702
703     /*
704      * Safety measure...  we should get the library context that was
705      * created up in OSSL_provider_init().
706      */
707     if (*provctx == NULL)
708         return 0;
709
710     *out = intern_dispatch_table;
711     return 1;
712 }
713
714 void ERR_new(void)
715 {
716     c_new_error(NULL);
717 }
718
719 void ERR_set_debug(const char *file, int line, const char *func)
720 {
721     c_set_error_debug(NULL, file, line, func);
722 }
723
724 void ERR_set_error(int lib, int reason, const char *fmt, ...)
725 {
726     va_list args;
727
728     va_start(args, fmt);
729     c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args);
730     va_end(args);
731 }
732
733 void ERR_vset_error(int lib, int reason, const char *fmt, va_list args)
734 {
735     c_vset_error(NULL, ERR_PACK(lib, 0, reason), fmt, args);
736 }
737
738 int ERR_set_mark(void)
739 {
740     return c_set_error_mark(NULL);
741 }
742
743 int ERR_clear_last_mark(void)
744 {
745     return c_clear_last_error_mark(NULL);
746 }
747
748 int ERR_pop_to_mark(void)
749 {
750     return c_pop_error_to_mark(NULL);
751 }
752
753 const OSSL_PROVIDER *FIPS_get_provider(OPENSSL_CTX *ctx)
754 {
755     FIPS_GLOBAL *fgbl = openssl_ctx_get_data(ctx, OPENSSL_CTX_FIPS_PROV_INDEX,
756                                              &fips_prov_ossl_ctx_method);
757
758     if (fgbl == NULL)
759         return NULL;
760
761     return fgbl->prov;
762 }
763
764 void *CRYPTO_malloc(size_t num, const char *file, int line)
765 {
766     return c_CRYPTO_malloc(num, file, line);
767 }
768
769 void *CRYPTO_zalloc(size_t num, const char *file, int line)
770 {
771     return c_CRYPTO_zalloc(num, file, line);
772 }
773
774 void CRYPTO_free(void *ptr, const char *file, int line)
775 {
776     c_CRYPTO_free(ptr, file, line);
777 }
778
779 void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line)
780 {
781     c_CRYPTO_clear_free(ptr, num, file, line);
782 }
783
784 void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line)
785 {
786     return c_CRYPTO_realloc(addr, num, file, line);
787 }
788
789 void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
790                            const char *file, int line)
791 {
792     return c_CRYPTO_clear_realloc(addr, old_num, num, file, line);
793 }
794
795 void *CRYPTO_secure_malloc(size_t num, const char *file, int line)
796 {
797     return c_CRYPTO_secure_malloc(num, file, line);
798 }
799
800 void *CRYPTO_secure_zalloc(size_t num, const char *file, int line)
801 {
802     return c_CRYPTO_secure_zalloc(num, file, line);
803 }
804
805 void CRYPTO_secure_free(void *ptr, const char *file, int line)
806 {
807     c_CRYPTO_secure_free(ptr, file, line);
808 }
809
810 void CRYPTO_secure_clear_free(void *ptr, size_t num, const char *file, int line)
811 {
812     c_CRYPTO_secure_clear_free(ptr, num, file, line);
813 }
814
815 int CRYPTO_secure_allocated(const void *ptr)
816 {
817     return c_CRYPTO_secure_allocated(ptr);
818 }
819
820 int BIO_snprintf(char *buf, size_t n, const char *format, ...)
821 {
822     va_list args;
823     int ret;
824
825     va_start(args, format);
826     ret = c_BIO_vsnprintf(buf, n, format, args);
827     va_end(args);
828     return ret;
829 }