Commit 7d6a31ec1c for openssl.org

commit 7d6a31ec1cd8ab3d6e093d5404ee42446b43bad2
Author: Dmitry Belyavskiy <beldmit@gmail.com>
Date:   Fri Oct 2 16:36:13 2026 +0200

    Implement TLS1-PRF multi-key derivation provider

    Add derive_multi, get_skey, and get_iv dispatch functions to the TLS1-PRF
    provider, enabling simultaneous derivation of all TLS 1.2 key block
    components (MAC keys, cipher keys, IVs) in a single operation.

    This is the provider-side counterpart to the EVP_KDF_derive_SKEYs API,
    designed to support PKCS#11 providers that derive TLS key material
    atomically.

    Includes unit tests for consistency (raw vs multi-derive), error handling
    (bad purpose strings), and premature retrieval. Documents multi-derive
    parameters and purpose strings in EVP_KDF-TLS1_PRF.pod.

    Assisted-By: Claude Opus 4.6 <noreply@anthropic.com>

    Reviewed-by: Mounir Idrassi <mounir.idrassi@idrix.fr>
    Reviewed-by: Simo Sorce <simo@redhat.com>
    MergeDate: Wed Nov 18 12:11:50 2026
    (Merged from https://github.com/openssl/openssl/pull/33082)

diff --git a/doc/man7/EVP_KDF-TLS1_PRF.pod b/doc/man7/EVP_KDF-TLS1_PRF.pod
index a80915364a..3c378558ec 100644
--- a/doc/man7/EVP_KDF-TLS1_PRF.pod
+++ b/doc/man7/EVP_KDF-TLS1_PRF.pod
@@ -90,6 +90,88 @@ to return 0.

 =back

+=head2 Multi-key derivation parameters
+
+The TLS1-PRF implementation supports simultaneous derivation of multiple keys
+and IVs via EVP_KDF_derive_SKEYs(). The following additional parameters control
+the key block layout:
+
+=over 4
+
+=item "mac_key_len" (B<OSSL_KDF_PARAM_MAC_KEY_LEN>) <unsigned integer>
+
+The length in bytes of each MAC key. Set to 0 for cipher suites that do not
+use separate MAC keys (e.g., AEAD ciphers).
+
+=item "cipher_key_len" (B<OSSL_KDF_PARAM_CIPHER_KEY_LEN>) <unsigned integer>
+
+The length in bytes of each cipher key.
+
+=item "iv_len" (B<OSSL_KDF_PARAM_IV_LEN>) <unsigned integer>
+
+The length in bytes of each IV.
+
+=item "cipher" (B<OSSL_KDF_PARAM_CIPHER>) <UTF8 string>
+
+The cipher the derived keys are for, for example "AES-128-CBC". This is not
+used by the PRF itself; it tells the provider how large a cipher key to derive
+and which kind of key to produce. Given this, "cipher_key_len" is unnecessary,
+and if it is given anyway the two must agree: naming "AES-128-CBC" with a
+"cipher_key_len" of 10 is an error and is reported by EVP_KDF_derive_SKEYs().
+
+=item "mac" (B<OSSL_KDF_PARAM_MAC>) <UTF8 string>
+
+The MAC the derived MAC keys are for. Unlike a cipher, a MAC does not
+determine its own key length -- for HMAC that is a property of the TLS
+ciphersuite rather than of the algorithm -- so "mac_key_len" is still
+required.
+
+Unlike "cipher" above, this name is not fetched: it is passed to the provider
+to interpret, so the vocabulary is the provider's own. The default provider
+has no MAC-specific key type and ignores it entirely, producing generic
+secrets whatever it says. A provider backed by a token is the reason the
+parameter exists, and may well want a digest-qualified name such as
+"HMAC-SHA2-256", since PKCS#11 types an HMAC key by its digest -- a bare
+"HMAC" does not say whether a B<CKK_SHA256_HMAC> or a B<CKK_SHA384_HMAC> key
+is wanted.
+
+=back
+
+The key type each kind of key is produced as is decided by the provider from
+these names, and is reported by EVP_SKEY_get0_skeymgmt_name() on the key that
+comes back. The default provider produces B<OSSL_SKEY_TYPE_AES> keys for AES
+ciphers and B<OSSL_SKEY_TYPE_GENERIC> otherwise; a provider holding its keys
+on a token may use types of its own. Naming neither algorithm derives generic
+secrets of the requested lengths.
+
+The algorithms are given per kind of key rather than per purpose, since the
+client and server side of a connection always agree on them.
+
+The total key block size is 2 * (mac_key_len + cipher_key_len + iv_len).
+After calling EVP_KDF_derive_SKEYs(), individual keys are retrieved via
+EVP_KDF_CTX_get1_SKEY() and IVs via EVP_KDF_CTX_get0_IV() using the
+following purpose strings:
+
+=over 4
+
+=item "client_MAC_key" (B<OSSL_KDF_PURPOSE_CLIENT_MAC_KEY>)
+
+=item "server_MAC_key" (B<OSSL_KDF_PURPOSE_SERVER_MAC_KEY>)
+
+=item "client_cipher_key" (B<OSSL_KDF_PURPOSE_CLIENT_CIPHER_KEY>)
+
+=item "server_cipher_key" (B<OSSL_KDF_PURPOSE_SERVER_CIPHER_KEY>)
+
+=item "client_iv" (B<OSSL_KDF_PURPOSE_CLIENT_IV>)
+
+=item "server_iv" (B<OSSL_KDF_PURPOSE_SERVER_IV>)
+
+=back
+
+A purpose whose length was set to 0 is not derived, and retrieving it fails.
+For an AEAD ciphersuite, where "mac_key_len" is 0, that is the case for
+"client_MAC_key" and "server_MAC_key".
+
 =head1 NOTES

 A context for the TLS PRF can be obtained by calling:
diff --git a/providers/common/include/prov/provider_util.h b/providers/common/include/prov/provider_util.h
index 06f66bb171..72b6b4de19 100644
--- a/providers/common/include/prov/provider_util.h
+++ b/providers/common/include/prov/provider_util.h
@@ -51,6 +51,15 @@ int ossl_prov_cipher_copy(PROV_CIPHER *dst, const PROV_CIPHER *src);
 /* Query the cipher (if any) */
 const EVP_CIPHER *ossl_prov_cipher_cipher(const PROV_CIPHER *pc);

+/**
+ * The EVP_SKEYMGMT algorithm name under which a key for the cipher called
+ * |cipher_name| should be created by the providers in this source tree.
+ * @param cipher_name the cipher name to map to a key type
+ * @returns OSSL_SKEY_TYPE_GENERIC for a NULL name and for anything with no
+ * more specific key type, otherwise the specific key type (e.g., OSSL_SKEY_TYPE_AES)
+ */
+const char *ossl_prov_cipher_skey_type(const char *cipher_name);
+
 /* Digest functions */

 /*
diff --git a/providers/common/provider_util.c b/providers/common/provider_util.c
index e66b101a35..bdd1bc7551 100644
--- a/providers/common/provider_util.c
+++ b/providers/common/provider_util.c
@@ -68,6 +68,20 @@ const EVP_CIPHER *ossl_prov_cipher_cipher(const PROV_CIPHER *pc)
     return pc->cipher;
 }

+const char *ossl_prov_cipher_skey_type(const char *cipher_name)
+{
+    /*
+     * Matching on the family prefix rather than on each individual algorithm
+     * keeps this in step with the skeymgmts that are actually registered: an
+     * AES key is an AES key whichever mode it is later used in.
+     */
+    if (cipher_name != NULL
+        && OPENSSL_strncasecmp(cipher_name, "AES-", 4) == 0)
+        return OSSL_SKEY_TYPE_AES;
+
+    return OSSL_SKEY_TYPE_GENERIC;
+}
+
 void ossl_prov_digest_reset(PROV_DIGEST *pd)
 {
     EVP_MD_free(pd->alloc_md);
diff --git a/providers/implementations/kdfs/tls1_prf.c b/providers/implementations/kdfs/tls1_prf.c
index 07fcdd058e..c19e84c880 100644
--- a/providers/implementations/kdfs/tls1_prf.c
+++ b/providers/implementations/kdfs/tls1_prf.c
@@ -84,6 +84,14 @@ static OSSL_FUNC_kdf_settable_ctx_params_fn kdf_tls1_prf_settable_ctx_params;
 static OSSL_FUNC_kdf_set_ctx_params_fn kdf_tls1_prf_set_ctx_params;
 static OSSL_FUNC_kdf_gettable_ctx_params_fn kdf_tls1_prf_gettable_ctx_params;
 static OSSL_FUNC_kdf_get_ctx_params_fn kdf_tls1_prf_get_ctx_params;
+static OSSL_FUNC_kdf_derive_multi_fn kdf_tls1_prf_derive_multi;
+static OSSL_FUNC_kdf_get_skey_fn kdf_tls1_prf_get_skey;
+static OSSL_FUNC_kdf_get_iv_fn kdf_tls1_prf_get_iv;
+
+typedef struct tls1_prf_st TLS1_PRF;
+static void tls1_prf_multi_cleanup(TLS1_PRF *ctx);
+static int tls1_prf_purpose_to_offset(const TLS1_PRF *ctx, const char *purpose,
+    size_t *offset, size_t *len);

 static int tls1_prf_alg(EVP_MAC_CTX *mdctx, EVP_MAC_CTX *sha1ctx,
     const unsigned char *sec, size_t slen,
@@ -97,8 +105,35 @@ static int tls1_prf_alg(EVP_MAC_CTX *mdctx, EVP_MAC_CTX *sha1ctx,

 #include "providers/implementations/kdfs/tls1_prf.inc"

+/*
+ * Key slots of a TLS 1.2 key block, in the order they appear in it.  The IVs
+ * that follow them are not keys and so have no slot here.
+ */
+#define TLS1_PRF_NUM_KEYS 4
+
+static const char *const tls1_prf_key_purposes[TLS1_PRF_NUM_KEYS] = {
+    OSSL_KDF_PURPOSE_CLIENT_MAC_KEY,
+    OSSL_KDF_PURPOSE_SERVER_MAC_KEY,
+    OSSL_KDF_PURPOSE_CLIENT_CIPHER_KEY,
+    OSSL_KDF_PURPOSE_SERVER_CIPHER_KEY
+};
+
+/*
+ * A key type is chosen per category rather than per purpose: the two
+ * directions of a TLS connection always agree on it, and PKCS#11 models the
+ * same thing with a single C_DeriveKey template.
+ */
+#define TLS1_PRF_KEYTYPE_MAC 0
+#define TLS1_PRF_KEYTYPE_CIPHER 1
+#define TLS1_PRF_NUM_KEYTYPES 2
+
+static const int tls1_prf_purpose_keytype[TLS1_PRF_NUM_KEYS] = {
+    TLS1_PRF_KEYTYPE_MAC, TLS1_PRF_KEYTYPE_MAC,
+    TLS1_PRF_KEYTYPE_CIPHER, TLS1_PRF_KEYTYPE_CIPHER
+};
+
 /* TLS KDF kdf context structure */
-typedef struct {
+struct tls1_prf_st {
     void *provctx;

     /* MAC context for the main digest */
@@ -113,8 +148,42 @@ typedef struct {
     unsigned char *seed;
     size_t seedlen;

+    /* Multi-key derivation configuration */
+    size_t mac_key_len;
+    size_t cipher_key_len;
+    size_t iv_len;
+    /*
+     * The cipher the derived keys are for, resolved at set time to just the
+     * two facts needed of it: the name, which decides the key type, and the
+     * key length.  The EVP_CIPHER itself is not kept.
+     *
+     * The length is deliberately *not* merged into cipher_key_len above.
+     * That one is what the caller asked for, this one is what the cipher
+     * requires, and derive_multi() compares them -- naming AES-128-CBC and a
+     * cipher_key_len of 10 is a contradiction worth reporting rather than
+     * silently resolving.  Keeping them apart is also what lets a later
+     * "cipher" replace an earlier one while a caller-supplied length still
+     * conflicts with it, whatever order the two arrive in.
+     */
+    char *cipher_name;
+    size_t cipher_keylen;
+
+    /*
+     * Result of a multi-key derivation: the whole key block, the lengths
+     * actually used for it, and the key type settled on for each kind of key.
+     * Released by kdf_tls1_prf_reset() and copied by kdf_tls1_prf_dup().
+     */
+    struct {
+        unsigned char *key_block;
+        size_t key_block_len;
+        size_t mac_key_len;
+        size_t cipher_key_len;
+        size_t iv_len;
+        char *keytype[TLS1_PRF_NUM_KEYTYPES];
+    } multi;
+
     OSSL_FIPS_IND_DECLARE
-} TLS1_PRF;
+};

 static void *kdf_tls1_prf_new(void *provctx)
 {
@@ -155,6 +224,8 @@ static void kdf_tls1_prf_reset(void *vctx)
     EVP_MAC_CTX_free(ctx->P_sha1);
     OPENSSL_clear_free(ctx->sec, ctx->seclen);
     OPENSSL_clear_free(ctx->seed, ctx->seedlen);
+    OPENSSL_free(ctx->cipher_name);
+    tls1_prf_multi_cleanup(ctx);
     memset(ctx, 0, sizeof(*ctx));
     ctx->provctx = provctx;
 }
@@ -163,6 +234,7 @@ static void *kdf_tls1_prf_dup(void *vctx)
 {
     const TLS1_PRF *src = (const TLS1_PRF *)vctx;
     TLS1_PRF *dest;
+    int i;

     dest = kdf_tls1_prf_new(src->provctx);
     if (dest != NULL) {
@@ -177,6 +249,23 @@ static void *kdf_tls1_prf_dup(void *vctx)
         if (!ossl_prov_memdup(src->seed, src->seedlen, &dest->seed,
                 &dest->seedlen))
             goto err;
+        if (src->cipher_name != NULL
+            && (dest->cipher_name = OPENSSL_strdup(src->cipher_name)) == NULL)
+            goto err;
+        dest->cipher_keylen = src->cipher_keylen;
+        if (!ossl_prov_memdup(src->multi.key_block, src->multi.key_block_len,
+                &dest->multi.key_block, &dest->multi.key_block_len))
+            goto err;
+        for (i = 0; i < TLS1_PRF_NUM_KEYTYPES; i++)
+            if (src->multi.keytype[i] != NULL
+                && (dest->multi.keytype[i] = OPENSSL_strdup(src->multi.keytype[i])) == NULL)
+                goto err;
+        dest->multi.mac_key_len = src->multi.mac_key_len;
+        dest->multi.cipher_key_len = src->multi.cipher_key_len;
+        dest->multi.iv_len = src->multi.iv_len;
+        dest->mac_key_len = src->mac_key_len;
+        dest->cipher_key_len = src->cipher_key_len;
+        dest->iv_len = src->iv_len;
         OSSL_FIPS_IND_COPY(dest, src)
     }
     return dest;
@@ -416,6 +505,39 @@ static int kdf_tls1_prf_set_ctx_params(void *vctx, const OSSL_PARAM params[])
         }
     }

+    if (p.cipher != NULL) {
+        PROV_CIPHER pc = { 0 };
+        const EVP_CIPHER *ciph;
+        int clen;
+
+        if (!ossl_prov_cipher_load(&pc, p.cipher, p.propq,
+                PROV_LIBCTX_OF(ctx->provctx)))
+            return 0;
+        ciph = ossl_prov_cipher_cipher(&pc);
+        clen = ciph != NULL ? EVP_CIPHER_get_key_length(ciph) : -1;
+        if (clen < 0) {
+            ossl_prov_cipher_reset(&pc);
+            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
+            return 0;
+        }
+        OPENSSL_free(ctx->cipher_name);
+        ctx->cipher_name = OPENSSL_strdup(EVP_CIPHER_get0_name(ciph));
+        ctx->cipher_keylen = (size_t)clen;
+        ossl_prov_cipher_reset(&pc);
+        if (ctx->cipher_name == NULL)
+            return 0;
+    }
+
+    if (p.mac_key_len != NULL
+        && !OSSL_PARAM_get_size_t(p.mac_key_len, &ctx->mac_key_len))
+        return 0;
+    if (p.cipher_key_len != NULL
+        && !OSSL_PARAM_get_size_t(p.cipher_key_len, &ctx->cipher_key_len))
+        return 0;
+    if (p.iv_len != NULL
+        && !OSSL_PARAM_get_size_t(p.iv_len, &ctx->iv_len))
+        return 0;
+
     return 1;
 }

@@ -436,6 +558,36 @@ static int kdf_tls1_prf_get_ctx_params(void *vctx, OSSL_PARAM params[])
     if (p.size != NULL && !OSSL_PARAM_set_size_t(p.size, SIZE_MAX))
         return 0;

+    /*
+     * Report the key type settled on for each purpose of a preceding
+     * multi-key derivation.  A purpose with no key derived for it, such as a
+     * MAC key in an AEAD ciphersuite, is left unmodified (the caller will see
+     * it as absent via EVP_KDF_CTX_get1_SKEY).
+     */
+    {
+        OSSL_PARAM *const out[TLS1_PRF_NUM_KEYS] = {
+            p.client_mac_type, p.server_mac_type,
+            p.client_cipher_type, p.server_cipher_type
+        };
+        int i;
+
+        for (i = 0; i < TLS1_PRF_NUM_KEYS; i++) {
+            size_t offset, len;
+
+            if (out[i] == NULL)
+                continue;
+            /* Skip if no multi-derive has been done or this purpose has no key */
+            if (ctx->multi.key_block == NULL
+                || !tls1_prf_purpose_to_offset(ctx, tls1_prf_key_purposes[i],
+                    &offset, &len)
+                || len == 0)
+                continue;
+            if (!OSSL_PARAM_set_utf8_string(out[i],
+                    ctx->multi.keytype[tls1_prf_purpose_keytype[i]]))
+                return 0;
+        }
+    }
+
     if (!OSSL_FIPS_IND_GET_CTX_FROM_PARAM(ctx, p.ind))
         return 0;
     return 1;
@@ -447,6 +599,195 @@ static const OSSL_PARAM *kdf_tls1_prf_gettable_ctx_params(
     return tls1prf_get_ctx_params_list;
 }

+static void tls1_prf_multi_cleanup(TLS1_PRF *ctx)
+{
+    int i;
+
+    OPENSSL_clear_free(ctx->multi.key_block, ctx->multi.key_block_len);
+    for (i = 0; i < TLS1_PRF_NUM_KEYTYPES; i++)
+        OPENSSL_free(ctx->multi.keytype[i]);
+    memset(&ctx->multi, 0, sizeof(ctx->multi));
+}
+
+static int kdf_tls1_prf_derive_multi(void *vctx, const OSSL_PARAM params[])
+{
+    TLS1_PRF *ctx = (TLS1_PRF *)vctx;
+    size_t total, cipher_key_len;
+    int err = 0;
+
+    /* Discard anything left by a previous derivation on this context */
+    tls1_prf_multi_cleanup(ctx);
+
+    if (!ossl_prov_is_running() || !kdf_tls1_prf_set_ctx_params(ctx, params))
+        return 0;
+
+    if (ctx->P_hash == NULL) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_MESSAGE_DIGEST);
+        return 0;
+    }
+    if (ctx->sec == NULL) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_SECRET);
+        return 0;
+    }
+    if (ctx->seedlen == 0) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_SEED);
+        return 0;
+    }
+
+    /*
+     * Settle on the cipher key length: the caller's, the named cipher's, or
+     * an error if they disagree.  See the field comments in TLS1_PRF.
+     *
+     * The IV length is not taken from the cipher: the IV in a TLS 1.2 key
+     * block is whatever the protocol says it is, which for an AEAD suite is
+     * the implicit nonce rather than the cipher's full IV.
+     */
+    cipher_key_len = ctx->cipher_key_len;
+    if (ctx->cipher_keylen != 0) {
+        if (cipher_key_len == 0) {
+            cipher_key_len = ctx->cipher_keylen;
+        } else if (cipher_key_len != ctx->cipher_keylen) {
+            ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH,
+                "%s needs a %zu byte key, not %zu", ctx->cipher_name,
+                ctx->cipher_keylen, cipher_key_len);
+            return 0;
+        }
+    }
+
+    /* total = 2 * (mac_key_len + cipher_key_len + iv_len) */
+    total = safe_add_size_t(ctx->mac_key_len, cipher_key_len, &err);
+    total = safe_add_size_t(total, ctx->iv_len, &err);
+    total = safe_mul_size_t(total, 2, &err);
+    if (err || total == 0) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
+        return 0;
+    }
+
+#ifdef FIPS_MODULE
+    if (!fips_ems_check_passed(ctx))
+        return 0;
+#endif
+
+    ctx->multi.mac_key_len = ctx->mac_key_len;
+    ctx->multi.cipher_key_len = cipher_key_len;
+    ctx->multi.iv_len = ctx->iv_len;
+
+    /*
+     * Settle on the key type for each category now, while the algorithm
+     * names are still to hand.  Which type a given algorithm maps to is this
+     * provider's business; see ossl_prov_cipher_skey_type().
+     */
+    ctx->multi.keytype[TLS1_PRF_KEYTYPE_CIPHER] = OPENSSL_strdup(ossl_prov_cipher_skey_type(ctx->cipher_name));
+    /*
+     * "mac" names the algorithm the MAC keys are for.  This provider has no
+     * MAC-specific key type to map it to, so they are plain secrets whatever
+     * it says; a provider backed by a token would decide differently here.
+     */
+    ctx->multi.keytype[TLS1_PRF_KEYTYPE_MAC] = OPENSSL_strdup(OSSL_SKEY_TYPE_GENERIC);
+    if (ctx->multi.keytype[TLS1_PRF_KEYTYPE_CIPHER] == NULL
+        || ctx->multi.keytype[TLS1_PRF_KEYTYPE_MAC] == NULL)
+        goto err;
+
+    ctx->multi.key_block = OPENSSL_zalloc(total);
+    if (ctx->multi.key_block == NULL)
+        goto err;
+    ctx->multi.key_block_len = total;
+
+    if (!tls1_prf_alg(ctx->P_hash, ctx->P_sha1,
+            ctx->sec, ctx->seclen,
+            ctx->seed, ctx->seedlen,
+            ctx->multi.key_block, ctx->multi.key_block_len))
+        goto err;
+
+    return 1;
+
+err:
+    tls1_prf_multi_cleanup(ctx);
+    return 0;
+}
+
+/*
+ * Map a purpose string to an offset and length within the key block.
+ * Key block layout: client_MAC | server_MAC | client_key | server_key |
+ *                   client_iv  | server_iv
+ */
+static int tls1_prf_purpose_to_offset(const TLS1_PRF *ctx,
+    const char *purpose, size_t *offset, size_t *len)
+{
+    size_t mac2 = 2 * ctx->multi.mac_key_len;
+    size_t key2 = 2 * ctx->multi.cipher_key_len;
+
+    if (strcmp(purpose, OSSL_KDF_PURPOSE_CLIENT_MAC_KEY) == 0) {
+        *offset = 0;
+        *len = ctx->multi.mac_key_len;
+    } else if (strcmp(purpose, OSSL_KDF_PURPOSE_SERVER_MAC_KEY) == 0) {
+        *offset = ctx->multi.mac_key_len;
+        *len = ctx->multi.mac_key_len;
+    } else if (strcmp(purpose, OSSL_KDF_PURPOSE_CLIENT_CIPHER_KEY) == 0) {
+        *offset = mac2;
+        *len = ctx->multi.cipher_key_len;
+    } else if (strcmp(purpose, OSSL_KDF_PURPOSE_SERVER_CIPHER_KEY) == 0) {
+        *offset = mac2 + ctx->multi.cipher_key_len;
+        *len = ctx->multi.cipher_key_len;
+    } else if (strcmp(purpose, OSSL_KDF_PURPOSE_CLIENT_IV) == 0) {
+        *offset = mac2 + key2;
+        *len = ctx->multi.iv_len;
+    } else if (strcmp(purpose, OSSL_KDF_PURPOSE_SERVER_IV) == 0) {
+        *offset = mac2 + key2 + ctx->multi.iv_len;
+        *len = ctx->multi.iv_len;
+    } else {
+        return 0;
+    }
+    return 1;
+}
+
+static void *kdf_tls1_prf_get_skey(void *vctx, const char *purpose,
+    void *provctx, OSSL_FUNC_skeymgmt_import_fn *import)
+{
+    TLS1_PRF *ctx = (TLS1_PRF *)vctx;
+    size_t offset, len;
+    OSSL_PARAM import_params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
+
+    if (ctx->multi.key_block == NULL
+        || (strcmp(purpose, OSSL_KDF_PURPOSE_CLIENT_MAC_KEY) != 0
+            && strcmp(purpose, OSSL_KDF_PURPOSE_SERVER_MAC_KEY) != 0
+            && strcmp(purpose, OSSL_KDF_PURPOSE_CLIENT_CIPHER_KEY) != 0
+            && strcmp(purpose, OSSL_KDF_PURPOSE_SERVER_CIPHER_KEY) != 0)
+        || !tls1_prf_purpose_to_offset(ctx, purpose, &offset, &len)
+        || len == 0) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DATA);
+        return NULL;
+    }
+
+    import_params[0] = OSSL_PARAM_construct_octet_string(
+        OSSL_SKEY_PARAM_RAW_BYTES, ctx->multi.key_block + offset, len);
+
+    return import(provctx, OSSL_SKEYMGMT_SELECT_SECRET_KEY, import_params);
+}
+
+static int kdf_tls1_prf_get_iv(void *vctx, const char *purpose,
+    const unsigned char **pIV, size_t *pIVlen)
+{
+    TLS1_PRF *ctx = (TLS1_PRF *)vctx;
+    size_t offset, len;
+
+    if (!ossl_prov_is_running())
+        return 0;
+
+    if (ctx->multi.key_block == NULL
+        || (strcmp(purpose, OSSL_KDF_PURPOSE_CLIENT_IV) != 0
+            && strcmp(purpose, OSSL_KDF_PURPOSE_SERVER_IV) != 0)
+        || !tls1_prf_purpose_to_offset(ctx, purpose, &offset, &len)
+        || len == 0) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DATA);
+        return 0;
+    }
+
+    *pIV = ctx->multi.key_block + offset;
+    *pIVlen = len;
+    return 1;
+}
+
 const OSSL_DISPATCH ossl_kdf_tls1_prf_functions[] = {
     { OSSL_FUNC_KDF_NEWCTX, (void (*)(void))kdf_tls1_prf_new },
     { OSSL_FUNC_KDF_DUPCTX, (void (*)(void))kdf_tls1_prf_dup },
@@ -461,6 +802,12 @@ const OSSL_DISPATCH ossl_kdf_tls1_prf_functions[] = {
         (void (*)(void))kdf_tls1_prf_gettable_ctx_params },
     { OSSL_FUNC_KDF_GET_CTX_PARAMS,
         (void (*)(void))kdf_tls1_prf_get_ctx_params },
+    { OSSL_FUNC_KDF_DERIVE_MULTI,
+        (void (*)(void))kdf_tls1_prf_derive_multi },
+    { OSSL_FUNC_KDF_GET_SKEY,
+        (void (*)(void))kdf_tls1_prf_get_skey },
+    { OSSL_FUNC_KDF_GET_IV,
+        (void (*)(void))kdf_tls1_prf_get_iv },
     OSSL_DISPATCH_END
 };

