[PATCH v3 2/3] crypto/openssl: add ML crypto support

[Gowrishankar Muthukrishnan <gmuthukrishn@marvell.com>]

Add ML-KEM and ML-DSA support.

Signed-off-by: Gowrishankar Muthukrishnan <gmuthukrishn@marvell.com>
---
v3:
 - Fixed ML-DSA keygen capability only for OpenSSL 3.5.1 onwards.
---
 doc/guides/cryptodevs/features/openssl.ini   |   2 +
 drivers/crypto/openssl/openssl_pmd_private.h |  16 +
 drivers/crypto/openssl/rte_openssl_pmd.c     | 870 +++++++++++++++++++
 drivers/crypto/openssl/rte_openssl_pmd_ops.c | 133 +++
 4 files changed, 1021 insertions(+)

diff --git a/doc/guides/cryptodevs/features/openssl.ini b/doc/guides/cryptodevs/features/openssl.ini
index f0074a46f8..df6e7de316 100644
--- a/doc/guides/cryptodevs/features/openssl.ini
+++ b/doc/guides/cryptodevs/features/openssl.ini
@@ -67,6 +67,8 @@ Modular Inversion = Y
 Diffie-hellman = Y
 SM2 = Y
 EdDSA = Y
+ML-KEM = Y
+ML-DSA = Y
 
 ;
 ; Supported Operating systems of the 'openssl' crypto driver.
diff --git a/drivers/crypto/openssl/openssl_pmd_private.h b/drivers/crypto/openssl/openssl_pmd_private.h
index 4a6a088870..7f87840b84 100644
--- a/drivers/crypto/openssl/openssl_pmd_private.h
+++ b/drivers/crypto/openssl/openssl_pmd_private.h
@@ -249,6 +249,20 @@ struct __rte_cache_aligned openssl_asym_session {
 			OSSL_PARAM * params;
 #endif
 		} eddsa;
+		struct {
+			uint8_t param;
+#if (OPENSSL_VERSION_NUMBER >= 0x30500000L)
+			EVP_PKEY_CTX * pctx;
+#endif
+		} ml_kem;
+		struct {
+			uint8_t param;
+			bool sign_prehash;
+			bool sign_deterministic;
+#if (OPENSSL_VERSION_NUMBER >= 0x30500000L)
+			EVP_PKEY_CTX * pctx;
+#endif
+		} ml_dsa;
 	} u;
 };
 /** Set and validate OPENSSL crypto session parameters */
@@ -264,4 +278,6 @@ openssl_reset_session(struct openssl_session *sess);
 /** device specific operations function pointer structure */
 extern struct rte_cryptodev_ops *rte_openssl_pmd_ops;
 
+extern const char *ml_kem_paramset_names[];
+extern const char *ml_dsa_paramset_names[];
 #endif /* _OPENSSL_PMD_PRIVATE_H_ */
diff --git a/drivers/crypto/openssl/rte_openssl_pmd.c b/drivers/crypto/openssl/rte_openssl_pmd.c
index 5bfad92b7c..86c29bc55d 100644
--- a/drivers/crypto/openssl/rte_openssl_pmd.c
+++ b/drivers/crypto/openssl/rte_openssl_pmd.c
@@ -3255,6 +3255,7 @@ process_openssl_eddsa_op_evp(struct rte_crypto_op *cop,
 
 	return ret;
 }
