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);