diff --git a/providers/implementations/kdfs/tls1_prf.inc.in b/providers/implementations/kdfs/tls1_prf.inc.in
index 03583fcd05..afc6b703e0 100644
--- a/providers/implementations/kdfs/tls1_prf.inc.in
+++ b/providers/implementations/kdfs/tls1_prf.inc.in
@@ -12,16 +12,25 @@ use OpenSSL::paramnames qw(produce_param_decoder);
 -}

 {- produce_param_decoder('tls1prf_set_ctx_params',
-                         (['OSSL_KDF_PARAM_PROPERTIES',        'propq',  'utf8_string'],
-                          ['OSSL_KDF_PARAM_DIGEST',            'digest', 'utf8_string'],
-                          ['OSSL_KDF_PARAM_SECRET',            'secret', 'octet_string'],
-                          ['OSSL_KDF_PARAM_SEED',              'seed',   'octet_string', TLSPRF_MAX_SEEDS],
-                          ['OSSL_KDF_PARAM_FIPS_EMS_CHECK',    'ind_e',  'int', 'fips'],
-                          ['OSSL_KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d',  'int', 'fips'],
-                          ['OSSL_KDF_PARAM_FIPS_KEY_CHECK',    'ind_k',  'int', 'fips'],
+                         (['OSSL_KDF_PARAM_PROPERTIES',        'propq',          'utf8_string'],
+                          ['OSSL_KDF_PARAM_DIGEST',            'digest',         'utf8_string'],
+                          ['OSSL_KDF_PARAM_SECRET',            'secret',         'octet_string'],
+                          ['OSSL_KDF_PARAM_SEED',              'seed',           'octet_string', TLSPRF_MAX_SEEDS],
+                          ['OSSL_KDF_PARAM_MAC_KEY_LEN',       'mac_key_len',    'size_t'],
+                          ['OSSL_KDF_PARAM_CIPHER_KEY_LEN',    'cipher_key_len', 'size_t'],
+                          ['OSSL_KDF_PARAM_IV_LEN',            'iv_len',         'size_t'],
+                          ['OSSL_KDF_PARAM_CIPHER',            'cipher',         'utf8_string'],
+                          ['OSSL_KDF_PARAM_MAC',               'mac',            'utf8_string'],
+                          ['OSSL_KDF_PARAM_FIPS_EMS_CHECK',    'ind_e',          'int', 'fips'],
+                          ['OSSL_KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d',          'int', 'fips'],
+                          ['OSSL_KDF_PARAM_FIPS_KEY_CHECK',    'ind_k',          'int', 'fips'],
                          )); -}

 {- produce_param_decoder('tls1prf_get_ctx_params',
                          (['OSSL_KDF_PARAM_SIZE',                    'size', 'size_t'],
                           ['OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind',  'int', 'fips'],
+                          ['OSSL_KDF_PURPOSE_CLIENT_MAC_KEY',    'client_mac_type',    'utf8_string'],
+                          ['OSSL_KDF_PURPOSE_SERVER_MAC_KEY',    'server_mac_type',    'utf8_string'],
+                          ['OSSL_KDF_PURPOSE_CLIENT_CIPHER_KEY', 'client_cipher_type', 'utf8_string'],
+                          ['OSSL_KDF_PURPOSE_SERVER_CIPHER_KEY', 'server_cipher_type', 'utf8_string'],
                          )); -}
diff --git a/test/evp_kdf_test.c b/test/evp_kdf_test.c
index 155f093d95..bea17fee42 100644
--- a/test/evp_kdf_test.c
+++ b/test/evp_kdf_test.c
@@ -251,6 +251,436 @@ static int test_kdf_tls1_prf_1byte_seed(void)
     return ret;
 }