+
 #else
 static int
 process_openssl_rsa_op(struct rte_crypto_op *cop,
@@ -3383,6 +3384,861 @@ process_openssl_eddsa_op(struct rte_crypto_op *cop,
 }
 #endif
 
+#if (OPENSSL_VERSION_NUMBER >= 0x30500000L)
+static int
+mlkem_keygen_op_evp(struct rte_crypto_op *cop,
+		struct openssl_asym_session *sess)
+{
+	struct rte_crypto_ml_kem_op *op = &cop->asym->mlkem;
+	EVP_PKEY_CTX *pctx = sess->u.ml_kem.pctx;
+	OSSL_PARAM_BLD *param_bld;
+	uint8_t seed[64] = {0};
+	EVP_PKEY *pkey = NULL;
+	OSSL_PARAM *params;
+	const char *param;
+	size_t keylen = 0;
+	void *key = NULL;
+	OSSL_PARAM *p;
+
+	param = ml_kem_paramset_names[sess->u.ml_kem.param];
+	if (param == NULL) {
+		OPENSSL_LOG(ERR, "invalid ml_kem param set");
+		return -EINVAL;
+	}
+
+	memcpy(seed, op->keygen.d.data, op->keygen.d.length);
+	memcpy(seed + op->keygen.d.length,
+		op->keygen.z.data, op->keygen.z.length);
+
+	param_bld = OSSL_PARAM_BLD_new();
+	if (param_bld == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (!OSSL_PARAM_BLD_push_utf8_string(param_bld,
+			OSSL_PKEY_PARAM_GROUP_NAME,
+			param, strlen(param)) ||
+		!OSSL_PARAM_BLD_push_octet_string(param_bld,
+			OSSL_PKEY_PARAM_ML_KEM_SEED,
+			seed, sizeof(seed))) {
+		OSSL_PARAM_BLD_free(param_bld);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	params = OSSL_PARAM_BLD_to_param(param_bld);
+	OSSL_PARAM_BLD_free(param_bld);
+	if (params == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+	if (EVP_PKEY_fromdata_init(pctx) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+	if (EVP_PKEY_fromdata(pctx, &pkey, EVP_PKEY_KEYPAIR, params) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+	OSSL_PARAM_free(params);
+
+	if (pkey == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	/* extract public and private keys */
+	if (EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, &params) != 1) {
+		OPENSSL_LOG(ERR, "Failed to convert to key pairs");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PRIV_KEY);
+	if (p == NULL) {
+		OPENSSL_LOG(ERR, "Failed to locate private key");
+		OSSL_PARAM_free(params);
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	OSSL_PARAM_get_octet_string(p, &key,
+		rte_crypto_ml_kem_pubkey_size[sess->u.ml_kem.param], &keylen);
+	memcpy(op->keygen.dk.data, key, keylen);
+	op->keygen.dk.length = keylen;
+
+	p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PUB_KEY);
+	if (p == NULL) {
+		OPENSSL_LOG(ERR, "Failed to locate public key");
+		OSSL_PARAM_free(params);
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	OSSL_PARAM_get_octet_string(p, &key,
+		rte_crypto_ml_kem_privkey_size[sess->u.ml_kem.param], &keylen);
+	memcpy(op->keygen.ek.data, key, keylen);
+	op->keygen.ek.length = keylen;
+
+	OSSL_PARAM_free(params);
+	EVP_PKEY_free(pkey);
+	cop->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
+	return 0;
+}
+
+static int
+mlkem_encap_op_evp(struct rte_crypto_op *cop,
+		struct openssl_asym_session *sess)
+{
+	struct rte_crypto_ml_kem_op *op = &cop->asym->mlkem;
+	EVP_PKEY_CTX *pctx = sess->u.ml_kem.pctx;
+	OSSL_PARAM_BLD *param_bld;
+	EVP_PKEY_CTX *cctx = NULL;
+	EVP_PKEY *pkey = NULL;
+	OSSL_PARAM *params;
+	const char *param;
+	size_t keylen = 0;
+	size_t outlen = 0;
+	int ret = -1;
+
+	param = ml_kem_paramset_names[sess->u.ml_kem.param];
+	if (param == NULL) {
+		OPENSSL_LOG(ERR, "invalid ml_kem param set");
+		return -EINVAL;
+	}
+
+	param_bld = OSSL_PARAM_BLD_new();
+	if (param_bld == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (!OSSL_PARAM_BLD_push_utf8_string(param_bld,
+			OSSL_PKEY_PARAM_GROUP_NAME,
+			param, strlen(param)) ||
+		!OSSL_PARAM_BLD_push_octet_string(param_bld,
+			OSSL_PKEY_PARAM_PUB_KEY,
+			op->encap.ek.data, op->encap.ek.length)) {
+		OSSL_PARAM_BLD_free(param_bld);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	params = OSSL_PARAM_BLD_to_param(param_bld);
+	OSSL_PARAM_BLD_free(param_bld);
+	if (params == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_fromdata_init(pctx) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_fromdata(pctx, &pkey, EVP_PKEY_PUBLIC_KEY, params) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+	OSSL_PARAM_free(params);
+
+	if (pkey == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	cctx = EVP_PKEY_CTX_new_from_pkey(NULL, pkey, NULL);
+	if (cctx == NULL) {
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_encapsulate_init(cctx, NULL) != 1) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (op->encap.message.length) {
+		const OSSL_PARAM kem_params[] = {
+			OSSL_PARAM_octet_string(OSSL_KEM_PARAM_IKME,
+				(void *)op->encap.message.data, op->encap.message.length),
+			OSSL_PARAM_END
+		};
+
+		if (EVP_PKEY_encapsulate_init(cctx, kem_params) != 1) {
+			EVP_PKEY_free(pkey);
+			cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+			return -1;
+		}
+	}
+
+	if (EVP_PKEY_encapsulate(cctx, NULL, &outlen, NULL, &keylen) != 1) {
+		OPENSSL_LOG(ERR, "Failed to determine output length");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (outlen > op->encap.cipher.length) {
+		OPENSSL_LOG(ERR, "Insufficient buffer for cipher text");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (keylen > op->encap.sk.length) {
+		OPENSSL_LOG(ERR, "Insufficient buffer for shared key");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_encapsulate(cctx, op->encap.cipher.data, &outlen,
+			op->encap.sk.data, &keylen) != 1) {
+		OPENSSL_LOG(ERR, "Failed to encapculate");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	op->encap.cipher.length = outlen;
+	op->encap.sk.length = keylen;
+
+	EVP_PKEY_CTX_free(cctx);
+	EVP_PKEY_free(pkey);
+	ret = 0;
+	cop->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
+	return ret;
+}
+
+static int
+mlkem_decap_op_evp(struct rte_crypto_op *cop,
+		struct openssl_asym_session *sess)
+{
+	struct rte_crypto_ml_kem_op *op = &cop->asym->mlkem;
+	EVP_PKEY_CTX *pctx = sess->u.ml_kem.pctx;
+	OSSL_PARAM_BLD *param_bld;
+	EVP_PKEY_CTX *cctx = NULL;
+	EVP_PKEY *pkey = NULL;
+	OSSL_PARAM *params;
+	const char *param;
+	size_t keylen = 0;
+	int ret = -1;
+
+	param = ml_kem_paramset_names[sess->u.ml_kem.param];
+	if (param == NULL) {
+		OPENSSL_LOG(ERR, "invalid ml_kem param set");
+		return -EINVAL;
+	}
+
+	param_bld = OSSL_PARAM_BLD_new();
+	if (param_bld == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (!OSSL_PARAM_BLD_push_utf8_string(param_bld,
+			OSSL_PKEY_PARAM_GROUP_NAME,
+			param, strlen(param)) ||
+		!OSSL_PARAM_BLD_push_octet_string(param_bld,
+			OSSL_PKEY_PARAM_PRIV_KEY,
+			op->decap.dk.data, op->decap.dk.length)) {
+		OSSL_PARAM_BLD_free(param_bld);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	params = OSSL_PARAM_BLD_to_param(param_bld);
+	OSSL_PARAM_BLD_free(param_bld);
+	if (params == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_fromdata_init(pctx) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_fromdata(pctx, &pkey, EVP_PKEY_PRIVATE_KEY, params) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+	OSSL_PARAM_free(params);
+
+	if (pkey == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	cctx = EVP_PKEY_CTX_new_from_pkey(NULL, pkey, NULL);
+	if (cctx == NULL) {
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_decapsulate_init(cctx, params) != 1) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_decapsulate(cctx, NULL, &keylen,
+		op->decap.cipher.data, op->decap.cipher.length) != 1) {
+		OPENSSL_LOG(ERR, "Failed to determine output length");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (keylen > op->decap.sk.length) {
+		OPENSSL_LOG(ERR, "Insufficient buffer for shared key");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_decapsulate(cctx, op->decap.sk.data, &keylen,
+			op->decap.cipher.data, op->decap.cipher.length) != 1) {
+		OPENSSL_LOG(ERR, "Failed to decapsulate");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	op->decap.sk.length = keylen;
+
+	EVP_PKEY_CTX_free(cctx);
+	EVP_PKEY_free(pkey);
+	ret = 0;
+	cop->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
+	return ret;
+}
+
+static int
+process_openssl_mlkem_op_evp(struct rte_crypto_op *cop,
+		struct openssl_asym_session *sess)
+{
+	struct rte_crypto_ml_kem_op *op = &cop->asym->mlkem;
+	int ret = -1;
+
+	switch (op->op) {
+	case RTE_CRYPTO_ML_KEM_OP_KEYGEN:
+		ret = mlkem_keygen_op_evp(cop, sess);
+		break;
+	case RTE_CRYPTO_ML_KEM_OP_KEYVER:
+		cop->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
+		break;
+	case RTE_CRYPTO_ML_KEM_OP_ENCAP:
+		ret = mlkem_encap_op_evp(cop, sess);
+		break;
+	case RTE_CRYPTO_ML_KEM_OP_DECAP:
+		ret = mlkem_decap_op_evp(cop, sess);
+		break;
+	default:
+		cop->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
+		break;
+	}
+
+	return ret;
+}
+
+static int
+mldsa_keygen_op_evp(struct rte_crypto_op *cop,
+		struct openssl_asym_session *sess)
+{
+	struct rte_crypto_ml_dsa_op *op = &cop->asym->mldsa;
+	EVP_PKEY_CTX *pctx = sess->u.ml_dsa.pctx;
+	OSSL_PARAM_BLD *param_bld;
+	EVP_PKEY *pkey = NULL;
+	OSSL_PARAM *params;
+	const char *param;
+	size_t keylen = 0;
+	void *key = NULL;
+	OSSL_PARAM *p;
+
+	param = ml_dsa_paramset_names[sess->u.ml_dsa.param];
+	if (param == NULL) {
+		OPENSSL_LOG(ERR, "invalid ml_dsa param set");
+		return -EINVAL;
+	}
+
+	param_bld = OSSL_PARAM_BLD_new();
+	if (param_bld == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (!OSSL_PARAM_BLD_push_utf8_string(param_bld,
+			OSSL_PKEY_PARAM_GROUP_NAME,
+			param, strlen(param)) ||
+		!OSSL_PARAM_BLD_push_octet_string(param_bld,
+			OSSL_PKEY_PARAM_ML_DSA_SEED,
+			op->keygen.seed.data, op->keygen.seed.length)) {
+		OSSL_PARAM_BLD_free(param_bld);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	params = OSSL_PARAM_BLD_to_param(param_bld);
+	OSSL_PARAM_BLD_free(param_bld);
+	if (params == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+	if (EVP_PKEY_fromdata_init(pctx) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+	if (EVP_PKEY_fromdata(pctx, &pkey, EVP_PKEY_KEYPAIR, params) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+	OSSL_PARAM_free(params);
+
+	if (pkey == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	/* extract public and private keys */
+	if (EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, &params) != 1) {
+		OPENSSL_LOG(ERR, "Failed to convert to key pairs");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PRIV_KEY);
+	if (p == NULL) {
+		OPENSSL_LOG(ERR, "Failed to locate private key");
+		OSSL_PARAM_free(params);
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	OSSL_PARAM_get_octet_string(p, &key,
+		rte_crypto_ml_dsa_privkey_size[sess->u.ml_dsa.param], &keylen);
+	memcpy(op->keygen.privkey.data, key, keylen);
+	op->keygen.privkey.length = keylen;
+
+	p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PUB_KEY);
+	if (p == NULL) {
+		OPENSSL_LOG(ERR, "Failed to locate public key");
+		OSSL_PARAM_free(params);
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	OSSL_PARAM_get_octet_string(p, &key,
+		rte_crypto_ml_dsa_pubkey_size[sess->u.ml_dsa.param], &keylen);
+	memcpy(op->keygen.pubkey.data, key, keylen);
+	op->keygen.pubkey.length = keylen;
+
+	OSSL_PARAM_free(params);
+	EVP_PKEY_free(pkey);
+	cop->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
+	return 0;
+}
+
+static int
+mldsa_sign_op_evp(struct rte_crypto_op *cop,
+		struct openssl_asym_session *sess)
+{
+	struct rte_crypto_ml_dsa_op *op = &cop->asym->mldsa;
+	EVP_PKEY_CTX *pctx = sess->u.ml_dsa.pctx;
+	const EVP_MD *check_md = NULL;
+	OSSL_PARAM_BLD *param_bld;
+	EVP_PKEY_CTX *cctx = NULL;
+	EVP_PKEY *pkey = NULL;
+	EVP_SIGNATURE *sigalg;
+	OSSL_PARAM *params;
+	const char *param;
+	unsigned char *md;
+	size_t siglen = 0;
+	size_t mdlen = 0;
+	int ret = -1;
+
+	param = ml_dsa_paramset_names[sess->u.ml_dsa.param];
+	if (param == NULL) {
+		OPENSSL_LOG(ERR, "invalid ml_dsa param set");
+		return -EINVAL;
+	}
+
+	param_bld = OSSL_PARAM_BLD_new();
+	if (param_bld == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (!OSSL_PARAM_BLD_push_utf8_string(param_bld,
+			OSSL_PKEY_PARAM_GROUP_NAME,
+			param, strlen(param)) ||
+		(op->siggen.seed.length &&
+			!OSSL_PARAM_BLD_push_octet_string(param_bld,
+			OSSL_PKEY_PARAM_ML_DSA_SEED,
+			op->siggen.seed.data, op->siggen.seed.length)) ||
+		!OSSL_PARAM_BLD_push_octet_string(param_bld,
+			OSSL_PKEY_PARAM_PRIV_KEY,
+			op->siggen.privkey.data, op->siggen.privkey.length)) {
+		OSSL_PARAM_BLD_free(param_bld);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	params = OSSL_PARAM_BLD_to_param(param_bld);
+	OSSL_PARAM_BLD_free(param_bld);
+	if (params == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_fromdata_init(pctx) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_fromdata(pctx, &pkey, EVP_PKEY_PRIVATE_KEY, params) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (pkey == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	cctx = EVP_PKEY_CTX_new_from_pkey(NULL, pkey, NULL);
+	if (cctx == NULL) {
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	sigalg = EVP_SIGNATURE_fetch(NULL, param, NULL);
+	if (sigalg == NULL) {
+		OPENSSL_LOG(ERR, "Failed to fetch signature algorithm");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_sign_message_init(cctx, sigalg, NULL) != 1) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (sess->u.ml_dsa.sign_deterministic) {
+		int deterministic = 1;
+		const OSSL_PARAM sign_params[] = {
+			OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_DETERMINISTIC, &deterministic),
+			OSSL_PARAM_END
+		};
+
+		if (EVP_PKEY_sign_message_init(cctx, sigalg, sign_params) != 1) {
+			EVP_SIGNATURE_free(sigalg);
+			cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+			return -1;
+		}
+	}
+
+	md = op->siggen.message.data;
+	mdlen = op->siggen.message.length;
+
+	if (op->siggen.mu.length) {
+		int has_mu = 1;
+		const OSSL_PARAM sign_params[] = {
+			OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MU, &has_mu),
+			OSSL_PARAM_END
+		};
+
+		if (EVP_PKEY_sign_message_init(cctx, sigalg, sign_params) != 1) {
+			EVP_SIGNATURE_free(sigalg);
+			cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+			return -1;
+		}
+
+		md = op->siggen.mu.data;
+		mdlen = op->siggen.mu.length;
+	} else if (op->siggen.ctx.length) {
+		int has_ctx = 1;
+		const OSSL_PARAM sign_params[] = {
+			OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING, &has_ctx),
+			OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_CONTEXT_STRING,
+				(void *)op->siggen.ctx.data, op->siggen.ctx.length),
+			OSSL_PARAM_END
+		};
+
+		if (EVP_PKEY_sign_message_init(cctx, sigalg, sign_params) != 1) {
+			EVP_SIGNATURE_free(sigalg);
+			cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+			return -1;
+		}
+	}
+
+	EVP_SIGNATURE_free(sigalg);
+
+	switch (op->siggen.hash) {
+	case RTE_CRYPTO_AUTH_SHA3_224:
+		check_md = EVP_sha3_224();
+		break;
+	case RTE_CRYPTO_AUTH_SHA3_256:
+		check_md = EVP_sha3_256();
+		break;
+	case RTE_CRYPTO_AUTH_SHA3_384:
+		check_md = EVP_sha3_384();
+		break;
+	case RTE_CRYPTO_AUTH_SHA3_512:
+		check_md = EVP_sha3_512();
+		break;
+	case RTE_CRYPTO_AUTH_SHAKE_128:
+		check_md = EVP_shake128();
+		break;
+	case RTE_CRYPTO_AUTH_SHAKE_256:
+		check_md = EVP_shake256();
+		break;
+	default:
+		break;
+	}
+
+	if (op->siggen.hash != 0 && check_md == NULL) {
+		OPENSSL_LOG(ERR, "invalid hash type");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (check_md != NULL) {
+		if (EVP_PKEY_CTX_set_signature_md(cctx, check_md) != 1) {
+			OPENSSL_LOG(ERR, "Failed to set signature md");
+			EVP_PKEY_free(pkey);
+			cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+			return -1;
+		}
+	}
+
+	if (EVP_PKEY_sign(cctx, NULL, &siglen, md, mdlen) != 1) {
+		OPENSSL_LOG(ERR, "Failed to determine output length");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (siglen > op->siggen.sign.length) {
+		OPENSSL_LOG(ERR, "Insufficient buffer for signature");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_sign(cctx, op->siggen.sign.data, &siglen, md, mdlen) != 1) {
+		OPENSSL_LOG(ERR, "Failed to sign");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	op->siggen.sign.length = siglen;
+
+	OSSL_PARAM_free(params);
+	EVP_PKEY_CTX_free(cctx);
+	EVP_PKEY_free(pkey);
+	ret = 0;
+	cop->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
+	return ret;
+}
+
+static int
+mldsa_verify_op_evp(struct rte_crypto_op *cop,
+		struct openssl_asym_session *sess)
+{
+	struct rte_crypto_ml_dsa_op *op = &cop->asym->mldsa;
+	EVP_PKEY_CTX *pctx = sess->u.ml_dsa.pctx;
+	OSSL_PARAM_BLD *param_bld;
+	EVP_PKEY_CTX *cctx = NULL;
+	EVP_PKEY *pkey = NULL;
+	EVP_SIGNATURE *sigalg;
+	OSSL_PARAM *params;
+	const char *param;
+	unsigned char *md;
+	size_t mdlen = 0;
+	int ret = -1;
+
+	param = ml_dsa_paramset_names[sess->u.ml_dsa.param];
+	if (param == NULL) {
+		OPENSSL_LOG(ERR, "invalid ml_dsa param set");
+		return -EINVAL;
+	}
+
+	param_bld = OSSL_PARAM_BLD_new();
+	if (param_bld == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (!OSSL_PARAM_BLD_push_utf8_string(param_bld,
+			OSSL_PKEY_PARAM_GROUP_NAME,
+			param, strlen(param)) ||
+		!OSSL_PARAM_BLD_push_octet_string(param_bld,
+			OSSL_PKEY_PARAM_PUB_KEY,
+			op->sigver.pubkey.data, op->sigver.pubkey.length)) {
+		OSSL_PARAM_BLD_free(param_bld);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	params = OSSL_PARAM_BLD_to_param(param_bld);
+	OSSL_PARAM_BLD_free(param_bld);
+	if (params == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_fromdata_init(pctx) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_fromdata(pctx, &pkey, EVP_PKEY_PUBLIC_KEY, params) != 1) {
+		OSSL_PARAM_free(params);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (pkey == NULL) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	cctx = EVP_PKEY_CTX_new_from_pkey(NULL, pkey, NULL);
+	if (cctx == NULL) {
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	sigalg = EVP_SIGNATURE_fetch(NULL, param, NULL);
+	if (sigalg == NULL) {
+		OPENSSL_LOG(ERR, "Failed to fetch signature algorithm");
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	if (EVP_PKEY_verify_message_init(cctx, sigalg, NULL) != 1) {
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return -1;
+	}
+
+	md = op->sigver.message.data;
+	mdlen = op->sigver.message.length;
+
+	if (op->sigver.mu.length) {
+		int has_mu = 1;
+		const OSSL_PARAM sign_params[] = {
+			OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MU, &has_mu),
+			OSSL_PARAM_END
+		};
+
+		if (EVP_PKEY_verify_message_init(cctx, sigalg, sign_params) != 1) {
+			EVP_SIGNATURE_free(sigalg);
+			cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+			return -1;
+		}
+
+		md = op->sigver.mu.data;
+		mdlen = op->sigver.mu.length;
+	} else if (op->sigver.ctx.length) {
+		const OSSL_PARAM sign_params[] = {
+			OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_CONTEXT_STRING,
+				(void *)op->sigver.ctx.data, op->sigver.ctx.length),
+			OSSL_PARAM_END
+		};
+
+		if (EVP_PKEY_verify_message_init(cctx, sigalg, sign_params) != 1) {
+			EVP_SIGNATURE_free(sigalg);
+			cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+			return -1;
+		}
+	}
+
+	if (EVP_PKEY_verify(cctx, op->sigver.sign.data, op->sigver.sign.length,
+		md, mdlen) != 1) {
+		EVP_PKEY_free(pkey);
+		cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return 0;
+	}
+
+	OSSL_PARAM_free(params);
+	EVP_PKEY_CTX_free(cctx);
+	EVP_PKEY_free(pkey);
+	ret = 0;
+	cop->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
+	return ret;
+}
+
+static int
+process_openssl_mldsa_op_evp(struct rte_crypto_op *cop,
+		struct openssl_asym_session *sess)
+{
+	struct rte_crypto_ml_dsa_op *op = &cop->asym->mldsa;
+	int ret = -1;
+
+	switch (op->op) {
+	case RTE_CRYPTO_ML_DSA_OP_KEYGEN:
+		ret = mldsa_keygen_op_evp(cop, sess);
+		break;
+	case RTE_CRYPTO_ML_DSA_OP_SIGN:
+		ret = mldsa_sign_op_evp(cop, sess);
+		break;
+	case RTE_CRYPTO_ML_DSA_OP_VERIFY:
+		ret = mldsa_verify_op_evp(cop, sess);
+		break;
+	default:
+		cop->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
+		break;
+	}
+
+	return ret;
+}
+#else
+static int
+process_openssl_mlkem_op(struct rte_crypto_op *cop,
+		struct openssl_asym_session *sess)
+{
+	RTE_SET_USED(cop);
+	RTE_SET_USED(sess);
+	return -ENOTSUP;
+}
+
+static int
+process_openssl_mldsa_op(struct rte_crypto_op *cop,
+		struct openssl_asym_session *sess)
+{
+	RTE_SET_USED(cop);
+	RTE_SET_USED(sess);
+	return -ENOTSUP;
+}
+#endif
+
 static int
 process_asym_op(struct openssl_qp *qp, struct rte_crypto_op *op,
 		struct openssl_asym_session *sess)
@@ -3450,6 +4306,20 @@ process_asym_op(struct openssl_qp *qp, struct rte_crypto_op *op,
 		retval = process_openssl_eddsa_op_evp(op, sess);
 #else
 		retval = process_openssl_eddsa_op(op, sess);
+#endif
+		break;
+	case RTE_CRYPTO_ASYM_XFORM_ML_KEM:
+#if (OPENSSL_VERSION_NUMBER >= 0x30500000L)
+		retval = process_openssl_mlkem_op_evp(op, sess);
+#else
+		retval = process_openssl_mlkem_op(op, sess);
+#endif
+		break;
+	case RTE_CRYPTO_ASYM_XFORM_ML_DSA:
+#if (OPENSSL_VERSION_NUMBER >= 0x30500000L)
+		retval = process_openssl_mldsa_op_evp(op, sess);
+#else
+		retval = process_openssl_mldsa_op(op, sess);
 #endif
 		break;
 	default:
diff --git a/drivers/crypto/openssl/rte_openssl_pmd_ops.c b/drivers/crypto/openssl/rte_openssl_pmd_ops.c
index d3aa396c76..432c8ee8fb 100644
--- a/drivers/crypto/openssl/rte_openssl_pmd_ops.c
+++ b/drivers/crypto/openssl/rte_openssl_pmd_ops.c
@@ -639,10 +639,81 @@ static const struct rte_cryptodev_capabilities openssl_pmd_capabilities[] = {
 		}
 		}
 	},
+#if (OPENSSL_VERSION_NUMBER >= 0x30500000L)
+	{
+		/* ML-KEM */
+		.op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
+		.asym = {
+			.xform_capa = {
+				.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM,
+				.op_types =
+				((1 << RTE_CRYPTO_ML_KEM_OP_KEYGEN) |
+				 (1 << RTE_CRYPTO_ML_KEM_OP_ENCAP) |
+				 (1 << RTE_CRYPTO_ML_KEM_OP_DECAP)),
+				.mlkem_capa = {
+					[RTE_CRYPTO_ML_KEM_OP_KEYGEN] =
+						(1 << RTE_CRYPTO_ML_KEM_PARAM_512) |
+						(1 << RTE_CRYPTO_ML_KEM_PARAM_768) |
+						(1 << RTE_CRYPTO_ML_KEM_PARAM_1024),
+					[RTE_CRYPTO_ML_KEM_OP_ENCAP] =
+						(1 << RTE_CRYPTO_ML_KEM_PARAM_512) |
+						(1 << RTE_CRYPTO_ML_KEM_PARAM_768) |
+						(1 << RTE_CRYPTO_ML_KEM_PARAM_1024),
+					[RTE_CRYPTO_ML_KEM_OP_DECAP] =
+						(1 << RTE_CRYPTO_ML_KEM_PARAM_512) |
+						(1 << RTE_CRYPTO_ML_KEM_PARAM_768) |
+						(1 << RTE_CRYPTO_ML_KEM_PARAM_1024)
+				}
+			}
+		}
+	},
+	{
+		/* ML-DSA */
+		.op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
+		.asym = {
+			.xform_capa = {
+				.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA,
+				.op_types =
+				((1 << RTE_CRYPTO_ML_DSA_OP_SIGN) |
+#if (OPENSSL_VERSION_NUMBER >= 0x30500010)
+				 (1 << RTE_CRYPTO_ML_DSA_OP_KEYGEN) |
+#endif
+				 (1 << RTE_CRYPTO_ML_DSA_OP_VERIFY)),
+				.mldsa_capa = {
+					[RTE_CRYPTO_ML_DSA_OP_KEYGEN] =
+						(1 << RTE_CRYPTO_ML_DSA_PARAM_44) |
+						(1 << RTE_CRYPTO_ML_DSA_PARAM_65) |
+						(1 << RTE_CRYPTO_ML_DSA_PARAM_87),
+					[RTE_CRYPTO_ML_DSA_OP_SIGN] =
+						(1 << RTE_CRYPTO_ML_DSA_PARAM_44) |
+						(1 << RTE_CRYPTO_ML_DSA_PARAM_65) |
+						(1 << RTE_CRYPTO_ML_DSA_PARAM_87),
+					[RTE_CRYPTO_ML_DSA_OP_VERIFY] =
+						(1 << RTE_CRYPTO_ML_DSA_PARAM_44) |
+						(1 << RTE_CRYPTO_ML_DSA_PARAM_65) |
+						(1 << RTE_CRYPTO_ML_DSA_PARAM_87)
+				}
+			}
+		}
+	},
+#endif
 
 	RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
 };
 
+const char *ml_kem_paramset_names[] = {
+	NULL,
+	"ML-KEM-512",
+	"ML-KEM-768",
+	"ML-KEM-1024",
+};
+
+const char *ml_dsa_paramset_names[] = {
+	NULL,
+	"ML-DSA-44",
+	"ML-DSA-65",
+	"ML-DSA-87",
+};
 
 /** Configure device */
 static int
@@ -1573,6 +1644,58 @@ static int openssl_set_asym_session_parameters(
 #else
 		OPENSSL_LOG(WARNING, "EdDSA unsupported for OpenSSL Version < 3.3");
 		return -ENOTSUP;
+#endif
+	}
+	case RTE_CRYPTO_ASYM_XFORM_ML_KEM:
+	{
+#if (OPENSSL_VERSION_NUMBER >= 0x30500000L)
+		const char *param;
+
+		param = ml_kem_paramset_names[xform->mlkem.param];
+		if (param == NULL) {
+			OPENSSL_LOG(ERR, "invalid ml_kem param set");
+			return -EINVAL;
+		}
+
+		asym_session->u.ml_kem.pctx = EVP_PKEY_CTX_new_from_name(NULL, param, NULL);
+		if (!asym_session->u.ml_kem.pctx) {
+			OPENSSL_LOG(ERR, "failed to allocate resources");
+			return -1;
+		}
+
+		asym_session->u.ml_kem.param = xform->mlkem.param;
+		asym_session->xfrm_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+		break;
+#else
+		OPENSSL_LOG(WARNING, "ML-KEM unsupported for OpenSSL Version < 3.5");
+		return -ENOTSUP;
+#endif
+	}
+	case RTE_CRYPTO_ASYM_XFORM_ML_DSA:
+	{
+#if (OPENSSL_VERSION_NUMBER >= 0x30500000L)
+		const char *param;
+
+		param = ml_dsa_paramset_names[xform->mldsa.param];
+		if (param == NULL) {
+			OPENSSL_LOG(ERR, "invalid ml_dsa param set");
+			return -EINVAL;
+		}
+
+		asym_session->u.ml_dsa.pctx = EVP_PKEY_CTX_new_from_name(NULL, param, NULL);
+		if (!asym_session->u.ml_dsa.pctx) {
+			OPENSSL_LOG(ERR, "failed to allocate resources");
+			return -1;
+		}
+
+		asym_session->u.ml_dsa.param = xform->mldsa.param;
+		asym_session->u.ml_dsa.sign_prehash = xform->mldsa.sign_prehash;
+		asym_session->u.ml_dsa.sign_deterministic = xform->mldsa.sign_deterministic;
+		asym_session->xfrm_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+		break;
+#else
+		OPENSSL_LOG(WARNING, "ML-DSA unsupported for OpenSSL Version < 3.5");
+		return -ENOTSUP;
 #endif
 	}
 	default:
@@ -1675,6 +1798,16 @@ static void openssl_reset_asym_session(struct openssl_asym_session *sess)
 	case RTE_CRYPTO_ASYM_XFORM_EDDSA:
 #if (OPENSSL_VERSION_NUMBER >= 0x30300000L)
 		OSSL_PARAM_free(sess->u.eddsa.params);
+#endif
+		break;
+	case RTE_CRYPTO_ASYM_XFORM_ML_KEM:
+#if (OPENSSL_VERSION_NUMBER >= 0x30500000L)
+		EVP_PKEY_CTX_free(sess->u.ml_kem.pctx);
+#endif
+		break;
+	case RTE_CRYPTO_ASYM_XFORM_ML_DSA:
+#if (OPENSSL_VERSION_NUMBER >= 0x30500000L)
+		EVP_PKEY_CTX_free(sess->u.ml_dsa.pctx);
 #endif
 		break;
 	default:
-- 
2.37.1