Add AES_CBC_HMAC_SHA ciphers to providers.

Also Add ability for providers to dynamically exclude cipher algorithms.
Cipher algorithms are only returned from providers if their capable() method is either NULL,
or the method returns 1.
This is mainly required for ciphers that only have hardware implementations.
If there is no hardware support, then the algorithm needs to be not available.

Reviewed-by: Matt Caswell <matt@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/10146)

17 files changed, 2529 insertions, 197 deletions

diff --git a/crypto/aes/build.info b/crypto/aes/build.info
index 291bf2af9b..dc00df0cda 100644
--- a/crypto/aes/build.info
+++ b/crypto/aes/build.info
@@ -68,8 +68,6 @@ SOURCE[../../providers/libfips.a]=$COMMON
 DEFINE[../../libcrypto]=$AESDEF
 DEFINE[../../providers/libfips.a]=$AESDEF
 DEFINE[../../providers/libimplementations.a]=$AESDEF
-# fipsprov.c needs access to AESNI.
-DEFINE[../../providers/fips]=$AESDEF
 
 GENERATE[aes-ia64.s]=asm/aes-ia64.S
 
diff --git a/crypto/evp/evp_enc.c b/crypto/evp/evp_enc.c
index 3896cff34d..c650addbd1 100644
--- a/crypto/evp/evp_enc.c
+++ b/crypto/evp/evp_enc.c
@@ -174,6 +174,10 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
         case NID_aes_256_siv:
         case NID_aes_192_siv:
         case NID_aes_128_siv:
+        case NID_aes_256_cbc_hmac_sha256:
+        case NID_aes_128_cbc_hmac_sha256:
+        case NID_aes_256_cbc_hmac_sha1:
+        case NID_aes_128_cbc_hmac_sha1:
         case NID_id_aes256_wrap:
         case NID_id_aes256_wrap_pad:
         case NID_id_aes192_wrap:
@@ -1086,7 +1090,9 @@ int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
     int set_params = 1;
     size_t sz = arg;
     unsigned int i;
-    OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
+    OSSL_PARAM params[4] = {
+        OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END
+    };
 
     if (ctx == NULL || ctx->cipher == NULL) {
         EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET);
@@ -1154,13 +1160,8 @@ int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
         params[0] = OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG,
                                                       ptr, sz);
         break;
-    case EVP_CTRL_AEAD_SET_MAC_KEY:
-        params[0] =
-            OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_MAC_KEY,
-                                              ptr, sz);
-        break;
     case EVP_CTRL_AEAD_TLS1_AAD:
-        /* This one does a set and a get - since it returns a padding size */
+        /* This one does a set and a get - since it returns a size */
         params[0] =
             OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD,
                                               ptr, sz);
@@ -1180,6 +1181,76 @@ int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
         params[0] = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_RC2_KEYBITS, &sz);
         break;
 #endif /* OPENSSL_NO_RC2 */
+#if !defined(OPENSSL_NO_MULTIBLOCK)
+    case EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE:
+        params[0] = OSSL_PARAM_construct_size_t(
+                OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT, &sz);
+        ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->provctx, params);
+        if (ret <= 0)
+            return 0;
+
+        params[0] = OSSL_PARAM_construct_size_t(
+                OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE, &sz);
+        params[1] = OSSL_PARAM_construct_end();
+        ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->provctx, params);
+        if (ret <= 0)
+            return 0;
+        return sz;
+    case EVP_CTRL_TLS1_1_MULTIBLOCK_AAD: {
+        EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *p =
+            (EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *)ptr;
+
+        if (arg < (int)sizeof(EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM))
+            return 0;
+
+        params[0] = OSSL_PARAM_construct_octet_string(
+                OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD, (void*)p->inp, p->len);
+        params[1] = OSSL_PARAM_construct_uint(
+                OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, &p->interleave);
+        ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->provctx, params);
+        if (ret <= 0)
+            return ret;
+        /* Retrieve the return values changed by the set */
+        params[0] = OSSL_PARAM_construct_size_t(
+                OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN, &sz);
+        params[1] = OSSL_PARAM_construct_uint(
+                OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, &p->interleave);
+        params[2] = OSSL_PARAM_construct_end();
+        ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->provctx, params);
+        if (ret <= 0)
+            return 0;
+        return sz;
+    }
+    case EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT: {
+        EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *p =
+            (EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *)ptr;
+
+        params[0] = OSSL_PARAM_construct_octet_string(
+                        OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC, p->out, p->len);
+
+        params[1] = OSSL_PARAM_construct_octet_string(
+                OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN, (void*)p->inp,
+                p->len);
+        params[2] = OSSL_PARAM_construct_uint(
+                OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, &p->interleave);
+        ret = evp_do_ciph_ctx_setparams(ctx->cipher, ctx->provctx, params);
+        if (ret <= 0)
+            return ret;
+        params[0] = OSSL_PARAM_construct_size_t(
+                        OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN, &sz);
+        params[1] = OSSL_PARAM_construct_end();
+        ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->provctx, params);
+        if (ret <= 0)
+            return 0;
+        return sz;
+    }
+#endif /* OPENSSL_NO_MULTIBLOCK */
+    case EVP_CTRL_AEAD_SET_MAC_KEY:
+        if (arg < 0)
+            return -1;
+        params[0] = OSSL_PARAM_construct_octet_string(
+                OSSL_CIPHER_PARAM_AEAD_MAC_KEY, ptr, sz);
+        break;
     }
 
     if (set_params)