+static int test_kdf_tls1_prf_derive_multi_consistency(void)
+{
+    int ret = 0;
+    EVP_KDF_CTX *kctx_raw = NULL, *kctx_multi = NULL;
+    unsigned char raw_block[64];
+    unsigned char reassembled[64];
+    size_t mac_key_len = 10, cipher_key_len = 16, iv_len = 6;
+    size_t total = 2 * (mac_key_len + cipher_key_len + iv_len);
+    OSSL_PARAM *params = NULL;
+    OSSL_PARAM multi_params[7];
+    OSSL_PARAM *mp = multi_params;
+    EVP_SKEY *skey = NULL;
+    const unsigned char *raw = NULL;
+    size_t raw_len = 0;
+    const unsigned char *iv = NULL;
+    size_t iv_len_out = 0;
+
+    params = construct_tls1_prf_params("sha256", "secret", "seed");
+    if (!TEST_ptr(params))
+        goto err;
+
+    /* Derive raw key block */
+    if (!TEST_ptr(kctx_raw = get_kdfbyname(OSSL_KDF_NAME_TLS1_PRF))
+        || !TEST_int_gt(EVP_KDF_derive(kctx_raw, raw_block, total, params), 0))
+        goto err;
+
+    /* Derive via multi-derive */
+    if (!TEST_ptr(kctx_multi = get_kdfbyname(OSSL_KDF_NAME_TLS1_PRF)))
+        goto err;
+
+    *mp++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST,
+        "sha256", 0);
+    *mp++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SECRET,
+        (unsigned char *)"secret", 6);
+    *mp++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
+        (unsigned char *)"seed", 4);
+    *mp++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_MAC_KEY_LEN,
+        &mac_key_len);
+    *mp++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_CIPHER_KEY_LEN,
+        &cipher_key_len);
+    *mp++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_IV_LEN,
+        &iv_len);
+    *mp = OSSL_PARAM_construct_end();
+
+    if (!TEST_int_gt(EVP_KDF_derive_SKEYs(kctx_multi, multi_params), 0))
+        goto err;
+
+    /* Reassemble from individual keys and IVs */
+    memset(reassembled, 0, sizeof(reassembled));
+
+    /* client_MAC_key */
+    if (!TEST_ptr(skey = EVP_KDF_CTX_get1_SKEY(kctx_multi, OSSL_KDF_PURPOSE_CLIENT_MAC_KEY, NULL))
+        || !TEST_int_eq(EVP_SKEY_get0_raw_key(skey, &raw, &raw_len), 1)
+        || !TEST_size_t_eq(raw_len, mac_key_len))
+        goto err;
+    memcpy(reassembled, raw, raw_len);
+    EVP_SKEY_free(skey);
+    skey = NULL;
+
+    /* server_MAC_key */
+    if (!TEST_ptr(skey = EVP_KDF_CTX_get1_SKEY(kctx_multi, OSSL_KDF_PURPOSE_SERVER_MAC_KEY, NULL))
+        || !TEST_int_eq(EVP_SKEY_get0_raw_key(skey, &raw, &raw_len), 1)
+        || !TEST_size_t_eq(raw_len, mac_key_len))
+        goto err;
+    memcpy(reassembled + mac_key_len, raw, raw_len);
+    EVP_SKEY_free(skey);
+    skey = NULL;
+
+    /* client_cipher_key */
+    if (!TEST_ptr(skey = EVP_KDF_CTX_get1_SKEY(kctx_multi, OSSL_KDF_PURPOSE_CLIENT_CIPHER_KEY, NULL))
+        || !TEST_int_eq(EVP_SKEY_get0_raw_key(skey, &raw, &raw_len), 1)
+        || !TEST_size_t_eq(raw_len, cipher_key_len))
+        goto err;
+    memcpy(reassembled + 2 * mac_key_len, raw, raw_len);
+    EVP_SKEY_free(skey);
+    skey = NULL;
+
+    /* server_cipher_key */
+    if (!TEST_ptr(skey = EVP_KDF_CTX_get1_SKEY(kctx_multi, OSSL_KDF_PURPOSE_SERVER_CIPHER_KEY, NULL))
+        || !TEST_int_eq(EVP_SKEY_get0_raw_key(skey, &raw, &raw_len), 1)
+        || !TEST_size_t_eq(raw_len, cipher_key_len))
+        goto err;
+    memcpy(reassembled + 2 * mac_key_len + cipher_key_len, raw, raw_len);
+    EVP_SKEY_free(skey);
+    skey = NULL;
+
+    /* client_IV */
+    if (!TEST_int_eq(EVP_KDF_CTX_get0_IV(kctx_multi, OSSL_KDF_PURPOSE_CLIENT_IV, &iv, &iv_len_out), 1)
+        || !TEST_size_t_eq(iv_len_out, iv_len))
+        goto err;
+    memcpy(reassembled + 2 * (mac_key_len + cipher_key_len), iv, iv_len_out);
+
+    /* server_IV */
+    if (!TEST_int_eq(EVP_KDF_CTX_get0_IV(kctx_multi, OSSL_KDF_PURPOSE_SERVER_IV, &iv, &iv_len_out), 1)
+        || !TEST_size_t_eq(iv_len_out, iv_len))
+        goto err;
+    memcpy(reassembled + 2 * (mac_key_len + cipher_key_len) + iv_len, iv, iv_len_out);
+
+    /* Verify match */
+    if (!TEST_mem_eq(raw_block, total, reassembled, total))
+        goto err;
+
+    ret = 1;
+err:
+    EVP_SKEY_free(skey);
+    EVP_KDF_CTX_free(kctx_raw);
+    EVP_KDF_CTX_free(kctx_multi);
+    OPENSSL_free(params);
+    return ret;
+}
+
+static int test_kdf_tls1_prf_derive_multi_bad_purpose(void)
+{
+    int ret = 0;
+    EVP_KDF_CTX *kctx = NULL;
+    OSSL_PARAM multi_params[7];
+    OSSL_PARAM *mp = multi_params;
+    size_t mac_key_len = 10, cipher_key_len = 16, iv_len = 6;
+    EVP_SKEY *skey = NULL;
+    const unsigned char *iv = NULL;
+    size_t iv_len_out = 0;
+
+    if (!TEST_ptr(kctx = get_kdfbyname(OSSL_KDF_NAME_TLS1_PRF)))
+        goto err;
+
+    *mp++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST,
+        "sha256", 0);
+    *mp++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SECRET,
+        (unsigned char *)"secret", 6);
+    *mp++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
+        (unsigned char *)"seed", 4);
+    *mp++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_MAC_KEY_LEN,
+        &mac_key_len);
+    *mp++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_CIPHER_KEY_LEN,
+        &cipher_key_len);
+    *mp++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_IV_LEN,
+        &iv_len);
+    *mp = OSSL_PARAM_construct_end();
+
+    if (!TEST_int_gt(EVP_KDF_derive_SKEYs(kctx, multi_params), 0))
+        goto err;
+
+    if (!TEST_ptr_null(skey = EVP_KDF_CTX_get1_SKEY(kctx, "nonexistent", NULL)))
+        goto err;
+
+    if (!TEST_int_eq(EVP_KDF_CTX_get0_IV(kctx, "nonexistent", &iv, &iv_len_out), 0))
+        goto err;
+
+    ret = 1;
+err:
+    EVP_SKEY_free(skey);
+    EVP_KDF_CTX_free(kctx);
+    return ret;
+}
+
+static int test_kdf_tls1_prf_derive_multi_no_derive(void)
+{
+    int ret = 0;
+    EVP_KDF_CTX *kctx = NULL;
+    EVP_SKEY *skey = NULL;
+    const unsigned char *iv = NULL;
+    size_t iv_len_out = 0;
+
+    if (!TEST_ptr(kctx = get_kdfbyname(OSSL_KDF_NAME_TLS1_PRF)))
+        goto err;
+
+    if (!TEST_ptr_null(skey = EVP_KDF_CTX_get1_SKEY(kctx, OSSL_KDF_PURPOSE_CLIENT_MAC_KEY, NULL)))
+        goto err;
+
+    if (!TEST_int_eq(EVP_KDF_CTX_get0_IV(kctx, OSSL_KDF_PURPOSE_CLIENT_IV, &iv, &iv_len_out), 0))
+        goto err;
+
+    ret = 1;
+err:
+    EVP_SKEY_free(skey);
+    EVP_KDF_CTX_free(kctx);
+    return ret;
+}
+
+/*
+ * Naming the cipher the key is for is enough: the provider takes the key
+ * length from it and settles on its own key type, while the MAC keys, whose
+ * length only TLS knows, stay generic secrets of the length asked for.
+ */
+static int test_kdf_tls1_prf_derive_multi_keytypes(void)
+{
+    int ret = 0;
+    EVP_KDF_CTX *kctx = NULL;
+    EVP_SKEY *skey = NULL;
+    const unsigned char *raw;
+    size_t raw_len;
+    size_t mac_key_len = 32, iv_len = 16;
+    OSSL_PARAM params[9], *p = params;
+
+    *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, "sha256", 0);
+    *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SECRET,
+        (unsigned char *)"secret", 6);
+    *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
+        (unsigned char *)"seed", 4);
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_MAC_KEY_LEN,
+        &mac_key_len);
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_IV_LEN, &iv_len);
+    /* No cipher_key_len: AES-128-CBC already says it is 16 bytes */
+    *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_CIPHER,
+        "AES-128-CBC", 0);
+    *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_MAC, "HMAC", 0);
+    *p = OSSL_PARAM_construct_end();
+
+    if (!TEST_ptr(kctx = get_kdfbyname(OSSL_KDF_NAME_TLS1_PRF))
+        || !TEST_int_gt(EVP_KDF_derive_SKEYs(kctx, params), 0))
+        goto err;
+
+    if (!TEST_ptr(skey = EVP_KDF_CTX_get1_SKEY(kctx,
+                      OSSL_KDF_PURPOSE_CLIENT_CIPHER_KEY, NULL))
+        || !TEST_true(EVP_SKEY_is_a(skey, OSSL_SKEY_TYPE_AES))
+        || !TEST_int_eq(EVP_SKEY_get0_raw_key(skey, &raw, &raw_len), 1)
+        || !TEST_size_t_eq(raw_len, 16))
+        goto err;
+    EVP_SKEY_free(skey);
+    skey = NULL;
+
+    if (!TEST_ptr(skey = EVP_KDF_CTX_get1_SKEY(kctx,
+                      OSSL_KDF_PURPOSE_CLIENT_MAC_KEY, NULL))
+        || !TEST_true(EVP_SKEY_is_a(skey, OSSL_SKEY_TYPE_GENERIC))
+        || !TEST_int_eq(EVP_SKEY_get0_raw_key(skey, &raw, &raw_len), 1)
+        || !TEST_size_t_eq(raw_len, mac_key_len))
+        goto err;
+
+    ret = 1;
+err:
+    EVP_SKEY_free(skey);
+    EVP_KDF_CTX_free(kctx);
+    return ret;
+}
+
+/*
+ * Duplicating a context duplicates the derivation result with it: every
+ * purpose yields the same key or IV, of the same type, from either context,
+ * and the two are independent once one is freed.
+ */
+static int test_kdf_tls1_prf_derive_multi_dup(void)
+{
+    static const char *const key_purposes[] = {
+        OSSL_KDF_PURPOSE_CLIENT_MAC_KEY, OSSL_KDF_PURPOSE_SERVER_MAC_KEY,
+        OSSL_KDF_PURPOSE_CLIENT_CIPHER_KEY, OSSL_KDF_PURPOSE_SERVER_CIPHER_KEY
+    };
+    static const char *const iv_purposes[] = {
+        OSSL_KDF_PURPOSE_CLIENT_IV, OSSL_KDF_PURPOSE_SERVER_IV
+    };
+    int ret = 0, i;
+    EVP_KDF_CTX *kctx = NULL, *copy = NULL, *fresh = NULL, *fresh_copy = NULL;
+    EVP_SKEY *skey = NULL, *dkey = NULL;
+    const unsigned char *raw, *draw, *iv, *div;
+    size_t raw_len, draw_len, iv_len_out, div_len;
+    unsigned char saved_iv[16];
+    size_t saved_iv_len;
+    size_t mac_key_len = 32, iv_len = 16;
+    OSSL_PARAM params[9], *p = params;
+
+    *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, "sha256", 0);
+    *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SECRET,
+        (unsigned char *)"secret", 6);
+    *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
+        (unsigned char *)"seed", 4);
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_MAC_KEY_LEN,
+        &mac_key_len);
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_IV_LEN, &iv_len);
+    *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_CIPHER,
+        "AES-128-CBC", 0);
+    *p = OSSL_PARAM_construct_end();
+
+    /* A context with no derivation result duplicates fine */
+    if (!TEST_ptr(fresh = get_kdfbyname(OSSL_KDF_NAME_TLS1_PRF))
+        || !TEST_ptr(fresh_copy = EVP_KDF_CTX_dup(fresh)))
+        goto err;
+
+    if (!TEST_ptr(kctx = get_kdfbyname(OSSL_KDF_NAME_TLS1_PRF))
+        || !TEST_int_gt(EVP_KDF_derive_SKEYs(kctx, params), 0)
+        || !TEST_ptr(copy = EVP_KDF_CTX_dup(kctx)))
+        goto err;
+
+    for (i = 0; i < (int)OSSL_NELEM(key_purposes); i++) {
+        if (!TEST_ptr(skey = EVP_KDF_CTX_get1_SKEY(kctx, key_purposes[i], NULL))
+            || !TEST_ptr(dkey = EVP_KDF_CTX_get1_SKEY(copy, key_purposes[i],
+                             NULL))
+            || !TEST_int_eq(EVP_SKEY_get0_raw_key(skey, &raw, &raw_len), 1)
+            || !TEST_int_eq(EVP_SKEY_get0_raw_key(dkey, &draw, &draw_len), 1)
+            || !TEST_mem_eq(raw, raw_len, draw, draw_len)
+            || !TEST_str_eq(EVP_SKEY_get0_skeymgmt_name(skey),
+                EVP_SKEY_get0_skeymgmt_name(dkey)))
+            goto err;
+        EVP_SKEY_free(skey);
+        EVP_SKEY_free(dkey);
+        skey = dkey = NULL;
+    }
+
+    for (i = 0; i < (int)OSSL_NELEM(iv_purposes); i++) {
+        if (!TEST_int_eq(EVP_KDF_CTX_get0_IV(kctx, iv_purposes[i], &iv,
+                             &iv_len_out),
+                1)
+            || !TEST_int_eq(EVP_KDF_CTX_get0_IV(copy, iv_purposes[i], &div,
+                                &div_len),
+                1)
+            || !TEST_mem_eq(iv, iv_len_out, div, div_len))
+            goto err;
+        /* The copy must own its IV, not point into the original */
+        if (!TEST_ptr_ne((void *)iv, (void *)div))
+            goto err;
+    }
+
+    /*
+     * Freeing the original must leave the copy intact.  The IVs matter most
+     * here: EVP_KDF_CTX_get0_IV() hands out a pointer into the context.
+     */
+    if (!TEST_int_eq(EVP_KDF_CTX_get0_IV(copy, OSSL_KDF_PURPOSE_CLIENT_IV,
+                         &div, &div_len),
+            1)
+        || !TEST_size_t_le(div_len, sizeof(saved_iv)))
+        goto err;
+    memcpy(saved_iv, div, div_len);
+    saved_iv_len = div_len;
+
+    EVP_KDF_CTX_free(kctx);
+    kctx = NULL;
+
+    if (!TEST_int_eq(EVP_KDF_CTX_get0_IV(copy, OSSL_KDF_PURPOSE_CLIENT_IV,
+                         &div, &div_len),
+            1)
+        || !TEST_mem_eq(div, div_len, saved_iv, saved_iv_len))
+        goto err;
+    if (!TEST_ptr(dkey = EVP_KDF_CTX_get1_SKEY(copy,
+                      OSSL_KDF_PURPOSE_CLIENT_CIPHER_KEY, NULL))
+        || !TEST_true(EVP_SKEY_is_a(dkey, OSSL_SKEY_TYPE_AES)))
+        goto err;
+
+    ret = 1;
+err:
+    EVP_SKEY_free(skey);
+    EVP_SKEY_free(dkey);
+    EVP_KDF_CTX_free(kctx);
+    EVP_KDF_CTX_free(copy);
+    EVP_KDF_CTX_free(fresh);
+    EVP_KDF_CTX_free(fresh_copy);
+    return ret;
+}
+
+/*
+ * A key length the requested type cannot accept must be rejected by
+ * EVP_KDF_derive_SKEYs() itself, not left to surface at collection time.
+ */
+static int test_kdf_tls1_prf_derive_multi_bad_keylen(void)
+{
+    int ret = 0;
+    EVP_KDF_CTX *kctx = NULL;
+    size_t mac_key_len = 16, cipher_key_len = 10, iv_len = 6;
+    OSSL_PARAM params[9], *p = params;
+
+    *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, "sha256", 0);
+    *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SECRET,
+        (unsigned char *)"secret", 6);
+    *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
+        (unsigned char *)"seed", 4);
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_MAC_KEY_LEN,
+        &mac_key_len);
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_CIPHER_KEY_LEN,
+        &cipher_key_len);
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_IV_LEN, &iv_len);
+    /* AES-128-CBC takes a 16 byte key, so 10 contradicts it */
+    *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_CIPHER,
+        "AES-128-CBC", 0);
+    *p = OSSL_PARAM_construct_end();
+
+    if (!TEST_ptr(kctx = get_kdfbyname(OSSL_KDF_NAME_TLS1_PRF))
+        || !TEST_int_le(EVP_KDF_derive_SKEYs(kctx, params), 0))
+        goto err;
+
+    ret = 1;
+err:
+    EVP_KDF_CTX_free(kctx);
+    return ret;
+}
+
+/*
+ * An AEAD ciphersuite derives no MAC keys at all.  Those slots must simply
+ * be absent rather than making the whole derivation fail.
+ */
+static int test_kdf_tls1_prf_derive_multi_no_mac_keys(void)
+{
+    int ret = 0;
+    EVP_KDF_CTX *kctx = NULL;
+    EVP_SKEY *skey = NULL;
+    size_t mac_key_len = 0, cipher_key_len = 16, iv_len = 12;
+    OSSL_PARAM params[9], *p = params;
+
+    *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, "sha256", 0);
+    *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SECRET,
+        (unsigned char *)"secret", 6);
+    *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
+        (unsigned char *)"seed", 4);
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_MAC_KEY_LEN,
+        &mac_key_len);
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_CIPHER_KEY_LEN,
+        &cipher_key_len);
+    *p++ = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_IV_LEN, &iv_len);
+    *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_CIPHER,
+        "AES-128-CBC", 0);
+    *p = OSSL_PARAM_construct_end();
+
+    if (!TEST_ptr(kctx = get_kdfbyname(OSSL_KDF_NAME_TLS1_PRF))
+        || !TEST_int_gt(EVP_KDF_derive_SKEYs(kctx, params), 0))
+        goto err;
+
+    if (!TEST_ptr(skey = EVP_KDF_CTX_get1_SKEY(kctx,
+                      OSSL_KDF_PURPOSE_CLIENT_CIPHER_KEY, NULL))
+        || !TEST_true(EVP_SKEY_is_a(skey, OSSL_SKEY_TYPE_AES)))
+        goto err;
+    EVP_SKEY_free(skey);
+    skey = NULL;
+
+    if (!TEST_ptr_null(skey = EVP_KDF_CTX_get1_SKEY(kctx,
+                           OSSL_KDF_PURPOSE_CLIENT_MAC_KEY, NULL)))
+        goto err;
+
+    ret = 1;
+err:
+    EVP_SKEY_free(skey);
+    EVP_KDF_CTX_free(kctx);
+    return ret;
+}
+
 static OSSL_PARAM *construct_hkdf_params(char *digest, char *key,
     size_t keylen, char *salt, char *info)
 {
@@ -2590,6 +3020,13 @@ int setup_tests(void)
     ADD_TEST(test_kdf_tls1_prf_1byte_secret);
     ADD_TEST(test_kdf_tls1_prf_empty_seed);
     ADD_TEST(test_kdf_tls1_prf_1byte_seed);
+    ADD_TEST(test_kdf_tls1_prf_derive_multi_consistency);
+    ADD_TEST(test_kdf_tls1_prf_derive_multi_bad_purpose);
+    ADD_TEST(test_kdf_tls1_prf_derive_multi_no_derive);
+    ADD_TEST(test_kdf_tls1_prf_derive_multi_keytypes);
+    ADD_TEST(test_kdf_tls1_prf_derive_multi_dup);
+    ADD_TEST(test_kdf_tls1_prf_derive_multi_bad_keylen);
+    ADD_TEST(test_kdf_tls1_prf_derive_multi_no_mac_keys);
     ADD_TEST(test_kdf_hkdf);
     ADD_TEST(test_kdf_hkdf_invalid_digest);
     ADD_TEST(test_kdf_hkdf_fixed_digest_change_digest);