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