diff --git a/doc/man7/provider-cipher.pod b/doc/man7/provider-cipher.pod
index 5e64c0e196..7ad239bcb6 100644
--- a/doc/man7/provider-cipher.pod
+++ b/doc/man7/provider-cipher.pod
@@ -349,6 +349,55 @@ by AES SIV ciphers which disallow multiple operations by default.
 Setting "speed" to 1 allows another encrypt or decrypt operation to be
 performed. This is used for performance testing.
 
+=item "tls1multi_enc" (B<OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC>) <octet string>
+
+Triggers a multiblock tls1 encrypt operation for a tls1 aware cipher that supports
+sending 4 or 8 records in one go.
+The cipher performs both the MAC and encrypt stages and constructs the record
+headers itself.
+"tls1multi_enc" supplies the output buffer for the encrypt operation,
+"tls1multi_encin" & "tls1multi_interleave" must also be set in order to supply
+values to the encrypt operation.
+
+=item "tls1multi_enclen" (B<OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN>) <unsigned integer>
+
+Get the total length of the record returned from the "tls1multi_enc" operation.
+
+=item "tls1multi_interleave" (B<OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE>) <unsigned integer>
+
+Sets or gets the number of records being sent in one go for a tls1 multiblock
+cipher operation (either 4 or 8 records).
+
+=item "tls1multi_encin" (B<OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN>) <octet string>
+
+Supplies the data to encrypt for a tls1 multiblock cipher operation.
+
+=item "tls1multi_maxsndfrag" (B<OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT>) <unsigned integer>
+
+Sets the maximum send fragment size for a tls1 multiblock cipher operation.
+It must be set before using "tls1multi_maxbufsz".
+The length of the "tls1multi_maxsndfrag" parameter should not exceed that of a B<size_t>.
+
+=item "tls1multi_maxbufsz" (B<OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE>) <unsigned integer>
+
+Gets the maximum record length for a tls1 multiblock cipher operation.
+The length of the "tls1multi_maxbufsz" parameter should not exceed that of a B<size_t>.
+
+=item "tls1multi_aad" (B<OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD>) <octet string>
+
+Sets the authenticated additional data used by a tls1 multiblock cipher operation.
+The supplied data consists of 13 bytes of record data containing:
+Bytes 0-7: The sequence number of the first record
+Byte 8: The record type
+Byte 9-10: The protocol version
+Byte 11-12: Input length (Always 0)
+
+"tls1multi_interleave" must also be set for this operation.
+
+=item "tls1multi_aadpacklen" (B<OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN>) <unsigned integer>
+
+Gets the result of running the "tls1multi_aad" operation.
+
 =back
 
 =head1 RETURN VALUES
diff --git a/include/crypto/aes_platform.h b/include/crypto/aes_platform.h
index 483a1949ee..b478520cf8 100644
--- a/include/crypto/aes_platform.h
+++ b/include/crypto/aes_platform.h
@@ -121,6 +121,13 @@ void gcm_ghash_v8(u64 Xi[2],const u128 Htable[16],const u8 *inp, size_t len);
 #  endif
 # endif /* OPENSSL_CPUID_OBJ */
 
+# if     defined(AES_ASM) &&     ( \
+         defined(__x86_64)       || defined(__x86_64__)  || \
+         defined(_M_AMD64)       || defined(_M_X64)      )
+#  define AES_CBC_HMAC_SHA_CAPABLE 1
+#  define AESNI_CBC_HMAC_SHA_CAPABLE (OPENSSL_ia32cap_P[1]&(1<<(57-32)))
+# endif
+
 # if     defined(AES_ASM) && !defined(I386_ONLY) &&      (  \
          ((defined(__i386)       || defined(__i386__)    || \
            defined(_M_IX86)) && defined(OPENSSL_IA32_SSE2))|| \
diff --git a/include/openssl/core_names.h b/include/openssl/core_names.h
index e441ddf6c8..446af5fa8e 100644
--- a/include/openssl/core_names.h
+++ b/include/openssl/core_names.h
@@ -73,6 +73,22 @@ extern "C" {
 /* For passing the AlgorithmIdentifier parameter in DER form */
 #define OSSL_CIPHER_PARAM_ALG_ID             "alg_id_param" /* octet_string */
 
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT                    \
+    "tls1multi_maxsndfrag" /* uint */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE                          \
+    "tls1multi_maxbufsz"   /* size_t */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE                           \
+    "tls1multi_interleave" /* uint */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD                                  \
+    "tls1multi_aad"        /* octet_string */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN                          \
+    "tls1multi_aadpacklen" /* uint */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC                                  \
+    "tls1multi_enc"        /* octet_string */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN                               \
+    "tls1multi_encin"      /* octet_string */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN                              \
+    "tls1multi_enclen"     /* size_t */
 
 /* digest parameters */
 #define OSSL_DIGEST_PARAM_XOFLEN     "xoflen"    /* size_t */
diff --git a/providers/common/include/prov/provider_util.h b/providers/common/include/prov/provider_util.h
index 9925ac2b09..ca3550b3f7 100644
--- a/providers/common/include/prov/provider_util.h
+++ b/providers/common/include/prov/provider_util.h
@@ -101,3 +101,15 @@ int ossl_prov_macctx_load_from_params(EVP_MAC_CTX **macctx,
                                       const char *ciphername,
                                       const char *mdname,
                                       OPENSSL_CTX *ctx);
+
+typedef struct ag_capable_st {
+    OSSL_ALGORITHM alg;
+    int (*capable)(void);
+} OSSL_ALGORITHM_CAPABLE;
+
+/*
+ * Dynamically select algorithms by calling a capable() method.
+ * If this method is NULL or the method returns 1 then the algorithm is added.
+ */
+void ossl_prov_cache_exported_algorithms(const OSSL_ALGORITHM_CAPABLE *in,
+                                         OSSL_ALGORITHM *out);
diff --git a/providers/common/include/prov/providercommon.h b/providers/common/include/prov/providercommon.h
index 569c08c0b1..995c685292 100644
--- a/providers/common/include/prov/providercommon.h
+++ b/providers/common/include/prov/providercommon.h
@@ -13,3 +13,5 @@ const OSSL_PROVIDER *FIPS_get_provider(OPENSSL_CTX *ctx);
 
 const char *ossl_prov_util_nid_to_name(int nid);
 
+int cipher_capable_aes_cbc_hmac_sha1(void);
+int cipher_capable_aes_cbc_hmac_sha256(void);
diff --git a/providers/common/provider_util.c b/providers/common/provider_util.c
index ef4396f432..504463df19 100644
--- a/providers/common/provider_util.c
+++ b/providers/common/provider_util.c
@@ -237,3 +237,17 @@ int ossl_prov_macctx_load_from_params(EVP_MAC_CTX **macctx,
     *macctx = NULL;
     return 0;
 }
+
+void ossl_prov_cache_exported_algorithms(const OSSL_ALGORITHM_CAPABLE *in,
+                                         OSSL_ALGORITHM *out)
+{
+    int i, j;
+
+    if (out[0].algorithm_names == NULL) {
+        for (i = j = 0; in[i].alg.algorithm_names != NULL; ++i) {
+            if (in[i].capable == NULL || in[i].capable())
+                out[j++] = in[i].alg;
+        }
+        out[j++] = in[i].alg;
+    }
+}
diff --git a/providers/defltprov.c b/providers/defltprov.c
index 51cd2b9794..5c11b4a910 100644
--- a/providers/defltprov.c
+++ b/providers/defltprov.c
@@ -15,7 +15,13 @@
 #include <openssl/core_names.h>
 #include <openssl/params.h>
 #include "prov/bio.h"
+#include "prov/providercommon.h"
 #include "prov/implementations.h"
+#include "prov/provider_util.h"
+#include "internal/nelem.h"
+
+#define ALGC(NAMES, FUNC, CHECK) { { NAMES, "default=yes", FUNC }, CHECK }
+#define ALG(NAMES, FUNC) ALGC(NAMES, FUNC, NULL)
 
 /* Functions provided by the core */
 static OSSL_core_gettable_params_fn *c_gettable_params = NULL;
@@ -131,190 +137,196 @@ static const OSSL_ALGORITHM deflt_digests[] = {
     { NULL, NULL, NULL }
 };
 
-static const OSSL_ALGORITHM deflt_ciphers[] = {
-    { "AES-256-ECB", "default=yes", aes256ecb_functions },
-    { "AES-192-ECB", "default=yes", aes192ecb_functions },
-    { "AES-128-ECB", "default=yes", aes128ecb_functions },
-    { "AES-256-CBC", "default=yes", aes256cbc_functions },
-    { "AES-192-CBC", "default=yes", aes192cbc_functions },
-    { "AES-128-CBC", "default=yes", aes128cbc_functions },
-    { "AES-256-OFB", "default=yes", aes256ofb_functions },
-    { "AES-192-OFB", "default=yes", aes192ofb_functions },
-    { "AES-128-OFB", "default=yes", aes128ofb_functions },
-    { "AES-256-CFB", "default=yes", aes256cfb_functions },
-    { "AES-192-CFB", "default=yes", aes192cfb_functions },
-    { "AES-128-CFB", "default=yes", aes128cfb_functions },
-    { "AES-256-CFB1", "default=yes", aes256cfb1_functions },
-    { "AES-192-CFB1", "default=yes", aes192cfb1_functions },
-    { "AES-128-CFB1", "default=yes", aes128cfb1_functions },
-    { "AES-256-CFB8", "default=yes", aes256cfb8_functions },
-    { "AES-192-CFB8", "default=yes", aes192cfb8_functions },
-    { "AES-128-CFB8", "default=yes", aes128cfb8_functions },
-    { "AES-256-CTR", "default=yes", aes256ctr_functions },
-    { "AES-192-CTR", "default=yes", aes192ctr_functions },
-    { "AES-128-CTR", "default=yes", aes128ctr_functions },
-    { "AES-256-XTS", "default=yes", aes256xts_functions },
-    { "AES-128-XTS", "default=yes", aes128xts_functions },
+static const OSSL_ALGORITHM_CAPABLE deflt_ciphers[] = {
+    ALG("AES-256-ECB", aes256ecb_functions),
+    ALG("AES-192-ECB", aes192ecb_functions),
+    ALG("AES-128-ECB", aes128ecb_functions),
+    ALG("AES-256-CBC", aes256cbc_functions),
+    ALG("AES-192-CBC", aes192cbc_functions),
+    ALG("AES-128-CBC", aes128cbc_functions),
+    ALG("AES-256-OFB", aes256ofb_functions),
+    ALG("AES-192-OFB", aes192ofb_functions),
+    ALG("AES-128-OFB", aes128ofb_functions),
+    ALG("AES-256-CFB", aes256cfb_functions),
+    ALG("AES-192-CFB", aes192cfb_functions),
+    ALG("AES-128-CFB", aes128cfb_functions),
+    ALG("AES-256-CFB1", aes256cfb1_functions),
+    ALG("AES-192-CFB1", aes192cfb1_functions),
+    ALG("AES-128-CFB1", aes128cfb1_functions),
+    ALG("AES-256-CFB8", aes256cfb8_functions),
+    ALG("AES-192-CFB8", aes192cfb8_functions),
+    ALG("AES-128-CFB8", aes128cfb8_functions),
+    ALG("AES-256-CTR", aes256ctr_functions),
+    ALG("AES-192-CTR", aes192ctr_functions),
+    ALG("AES-128-CTR", aes128ctr_functions),
+    ALG("AES-256-XTS", aes256xts_functions),
+    ALG("AES-128-XTS", aes128xts_functions),
 #ifndef OPENSSL_NO_OCB
-    { "AES-256-OCB", "default=yes", aes256ocb_functions },
-    { "AES-192-OCB", "default=yes", aes192ocb_functions },
-    { "AES-128-OCB", "default=yes", aes128ocb_functions },
+    ALG("AES-256-OCB", aes256ocb_functions),
+    ALG("AES-192-OCB", aes192ocb_functions),
+    ALG("AES-128-OCB", aes128ocb_functions),
 #endif /* OPENSSL_NO_OCB */
 #ifndef OPENSSL_NO_SIV
-    { "AES-128-SIV", "default=yes", aes128siv_functions },
-    { "AES-192-SIV", "default=yes", aes192siv_functions },
-    { "AES-256-SIV", "default=yes", aes256siv_functions },
+    ALG("AES-128-SIV", aes128siv_functions),
+    ALG("AES-192-SIV", aes192siv_functions),
+    ALG("AES-256-SIV", aes256siv_functions),
 #endif /* OPENSSL_NO_SIV */
-    { "AES-256-GCM:id-aes256-GCM", "default=yes", aes256gcm_functions },
-    { "AES-192-GCM:id-aes192-GCM", "default=yes", aes192gcm_functions },
-    { "AES-128-GCM:id-aes128-GCM", "default=yes", aes128gcm_functions },
-    { "AES-256-CCM:id-aes256-CCM", "default=yes", aes256ccm_functions },
-    { "AES-192-CCM:id-aes192-CCM", "default=yes", aes192ccm_functions },
-    { "AES-128-CCM:id-aes128-CCM", "default=yes", aes128ccm_functions },
-    { "AES-256-WRAP:id-aes256-wrap:AES256-WRAP", "default=yes",
-      aes256wrap_functions },
-    { "AES-192-WRAP:id-aes192-wrap:AES192-WRAP", "default=yes",
-      aes192wrap_functions },
-    { "AES-128-WRAP:id-aes128-wrap:AES128-WRAP", "default=yes",
-      aes128wrap_functions },
-    { "AES-256-WRAP-PAD:id-aes256-wrap-pad:AES256-WRAP-PAD", "default=yes",
-      aes256wrappad_functions },
-    { "AES-192-WRAP-PAD:id-aes192-wrap-pad:AES192-WRAP-PAD", "default=yes",
-      aes192wrappad_functions },
-    { "AES-128-WRAP-PAD:id-aes128-wrap-pad:AES128-WRAP-PAD", "default=yes",
-      aes128wrappad_functions },
+    ALG("AES-256-GCM:id-aes256-GCM", aes256gcm_functions),
+    ALG("AES-192-GCM:id-aes192-GCM", aes192gcm_functions),
+    ALG("AES-128-GCM:id-aes128-GCM", aes128gcm_functions),
+    ALG("AES-256-CCM:id-aes256-CCM", aes256ccm_functions),
+    ALG("AES-192-CCM:id-aes192-CCM", aes192ccm_functions),
+    ALG("AES-128-CCM:id-aes128-CCM", aes128ccm_functions),
+    ALG("AES-256-WRAP:id-aes256-wrap:AES256-WRAP", aes256wrap_functions),
+    ALG("AES-192-WRAP:id-aes192-wrap:AES192-WRAP", aes192wrap_functions),
+    ALG("AES-128-WRAP:id-aes128-wrap:AES128-WRAP", aes128wrap_functions),
+    ALG("AES-256-WRAP-PAD:id-aes256-wrap-pad:AES256-WRAP-PAD",
+        aes256wrappad_functions),
+    ALG("AES-192-WRAP-PAD:id-aes192-wrap-pad:AES192-WRAP-PAD",
+        aes192wrappad_functions),
+    ALG("AES-128-WRAP-PAD:id-aes128-wrap-pad:AES128-WRAP-PAD",
+        aes128wrappad_functions),
+    ALGC("AES-128-CBC-HMAC-SHA1", aes128cbc_hmac_sha1_functions,
+         cipher_capable_aes_cbc_hmac_sha1),
+    ALGC("AES-256-CBC-HMAC-SHA1", aes256cbc_hmac_sha1_functions,
+         cipher_capable_aes_cbc_hmac_sha1),
+    ALGC("AES-128-CBC-HMAC-SHA256", aes128cbc_hmac_sha256_functions,
+        cipher_capable_aes_cbc_hmac_sha256),
+    ALGC("AES-256-CBC-HMAC-SHA256", aes256cbc_hmac_sha256_functions,
+         cipher_capable_aes_cbc_hmac_sha256),
 #ifndef OPENSSL_NO_ARIA
-    { "ARIA-256-GCM", "default=yes", aria256gcm_functions },
-    { "ARIA-192-GCM", "default=yes", aria192gcm_functions },
-    { "ARIA-128-GCM", "default=yes", aria128gcm_functions },
-    { "ARIA-256-CCM", "default=yes", aria256ccm_functions },
-    { "ARIA-192-CCM", "default=yes", aria192ccm_functions },
-    { "ARIA-128-CCM", "default=yes", aria128ccm_functions },
-    { "ARIA-256-ECB", "default=yes", aria256ecb_functions },
-    { "ARIA-192-ECB", "default=yes", aria192ecb_functions },
-    { "ARIA-128-ECB", "default=yes", aria128ecb_functions },
-    { "ARIA-256-CBC:ARIA256", "default=yes", aria256cbc_functions },
-    { "ARIA-192-CBC:ARIA192", "default=yes", aria192cbc_functions },
-    { "ARIA-128-CBC:ARIA128", "default=yes", aria128cbc_functions },
-    { "ARIA-256-OFB", "default=yes", aria256ofb_functions },
-    { "ARIA-192-OFB", "default=yes", aria192ofb_functions },
-    { "ARIA-128-OFB", "default=yes", aria128ofb_functions },
-    { "ARIA-256-CFB", "default=yes", aria256cfb_functions },
-    { "ARIA-192-CFB", "default=yes", aria192cfb_functions },
-    { "ARIA-128-CFB", "default=yes", aria128cfb_functions },
-    { "ARIA-256-CFB1", "default=yes", aria256cfb1_functions },
-    { "ARIA-192-CFB1", "default=yes", aria192cfb1_functions },
-    { "ARIA-128-CFB1", "default=yes", aria128cfb1_functions },
-    { "ARIA-256-CFB8", "default=yes", aria256cfb8_functions },
-    { "ARIA-192-CFB8", "default=yes", aria192cfb8_functions },
-    { "ARIA-128-CFB8", "default=yes", aria128cfb8_functions },
-    { "ARIA-256-CTR", "default=yes", aria256ctr_functions },
-    { "ARIA-192-CTR", "default=yes", aria192ctr_functions },
-    { "ARIA-128-CTR", "default=yes", aria128ctr_functions },
+    ALG("ARIA-256-GCM", aria256gcm_functions),
+    ALG("ARIA-192-GCM", aria192gcm_functions),
+    ALG("ARIA-128-GCM", aria128gcm_functions),
+    ALG("ARIA-256-CCM", aria256ccm_functions),
+    ALG("ARIA-192-CCM", aria192ccm_functions),
+    ALG("ARIA-128-CCM", aria128ccm_functions),
+    ALG("ARIA-256-ECB", aria256ecb_functions),
+    ALG("ARIA-192-ECB", aria192ecb_functions),
+    ALG("ARIA-128-ECB", aria128ecb_functions),
+    ALG("ARIA-256-CBC:ARIA256", aria256cbc_functions),
+    ALG("ARIA-192-CBC:ARIA192", aria192cbc_functions),
+    ALG("ARIA-128-CBC:ARIA128", aria128cbc_functions),
+    ALG("ARIA-256-OFB", aria256ofb_functions),
+    ALG("ARIA-192-OFB", aria192ofb_functions),
+    ALG("ARIA-128-OFB", aria128ofb_functions),
+    ALG("ARIA-256-CFB", aria256cfb_functions),
+    ALG("ARIA-192-CFB", aria192cfb_functions),
+    ALG("ARIA-128-CFB", aria128cfb_functions),
+    ALG("ARIA-256-CFB1", aria256cfb1_functions),
+    ALG("ARIA-192-CFB1", aria192cfb1_functions),
+    ALG("ARIA-128-CFB1", aria128cfb1_functions),
+    ALG("ARIA-256-CFB8", aria256cfb8_functions),
+    ALG("ARIA-192-CFB8", aria192cfb8_functions),
+    ALG("ARIA-128-CFB8", aria128cfb8_functions),
+    ALG("ARIA-256-CTR", aria256ctr_functions),
+    ALG("ARIA-192-CTR", aria192ctr_functions),
+    ALG("ARIA-128-CTR", aria128ctr_functions),
 #endif /* OPENSSL_NO_ARIA */
 #ifndef OPENSSL_NO_CAMELLIA
-    { "CAMELLIA-256-ECB", "default=yes", camellia256ecb_functions },
-    { "CAMELLIA-192-ECB", "default=yes", camellia192ecb_functions },
-    { "CAMELLIA-128-ECB", "default=yes", camellia128ecb_functions },
-    { "CAMELLIA-256-CBC:CAMELLIA256", "default=yes", camellia256cbc_functions },
-    { "CAMELLIA-192-CBC:CAMELLIA192", "default=yes", camellia192cbc_functions },
-    { "CAMELLIA-128-CBC:CAMELLIA128", "default=yes", camellia128cbc_functions },
-    { "CAMELLIA-256-OFB", "default=yes", camellia256ofb_functions },
-    { "CAMELLIA-192-OFB", "default=yes", camellia192ofb_functions },
-    { "CAMELLIA-128-OFB", "default=yes", camellia128ofb_functions },
-    { "CAMELLIA-256-CFB", "default=yes", camellia256cfb_functions },
-    { "CAMELLIA-192-CFB", "default=yes", camellia192cfb_functions },
-    { "CAMELLIA-128-CFB", "default=yes", camellia128cfb_functions },
-    { "CAMELLIA-256-CFB1", "default=yes", camellia256cfb1_functions },
-    { "CAMELLIA-192-CFB1", "default=yes", camellia192cfb1_functions },
-    { "CAMELLIA-128-CFB1", "default=yes", camellia128cfb1_functions },
-    { "CAMELLIA-256-CFB8", "default=yes", camellia256cfb8_functions },
-    { "CAMELLIA-192-CFB8", "default=yes", camellia192cfb8_functions },
-    { "CAMELLIA-128-CFB8", "default=yes", camellia128cfb8_functions },
-    { "CAMELLIA-256-CTR", "default=yes", camellia256ctr_functions },
-    { "CAMELLIA-192-CTR", "default=yes", camellia192ctr_functions },
-    { "CAMELLIA-128-CTR", "default=yes", camellia128ctr_functions },
+    ALG("CAMELLIA-256-ECB", camellia256ecb_functions),
+    ALG("CAMELLIA-192-ECB", camellia192ecb_functions),
+    ALG("CAMELLIA-128-ECB", camellia128ecb_functions),
+    ALG("CAMELLIA-256-CBC:CAMELLIA256", camellia256cbc_functions),
+    ALG("CAMELLIA-192-CBC:CAMELLIA192", camellia192cbc_functions),
+    ALG("CAMELLIA-128-CBC:CAMELLIA128", camellia128cbc_functions),
+    ALG("CAMELLIA-256-OFB", camellia256ofb_functions),
+    ALG("CAMELLIA-192-OFB", camellia192ofb_functions),
+    ALG("CAMELLIA-128-OFB", camellia128ofb_functions),
+    ALG("CAMELLIA-256-CFB", camellia256cfb_functions),
+    ALG("CAMELLIA-192-CFB", camellia192cfb_functions),
+    ALG("CAMELLIA-128-CFB", camellia128cfb_functions),
+    ALG("CAMELLIA-256-CFB1", camellia256cfb1_functions),
+    ALG("CAMELLIA-192-CFB1", camellia192cfb1_functions),
+    ALG("CAMELLIA-128-CFB1", camellia128cfb1_functions),
+    ALG("CAMELLIA-256-CFB8", camellia256cfb8_functions),
+    ALG("CAMELLIA-192-CFB8", camellia192cfb8_functions),
+    ALG("CAMELLIA-128-CFB8", camellia128cfb8_functions),
+    ALG("CAMELLIA-256-CTR", camellia256ctr_functions),
+    ALG("CAMELLIA-192-CTR", camellia192ctr_functions),
+    ALG("CAMELLIA-128-CTR", camellia128ctr_functions),
 #endif /* OPENSSL_NO_CAMELLIA */
 #ifndef OPENSSL_NO_DES
-    { "DES-EDE3-ECB:DES-EDE3", "default=yes", tdes_ede3_ecb_functions },
-    { "DES-EDE3-CBC:DES3", "default=yes", tdes_ede3_cbc_functions },
-    { "DES-EDE3-OFB", "default=yes", tdes_ede3_ofb_functions },
-    { "DES-EDE3-CFB", "default=yes", tdes_ede3_cfb_functions },
-    { "DES-EDE3-CFB8", "default=yes", tdes_ede3_cfb8_functions },
-    { "DES-EDE3-CFB1", "default=yes", tdes_ede3_cfb1_functions },
-    { "DES-EDE-ECB:DES-EDE", "default=yes", tdes_ede2_ecb_functions },
-    { "DES-EDE-CBC", "default=yes", tdes_ede2_cbc_functions },
-    { "DES-EDE-OFB", "default=yes", tdes_ede2_ofb_functions },
-    { "DES-EDE-CFB", "default=yes", tdes_ede2_cfb_functions },
-    { "DESX-CBC:DESX", "default=yes", tdes_desx_cbc_functions },
-    { "DES3-WRAP:id-smime-alg-CMS3DESwrap", "default=yes", tdes_wrap_cbc_functions },
-    { "DES-ECB", "default=yes", des_ecb_functions },
-    { "DES-CBC:DES", "default=yes", des_cbc_functions },
-    { "DES-OFB", "default=yes", des_ofb64_functions },
-    { "DES-CFB", "default=yes", des_cfb64_functions },
-    { "DES-CFB1", "default=yes", des_cfb1_functions },
-    { "DES-CFB8", "default=yes", des_cfb8_functions },
+    ALG("DES-EDE3-ECB:DES-EDE3", tdes_ede3_ecb_functions),
+    ALG("DES-EDE3-CBC:DES3", tdes_ede3_cbc_functions),
+    ALG("DES-EDE3-OFB", tdes_ede3_ofb_functions),
+    ALG("DES-EDE3-CFB", tdes_ede3_cfb_functions),
+    ALG("DES-EDE3-CFB8", tdes_ede3_cfb8_functions),
+    ALG("DES-EDE3-CFB1", tdes_ede3_cfb1_functions),
+    ALG("DES-EDE-ECB:DES-EDE", tdes_ede2_ecb_functions),
+    ALG("DES-EDE-CBC", tdes_ede2_cbc_functions),
+    ALG("DES-EDE-OFB", tdes_ede2_ofb_functions),
+    ALG("DES-EDE-CFB", tdes_ede2_cfb_functions),
+    ALG("DESX-CBC:DESX", tdes_desx_cbc_functions),
+    ALG("DES3-WRAP:id-smime-alg-CMS3DESwrap", tdes_wrap_cbc_functions),
+    ALG("DES-ECB", des_ecb_functions),
+    ALG("DES-CBC:DES", des_cbc_functions),
+    ALG("DES-OFB", des_ofb64_functions),
+    ALG("DES-CFB", des_cfb64_functions),
+    ALG("DES-CFB1", des_cfb1_functions),
+    ALG("DES-CFB8", des_cfb8_functions),
 #endif /* OPENSSL_NO_DES */
 #ifndef OPENSSL_NO_BF
-    { "BF-ECB", "default=yes", blowfish128ecb_functions },
-    { "BF-CBC:BF:BLOWFISH", "default=yes", blowfish128cbc_functions },
-    { "BF-OFB", "default=yes", blowfish64ofb64_functions },
-    { "BF-CFB", "default=yes", blowfish64cfb64_functions },
+    ALG("BF-ECB", blowfish128ecb_functions),
+    ALG("BF-CBC:BF:BLOWFISH", blowfish128cbc_functions),
+    ALG("BF-OFB", blowfish64ofb64_functions),
+    ALG("BF-CFB", blowfish64cfb64_functions),
 #endif /* OPENSSL_NO_BF */
 #ifndef OPENSSL_NO_IDEA
-    { "IDEA-ECB", "default=yes", idea128ecb_functions },
-    { "IDEA-CBC:IDEA", "default=yes", idea128cbc_functions },
-    { "IDEA-OFB:IDEA-OFB64", "default=yes", idea128ofb64_functions },
-    { "IDEA-CFB:IDEA-CFB64", "default=yes", idea128cfb64_functions },
+    ALG("IDEA-ECB", idea128ecb_functions),
+    ALG("IDEA-CBC:IDEA", idea128cbc_functions),
+    ALG("IDEA-OFB:IDEA-OFB64", idea128ofb64_functions),
+    ALG("IDEA-CFB:IDEA-CFB64", idea128cfb64_functions),
 #endif /* OPENSSL_NO_IDEA */
 #ifndef OPENSSL_NO_CAST
-    { "CAST5-ECB", "default=yes", cast5128ecb_functions },
-    { "CAST5-CBC:CAST-CBC:CAST", "default=yes", cast5128cbc_functions },
-    { "CAST5-OFB", "default=yes", cast564ofb64_functions },
-    { "CAST5-CFB", "default=yes", cast564cfb64_functions },
+    ALG("CAST5-ECB", cast5128ecb_functions),
+    ALG("CAST5-CBC:CAST-CBC:CAST", cast5128cbc_functions),
+    ALG("CAST5-OFB", cast564ofb64_functions),
+    ALG("CAST5-CFB", cast564cfb64_functions),
 #endif /* OPENSSL_NO_CAST */
 #ifndef OPENSSL_NO_SEED
-    { "SEED-ECB", "default=yes", seed128ecb_functions },
-    { "SEED-CBC:SEED", "default=yes", seed128cbc_functions },
-    { "SEED-OFB:SEED-OFB128", "default=yes", seed128ofb128_functions },
-    { "SEED-CFB:SEED-CFB128", "default=yes", seed128cfb128_functions },
+    ALG("SEED-ECB", seed128ecb_functions),
+    ALG("SEED-CBC:SEED", seed128cbc_functions),
+    ALG("SEED-OFB:SEED-OFB128", seed128ofb128_functions),
+    ALG("SEED-CFB:SEED-CFB128", seed128cfb128_functions),
 #endif /* OPENSSL_NO_SEED */
 #ifndef OPENSSL_NO_SM4
-    { "SM4-ECB", "default=yes", sm4128ecb_functions },
-    { "SM4-CBC:SM4", "default=yes", sm4128cbc_functions },
-    { "SM4-CTR", "default=yes", sm4128ctr_functions },
-    { "SM4-OFB:SM4-OFB128", "default=yes", sm4128ofb128_functions },
-    { "SM4-CFB:SM4-CFB128", "default=yes", sm4128cfb128_functions },
+    ALG("SM4-ECB", sm4128ecb_functions),
+    ALG("SM4-CBC:SM4", sm4128cbc_functions),
+    ALG("SM4-CTR", sm4128ctr_functions),
+    ALG("SM4-OFB:SM4-OFB128", sm4128ofb128_functions),
+    ALG("SM4-CFB:SM4-CFB128", sm4128cfb128_functions),
 #endif /* OPENSSL_NO_SM4 */
 #ifndef OPENSSL_NO_RC4
-    { "RC4", "default=yes", rc4128_functions },
-    { "RC4-40", "default=yes", rc440_functions },
+    ALG("RC4", rc4128_functions),
+    ALG("RC4-40", rc440_functions),
 # ifndef OPENSSL_NO_MD5
-    { "RC4-HMAC-MD5", "default=yes", rc4_hmac_md5_functions },
+    ALG("RC4-HMAC-MD5", rc4_hmac_md5_functions),
 # endif /* OPENSSL_NO_MD5 */
 #endif /* OPENSSL_NO_RC4 */
 #ifndef OPENSSL_NO_RC5
-    { "RC5-ECB", "default=yes", rc5128ecb_functions },
-    { "RC5-CBC", "default=yes", rc5128cbc_functions },
-    { "RC5-OFB", "default=yes", rc5128ofb64_functions },
-    { "RC5-CFB", "default=yes", rc5128cfb64_functions },
+    ALG("RC5-ECB", rc5128ecb_functions),
+    ALG("RC5-CBC", rc5128cbc_functions),
+    ALG("RC5-OFB", rc5128ofb64_functions),
+    ALG("RC5-CFB", rc5128cfb64_functions),
 #endif /* OPENSSL_NO_RC5 */
 #ifndef OPENSSL_NO_RC2
-    { "RC2-ECB", "default=yes", rc2128ecb_functions },
-    { "RC2-CBC", "default=yes", rc2128cbc_functions },
-    { "RC2-40-CBC", "default=yes", rc240cbc_functions },
-    { "RC2-64-CBC", "default=yes", rc264cbc_functions },
-    { "RC2-CFB", "default=yes", rc2128cfb128_functions },
-    { "RC2-OFB", "default=yes", rc2128ofb128_functions },
+    ALG("RC2-ECB", rc2128ecb_functions),
+    ALG("RC2-CBC", rc2128cbc_functions),
+    ALG("RC2-40-CBC", rc240cbc_functions),
+    ALG("RC2-64-CBC", rc264cbc_functions),
+    ALG("RC2-CFB", rc2128cfb128_functions),
+    ALG("RC2-OFB", rc2128ofb128_functions),
 #endif /* OPENSSL_NO_RC2 */
 #ifndef OPENSSL_NO_CHACHA
-    { "ChaCha20", "default=yes", chacha20_functions },
+    ALG("ChaCha20", chacha20_functions),
 # ifndef OPENSSL_NO_POLY1305
-    { "ChaCha20-Poly1305", "default=yes", chacha20_poly1305_functions },
+    ALG("ChaCha20-Poly1305", chacha20_poly1305_functions),
 # endif /* OPENSSL_NO_POLY1305 */
 #endif /* OPENSSL_NO_CHACHA */
-    { NULL, NULL, NULL }
+    { { NULL, NULL, NULL }, NULL }
 };
+static OSSL_ALGORITHM exported_ciphers[OSSL_NELEM(deflt_ciphers)];
 
 static const OSSL_ALGORITHM deflt_macs[] = {
 #ifndef OPENSSL_NO_BLAKE2
@@ -432,7 +444,8 @@ static const OSSL_ALGORITHM *deflt_query(OSSL_PROVIDER *prov,
     case OSSL_OP_DIGEST:
         return deflt_digests;
     case OSSL_OP_CIPHER:
-        return deflt_ciphers;
+        ossl_prov_cache_exported_algorithms(deflt_ciphers, exported_ciphers);
+        return exported_ciphers;
     case OSSL_OP_MAC:
         return deflt_macs;
     case OSSL_OP_KDF:
diff --git a/providers/fips/fipsprov.c b/providers/fips/fipsprov.c
index 12c471f325..7afab78063 100644
--- a/providers/fips/fipsprov.c
+++ b/providers/fips/fipsprov.c
@@ -25,12 +25,17 @@
 
 #include "internal/cryptlib.h"
 #include "internal/property.h"
+#include "internal/nelem.h"
 #include "crypto/evp.h"
 #include "prov/implementations.h"
 #include "prov/provider_ctx.h"
 #include "prov/providercommon.h"
+#include "prov/provider_util.h"
 #include "selftest.h"
 
+#define ALGC(NAMES, FUNC, CHECK) { { NAMES, "fips=yes", FUNC }, CHECK }
+#define ALG(NAMES, FUNC) ALGC(NAMES, FUNC, NULL)
+
 extern OSSL_core_thread_start_fn *c_thread_start;
 
 /*
@@ -300,6 +305,14 @@ const char *ossl_prov_util_nid_to_name(int nid)
         return "DES-EDE3";
     case NID_des_ede3_cbc:
         return "DES-EDE3-CBC";
+    case NID_aes_256_cbc_hmac_sha256:
+        return "AES-256-CBC-HMAC-SHA256";
+    case NID_aes_128_cbc_hmac_sha256:
+        return "AES-128-CBC-HMAC-SHA256";
+    case NID_aes_256_cbc_hmac_sha1:
+        return "AES-256-CBC-HMAC-SHA1";
+    case NID_aes_128_cbc_hmac_sha1:
+        return "AES-128-CBC-HMAC-SHA1";