Skip to contentSkip to conversation

cryptodev: support PQC ML algorithms

RFC New Gowrishankar Muthukrishnan 2 participants 20 messages Aug 28, 2025 – Oct 7, 2025 Crypto API

lore
Share & tools
lore
#0 lore raw

RFC 1/1 cryptodev: support PQC ML algorithms

Add support for PQC ML-KEM and ML-DSA algorithms.

---
 lib/cryptodev/rte_crypto_asym.h | 262 ++++++++++++++++++++++++++++++++
 lib/cryptodev/rte_cryptodev.c   |  39 +++++
 2 files changed, 301 insertions(+)
lib/cryptodev/rte_crypto_asym.h +262 -0
index 9787b710e7..102dd4dc09 100644
@@ -37,6 +37,14 @@ rte_crypto_asym_ke_strings[];
 extern const char *
 rte_crypto_asym_op_strings[];
 
+/** PQC ML crypto op parameters size */
+extern const uint16_t
+rte_crypto_ml_pubkey_size[];
+extern const uint16_t
+rte_crypto_ml_privkey_size[];
+extern const uint16_t
+rte_crypto_ml_output_size[];
+
 #ifdef __cplusplus
 }
 #endif
@@ -720,6 +728,252 @@ struct rte_crypto_sm2_op_param {
 	 */
 };
 
+/**
+ * PQC ML algorithms
+ *
+ * List of ML algorithms used in PQC
+ */
+enum rte_crypto_ml_param_set {
+	RTE_CRYPTO_ML_PARAM_NONE,
+	RTE_CRYPTO_ML_KEM_PARAM_512,
+	RTE_CRYPTO_ML_KEM_PARAM_768,
+	RTE_CRYPTO_ML_KEM_PARAM_1024,
+	RTE_CRYPTO_ML_DSA_PARAM_44,
+	RTE_CRYPTO_ML_DSA_PARAM_65,
+	RTE_CRYPTO_ML_DSA_PARAM_87,
+};
+
+/**
+ * PQC ML op types
+ *
+ * List of ML op types in PQC
+ */
+enum rte_crypto_ml_op {
+	RTE_CRYPTO_ML_OP_NONE,
+	RTE_CRYPTO_ML_KEM_OP_KEYGEN,
+	RTE_CRYPTO_ML_KEM_OP_KEYVER,
+	RTE_CRYPTO_ML_KEM_OP_ENCAP,
+	RTE_CRYPTO_ML_KEM_OP_DECAP,
+	RTE_CRYPTO_ML_DSA_OP_KEYGEN,
+	RTE_CRYPTO_ML_DSA_OP_SIGN,
+	RTE_CRYPTO_ML_DSA_OP_VERIFY,
+};
+
+/**
+ * PQC ML-KEM transform data
+ *
+ * Structure describing ML-KEM xform params
+ */
+struct rte_crypto_ml_kem_xform {
+	enum rte_crypto_ml_param_set param;
+};
+
+/**
+ * PQC ML-KEM KEYGEN op
+ *
+ * Parameters for PQC ML-KEM key generation operation
+ */
+struct rte_crypto_ml_kem_keygen_op {
+	rte_crypto_param d;
+	/**< The seed d value (of 32 bytes in length) to generate key pair.*/
+
+	rte_crypto_param z;
+	/**< The seed z value (of 32 bytes in length) to generate key pair.*/
+
+	rte_crypto_param ek;
+	/**<
+	 * Pointer to output data
+	 * - The computed encapsulation key.
+	 * - Refer `rte_crypto_ml_pubkey_size` for size of buffer.
+	 */
+
+	rte_crypto_param dk;
+	/**<
+	 * Pointer to output data
+	 * - The computed decapsulation key.
+	 * - Refer `rte_crypto_ml_privkey_size` for size of buffer.
+	 */
+};
+
+/**
+ * PQC ML-KEM KEYVER op
+ *
+ * Parameters for PQC ML-KEM key verification operation
+ */
+struct rte_crypto_ml_kem_keyver_op {
+	enum rte_crypto_ml_op op;
+	/**<
+	 * Op associated with key to be verified is one of below:
+	 * - Encapsulation op
+	 * - Decapsulation op
+	 */
+
+	rte_crypto_param key;
+	/**<
+	 * KEM key to check.
+	 * - ek in case of encapsulation op.
+	 * - dk in case of decapsulation op.
+	 */
+};
+
+/**
+ * PQC ML-KEM ENCAP op
+ *
+ * Parameters for PQC ML-KEM encapsulation operation
+ */
+struct rte_crypto_ml_kem_encap_op {
+	rte_crypto_param message;
+	/**< The message to be encapsulated.*/
+
+	rte_crypto_param ek;
+	/**< The encapsulation key.*/
+
+	rte_crypto_param cipher;
+	/**<
+	 * Pointer to output data
+	 * - The computed cipher.
+	 * - Refer `rte_crypto_ml_output_size` for size of buffer.
+	 */
+
+	rte_crypto_param sk;
+	/**<
+	 * Pointer to output data
+	 * - The computed shared secret key.
+	 * - Refer `rte_crypto_ml_pubkey_size` for size of buffer.
+	 */
+};
+
+/**
+ * PQC ML-KEM DECAP op
+ *
+ * Parameters for PQC ML-KEM decapsulation operation
+ */
+struct rte_crypto_ml_kem_decap_op {
+	rte_crypto_param cipher;
+	/**< The cipher to be decapsulated.*/
+
+	rte_crypto_param dk;
+	/**< The decapsulation key.*/
+
+	rte_crypto_param sk;
+	/**<
+	 * Pointer to output data
+	 * - The computed shared secret key.
+	 * - Refer `rte_crypto_ml_pubkey_size` for size of buffer.
+	 */
+};
+
+/**
+ * PQC ML-KEM op
+ *
+ * Parameters for PQC ML-KEM operation
+ */
+struct rte_crypto_ml_kem_op {
+	enum rte_crypto_ml_op op;
+	union {
+		struct rte_crypto_ml_kem_keygen_op keygen;
+		struct rte_crypto_ml_kem_keyver_op keyver;
+		struct rte_crypto_ml_kem_encap_op encap;
+		struct rte_crypto_ml_kem_decap_op decap;
+	};
+};
+
+/**
+ * PQC ML-DSA transform data
+ *
+ * Structure describing ML-DSA xform params
+ */
+struct rte_crypto_ml_dsa_xform {
+	enum rte_crypto_ml_param_set param;
+
+	bool random_seed;
+	/**< The signature generated using random seed (of 32 bytes in length). */
+
+	bool sign_prehash;
+	/**< The signature genearated using prehash or pure routine. */
+};
+
+/**
+ * PQC ML-DSA KEYGEN op
+ *
+ * Parameters for PQC ML-DSA key generation operation
+ */
+struct rte_crypto_ml_dsa_keygen_op {
+	rte_crypto_param seed;
+	/**< The random seed (of 32 bytes in length) to generate key pair.*/
+};
+
+/**
+ * PQC ML-DSA SIGGEN op
+ *
+ * Parameters for PQC ML-DSA sign operation
+ */
+struct rte_crypto_ml_dsa_siggen_op {
+	rte_crypto_param message;
+	/**< The message to generate signature.*/
+
+	rte_crypto_param mu;
+	/**< The mu to generate signature.*/
+
+	rte_crypto_param sk;
+	/**< The secret key to generate signature.*/
+
+	rte_crypto_param seed;
+	/**< The seed to generate signature.*/
+
+	rte_crypto_param ctx;
+	/**< The context key to generate signature.*/
+
+	enum rte_crypto_auth_algorithm hash;
+	/**< Hash function to generate signature. */
+
+	rte_crypto_param sign;
+	/**<
+	 * Pointer to output data
+	 * - The computed signature.
+	 * - Refer `rte_crypto_ml_output_size` for size of buffer.
+	 */
+};
+
+/**
+ * PQC ML-DSA SIGVER op
+ *
+ * Parameters for PQC ML-DSA verify operation
+ */
+struct rte_crypto_ml_dsa_sigver_op {
+	rte_crypto_param pubkey;
+	/**< The public key to verify signature.*/
+
+	rte_crypto_param message;
+	/**< The message used to verify signature.*/
+
+	rte_crypto_param sign;
+	/**< The signature to verify.*/
+
+	rte_crypto_param mu;
+	/**< The mu used to generate signature.*/
+
+	rte_crypto_param ctx;
+	/**< The context key to generate signature.*/
+
+	enum rte_crypto_auth_algorithm hash;
+	/**< Hash function to generate signature. */
+};
+
+/**
+ * PQC ML-DSA op
+ *
+ * Parameters for PQC ML-DSA operation
+ */
+struct rte_crypto_ml_dsa_op {
+	enum rte_crypto_ml_op op;
+	union {
+		struct rte_crypto_ml_dsa_keygen_op keygen;
+		struct rte_crypto_ml_dsa_siggen_op siggen;
+		struct rte_crypto_ml_dsa_sigver_op sigver;
+	};
+};
+
 /**
  * Asymmetric crypto transform data
  *
@@ -751,6 +1005,12 @@ struct rte_crypto_asym_xform {
 		/**< EC xform parameters, used by elliptic curve based
 		 * operations.
 		 */
+
+		struct rte_crypto_ml_kem_xform mlkem;
+		/**< PQC ML-KEM xform parameters */
+
+		struct rte_crypto_ml_dsa_xform mldsa;
+		/**< PQC ML-DSA xform parameters */
 	};
 };
 
@@ -778,6 +1038,8 @@ struct rte_crypto_asym_op {
 		struct rte_crypto_ecpm_op_param ecpm;
 		struct rte_crypto_sm2_op_param sm2;
 		struct rte_crypto_eddsa_op_param eddsa;
+		struct rte_crypto_ml_kem_op mlkem;
+		struct rte_crypto_ml_dsa_op mldsa;
 	};
 	uint16_t flags;
 	/**<
lib/cryptodev/rte_cryptodev.c +39 -0
index bb7bab4dd5..aeb6e1640d 100644
@@ -229,6 +229,45 @@ const char *rte_crypto_asym_ke_strings[] = {
 	[RTE_CRYPTO_ASYM_KE_PUB_KEY_VERIFY] = "pub_ec_key_verify"
 };
 
+/**
+ * Public key size used in PQC ML based crypto ops.
+ */
+RTE_EXPORT_SYMBOL(rte_crypto_ml_pubkey_size)
+const uint16_t rte_crypto_ml_pubkey_size[] = {
+	[RTE_CRYPTO_ML_KEM_PARAM_512] = 800,
+	[RTE_CRYPTO_ML_KEM_PARAM_768] = 1184,
+	[RTE_CRYPTO_ML_KEM_PARAM_1024] = 1568,
+	[RTE_CRYPTO_ML_DSA_PARAM_44] = 1312,
+	[RTE_CRYPTO_ML_DSA_PARAM_65] = 1952,
+	[RTE_CRYPTO_ML_DSA_PARAM_87] = 2592,
+};
+
+/**
+ * Private key size used in PQC ML based crypto ops.
+ */
+RTE_EXPORT_SYMBOL(rte_crypto_ml_privkey_size)
+const uint16_t rte_crypto_ml_privkey_size[] = {
+	[RTE_CRYPTO_ML_KEM_PARAM_512] = 1632,
+	[RTE_CRYPTO_ML_KEM_PARAM_768] = 2400,
+	[RTE_CRYPTO_ML_KEM_PARAM_1024] = 3168,
+	[RTE_CRYPTO_ML_DSA_PARAM_44] = 2560,
+	[RTE_CRYPTO_ML_DSA_PARAM_65] = 4032,
+	[RTE_CRYPTO_ML_DSA_PARAM_87] = 4896,
+};
+
+/**
+ * Output buffer size used in PQC ML based crypto ops.
+ */
+RTE_EXPORT_SYMBOL(rte_crypto_ml_output_size)
+const uint16_t rte_crypto_ml_output_size[] = {
+	[RTE_CRYPTO_ML_KEM_PARAM_512] = 768,
+	[RTE_CRYPTO_ML_KEM_PARAM_768] = 1088,
+	[RTE_CRYPTO_ML_KEM_PARAM_1024] = 1568,
+	[RTE_CRYPTO_ML_DSA_PARAM_44] = 2420,
+	[RTE_CRYPTO_ML_DSA_PARAM_65] = 3309,
+	[RTE_CRYPTO_ML_DSA_PARAM_87] = 4627,
+};
+
 struct rte_cryptodev_sym_session_pool_private_data {
 	uint16_t sess_data_sz;
 	/**< driver session data size */
Signature · 1 line
2.37.1
#1 lore raw

cover cryptodev: support PQC ML algorithms

This series added support for PQC ML-KEM and ML-DSA algorithms.

Gowrishankar Muthukrishnan (3):
cryptodev: support PQC ML algorithms
crypto/openssl: add ML crypto support
app/test: add ML crypto test vectors

 app/test/test_cryptodev_asym.c                |  856 ++++++++
 app/test/test_cryptodev_ml_dsa_test_vectors.h | 1856 +++++++++++++++++
 app/test/test_cryptodev_ml_kem_test_vectors.h |  873 ++++++++
 doc/guides/cryptodevs/features/default.ini    |    2 +
 doc/guides/cryptodevs/features/openssl.ini    |    2 +
 doc/guides/prog_guide/cryptodev_lib.rst       |    3 +-
 doc/guides/rel_notes/release_25_11.rst        |   11 +
 drivers/crypto/openssl/openssl_pmd_private.h  |   16 +
 drivers/crypto/openssl/rte_openssl_pmd.c      |  868 ++++++++
 drivers/crypto/openssl/rte_openssl_pmd_ops.c  |  129 ++
 lib/cryptodev/rte_crypto_asym.h               |  306 +++
 lib/cryptodev/rte_cryptodev.c                 |   60 +
 lib/cryptodev/rte_cryptodev.h                 |   15 +-
 13 files changed, 4994 insertions(+), 3 deletions(-)
 create mode 100644 app/test/test_cryptodev_ml_dsa_test_vectors.h
 create mode 100644 app/test/test_cryptodev_ml_kem_test_vectors.h
Signature · 1 line
2.37.1
#2 lore raw

PATCH 1/3 cryptodev: support PQC ML algorithms

Add support for PQC ML-KEM and ML-DSA algorithms.

---
 doc/guides/cryptodevs/features/default.ini |   2 +
 doc/guides/prog_guide/cryptodev_lib.rst    |   3 +-
 doc/guides/rel_notes/release_25_11.rst     |  11 +
 lib/cryptodev/rte_crypto_asym.h            | 306 +++++++++++++++++++++
 lib/cryptodev/rte_cryptodev.c              |  60 ++++
 lib/cryptodev/rte_cryptodev.h              |  15 +-
 6 files changed, 394 insertions(+), 3 deletions(-)
doc/guides/cryptodevs/features/default.ini +2 -0
index 116ffce249..64198f013a 100644
@@ -134,6 +134,8 @@ ECPM                    =
 ECDH                    =
 SM2                     =
 EdDSA                   =
+ML-DSA                  =
+ML-KEM                  =
 
 ;
 ; Supported Operating systems of a default crypto driver.
doc/guides/prog_guide/cryptodev_lib.rst +2 -1
index b54efcb74e..f0ee44eb54 100644
@@ -928,7 +928,8 @@ Asymmetric Cryptography
 The cryptodev library currently provides support for the following asymmetric
 Crypto operations; RSA, Modular exponentiation and inversion, Diffie-Hellman and
 Elliptic Curve Diffie-Hellman public and/or private key generation and shared
-secret compute, DSA and EdDSA signature generation and verification.
+secret compute, DSA and EdDSA signature generation and verification,
+PQC ML-KEM and ML-DSA algorithms.
 
 Session and Session Management
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
doc/guides/rel_notes/release_25_11.rst +11 -0
index c3b94e1896..9d47f762d7 100644
@@ -76,6 +76,14 @@ New Features
   * Added multi-process per port.
   * Optimized code.
 
+* **Added PQC ML-KEM and ML-DSA support.**
+
+  * Added PQC ML-KEM support with reference to FIPS203.
+  * Added PQC ML-DSA support with reference to FIPS204.
+
+* **Updated openssl crypto driver.**
+
+  * Added support for PQC ML-KEM and ML-DSA algorithms.
 
 Removed Items
 -------------
@@ -138,6 +146,9 @@ ABI Changes
 * stack: The structure ``rte_stack_lf_head`` alignment has been updated to 16 bytes
   to avoid unaligned accesses.
 
+* cryptodev: The enum ``rte_crypto_asym_xform_type``, struct ``rte_crypto_asym_xform``
+  and struct ``rte_crypto_asym_op`` are updated to include new values to support
+  ML-KEM and ML-DSA.
 
 Known Issues
 ------------
lib/cryptodev/rte_crypto_asym.h +306 -0

336 lines not on this page · raw message

lib/cryptodev/rte_cryptodev.c +60 -0

66 lines not on this page · raw message

lib/cryptodev/rte_cryptodev.h +13 -2
index eaf0e50d37..37a6a5e49b 100644
@@ -167,10 +167,13 @@ struct rte_cryptodev_asymmetric_xform_capability {
 	uint32_t op_types;
 	/**<
 	 * Bitmask for supported rte_crypto_asym_op_type or
+	 * rte_crypto_ml_kem_op_type or rte_crypto_ml_dsa_op_type or
 	 * rte_crypto_asym_ke_type. Which enum is used is determined
 	 * by the rte_crypto_asym_xform_type. For key exchange algorithms
-	 * like Diffie-Hellman it is rte_crypto_asym_ke_type, for others
-	 * it is rte_crypto_asym_op_type.
+	 * like Diffie-Hellman it is rte_crypto_asym_ke_type,
+	 * for ML-KEM algorithms it is rte_crypto_ml_kem_op_type,
+	 * for ML-DSA algorithms it is rte_crypto_ml_dsa_op_type,
+	 * or others it is rte_crypto_asym_op_type.
 	 */
 
 	__extension__
@@ -188,6 +191,12 @@ struct rte_cryptodev_asymmetric_xform_capability {
 
 		uint32_t op_capa[RTE_CRYPTO_ASYM_OP_LIST_END];
 		/**< Operation specific capabilities. */
+
+		uint32_t mlkem_capa[RTE_CRYPTO_ML_KEM_OP_END];
+		/**< Bitmask of supported ML-KEM parameter sets. */
+
+		uint32_t mldsa_capa[RTE_CRYPTO_ML_DSA_OP_END];
+		/**< Bitmask of supported ML-DSA parameter sets. */
 	};
 
 	uint64_t hash_algos;
@@ -577,6 +586,8 @@ rte_cryptodev_asym_get_xform_string(enum rte_crypto_asym_xform_type xform_enum);
 /**< Support inner checksum computation/verification */
 #define RTE_CRYPTODEV_FF_SECURITY_RX_INJECT		(1ULL << 28)
 /**< Support Rx injection after security processing */
+#define RTE_CRYPTODEV_FF_MLDSA_SIGN_PREHASH		(1ULL << 29)
+/**< Support Pre Hash ML-DSA Signature Generation */
 
 /**
  * Get the name of a crypto device feature flag
Signature · 1 line
2.37.1
#3 lore raw

PATCH 2/3 crypto/openssl: add ML crypto support

In reply to Gowrishankar Muthukrishnan

Add ML-KEM and ML-DSA support.

---
 doc/guides/cryptodevs/features/openssl.ini   |   2 +
 drivers/crypto/openssl/openssl_pmd_private.h |  16 +
 drivers/crypto/openssl/rte_openssl_pmd.c     | 868 +++++++++++++++++++
 drivers/crypto/openssl/rte_openssl_pmd_ops.c | 129 +++
 4 files changed, 1015 insertions(+)
doc/guides/cryptodevs/features/openssl.ini +2 -0
index f0074a46f8..df6e7de316 100644
@@ -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.
drivers/crypto/openssl/openssl_pmd_private.h +16 -0
index 4a6a088870..7f87840b84 100644
@@ -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_ */
drivers/crypto/openssl/rte_openssl_pmd.c +868 -0

886 lines not on this page · raw message

drivers/crypto/openssl/rte_openssl_pmd_ops.c +129 -0

151 lines not on this page · raw message

Signature · 1 line
2.37.1
#4 lore raw

PATCH 3/3 app/test: add ML crypto test vectors

In reply to Gowrishankar Muthukrishnan

Add ML-KEM and ML-DSA test vectors.

---
 app/test/test_cryptodev_asym.c                |  856 ++++++++
 app/test/test_cryptodev_ml_dsa_test_vectors.h | 1856 +++++++++++++++++
 app/test/test_cryptodev_ml_kem_test_vectors.h |  873 ++++++++
 3 files changed, 3585 insertions(+)
 create mode 100644 app/test/test_cryptodev_ml_dsa_test_vectors.h
 create mode 100644 app/test/test_cryptodev_ml_kem_test_vectors.h
app/test/test_cryptodev_asym.c +856 -0
index 20afb5e98b..942a23e3b3 100644
@@ -24,6 +24,8 @@
 #include "test_cryptodev_mod_test_vectors.h"
 #include "test_cryptodev_rsa_test_vectors.h"
 #include "test_cryptodev_sm2_test_vectors.h"
+#include "test_cryptodev_ml_kem_test_vectors.h"
+#include "test_cryptodev_ml_dsa_test_vectors.h"
 #include "test_cryptodev_asym_util.h"
 #include "test.h"
 
@@ -3629,6 +3631,33 @@ static int send_one(void)
 	return TEST_SUCCESS;
 }
 
+static int send_one_no_status_check(void)
+{
+	int ticks = 0;
+
+	if (rte_cryptodev_enqueue_burst(params->valid_devs[0], 0,
+			&self->op, 1) != 1) {
+		RTE_LOG(ERR, USER1,
+			"line %u FAILED: Error sending packet for operation on device %d",
+			__LINE__, params->valid_devs[0]);
+		return TEST_FAILED;
+	}
+	while (rte_cryptodev_dequeue_burst(params->valid_devs[0], 0,
+			&self->result_op, 1) == 0) {
+		rte_delay_ms(1);
+		ticks++;
+		if (ticks >= DEQ_TIMEOUT) {
+			RTE_LOG(ERR, USER1,
+				"line %u FAILED: Cannot dequeue the crypto op on device %d",
+				__LINE__, params->valid_devs[0]);
+			return TEST_FAILED;
+		}
+	}
+	TEST_ASSERT_NOT_NULL(self->result_op,
+		"Failed to process asym crypto op");
+	return TEST_SUCCESS;
+}
+
 static int
 modular_cmpeq(const uint8_t *a, size_t a_len, const uint8_t *b, size_t b_len)
 {
@@ -3735,6 +3764,827 @@ modular_multiplicative_inverse(const void *test_data)
 	return TEST_SUCCESS;
 }
 
+static int
+mlkem_keygen(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t ek[TEST_DATA_SIZE] = {0};
+	uint8_t dk[TEST_DATA_SIZE] = {0};
+
+	xform.mlkem.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_KEYGEN;
+	self->op->asym->mlkem.keygen.d.data = vector->d.data;
+	self->op->asym->mlkem.keygen.d.length = vector->d.length;
+	self->op->asym->mlkem.keygen.z.data = vector->z.data;
+	self->op->asym->mlkem.keygen.z.length = vector->z.length;
+	self->op->asym->mlkem.keygen.dk.data = dk;
+	self->op->asym->mlkem.keygen.dk.length = 0;
+	self->op->asym->mlkem.keygen.ek.data = ek;
+	self->op->asym->mlkem.keygen.ek.length = 0;
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM KeyGen)");
+	debug_hexdump(stdout, "Decapsulation key",
+		self->result_op->asym->mlkem.keygen.dk.data,
+		self->result_op->asym->mlkem.keygen.dk.length);
+	debug_hexdump(stdout, "Encapsulation key",
+		self->result_op->asym->mlkem.keygen.ek.data,
+		self->result_op->asym->mlkem.keygen.ek.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.keygen.dk.length,
+		rte_crypto_ml_kem_privkey_size[vector->param],
+		"Incorrect Decapsulation key length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.keygen.ek.length,
+		rte_crypto_ml_kem_pubkey_size[vector->param],
+		"Incorrect Encapsulation key length\n");
+
+	/* If the seed is all zero, keys are deterministic */
+	if (memcmp(vector->d.data, (uint8_t [32]) {0},
+			vector->d.length) == 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->dk.data,
+			self->result_op->asym->mlkem.keygen.dk.data,
+			self->result_op->asym->mlkem.keygen.dk.length,
+			"Incorrect Decapsulation key\n");
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->ek.data,
+			self->result_op->asym->mlkem.keygen.ek.data,
+			self->result_op->asym->mlkem.keygen.ek.length,
+			"Incorrect Encapsulation key\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic keygen test passed\n");
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mlkem_encap(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t cipher[TEST_DATA_SIZE] = {0};
+	uint8_t skcopy[TEST_DATA_SIZE] = {0};
+	uint8_t sk[TEST_DATA_SIZE] = {0};
+	size_t cipher_len;
+
+	xform.mlkem.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Encapsulate */
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_ENCAP;
+	self->op->asym->mlkem.encap.message.data = vector->message.data;
+	self->op->asym->mlkem.encap.message.length = vector->message.length;
+	self->op->asym->mlkem.encap.ek.data = vector->ek.data;
+	self->op->asym->mlkem.encap.ek.length = vector->ek.length;
+	self->op->asym->mlkem.encap.cipher.data = cipher;
+	self->op->asym->mlkem.encap.cipher.length =
+		rte_crypto_ml_kem_cipher_size[vector->param];
+	self->op->asym->mlkem.encap.sk.data = sk;
+	self->op->asym->mlkem.encap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Encap)");
+	debug_hexdump(stdout, "Cipher",
+		self->result_op->asym->mlkem.encap.cipher.data,
+		self->result_op->asym->mlkem.encap.cipher.length);
+	debug_hexdump(stdout, "Shared secret from encap",
+		self->result_op->asym->mlkem.encap.sk.data,
+		self->result_op->asym->mlkem.encap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.encap.cipher.length,
+		rte_crypto_ml_kem_cipher_size[vector->param],
+		"Incorrect Cipher length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.encap.sk.length, 32,
+		"Incorrect Shared key length\n");
+
+	/* If random message is set, cipher and shared secret are deterministic */
+	if (vector->message.length != 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->cipher.data,
+			self->result_op->asym->mlkem.encap.cipher.data,
+			self->result_op->asym->mlkem.encap.cipher.length,
+			"Incorrect Cipher\n");
+
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->sk.data,
+			self->result_op->asym->mlkem.encap.sk.data,
+			self->result_op->asym->mlkem.encap.sk.length,
+			"Incorrect Shared secret\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic encap test passed\n");
+	}
+
+	/* Decapsulate and verify */
+	cipher_len = self->result_op->asym->mlkem.encap.cipher.length;
+	memcpy(skcopy, self->result_op->asym->mlkem.encap.sk.data,
+		self->result_op->asym->mlkem.encap.sk.length);
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from decap",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(self->result_op->asym->mlkem.decap.sk.data,
+		skcopy, self->result_op->asym->mlkem.decap.sk.length,
+		"Incorrect Shared secret\n");
+
+	/* Negative test */
+	cipher[0] ^= 0x01;
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from negative test",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+
+	if (!memcmp(self->result_op->asym->mlkem.decap.sk.data, skcopy, 32)) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mlkem_decap(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t cipher[TEST_DATA_SIZE] = {0};
+	uint8_t sk[TEST_DATA_SIZE] = {0};
+	size_t cipher_len;
+
+	xform.mlkem.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Decapsulate and verify */
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = vector->cipher.data;
+	self->op->asym->mlkem.decap.cipher.length = vector->cipher.length;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from decap",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(self->result_op->asym->mlkem.decap.sk.data,
+		vector->sk.data, vector->sk.length,
+		"Incorrect Shared secret\n");
+
+	/* Negative test */
+	memcpy(cipher, vector->cipher.data, vector->cipher.length);
+	cipher_len = vector->cipher.length;
+	cipher[0] ^= 0x01;
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from negative test",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+
+	if (!memcmp(self->result_op->asym->mlkem.decap.sk.data,
+		vector->sk.data, vector->sk.length)) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_keygen(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t privkey[TEST_DATA_SIZE] = {0};
+	uint8_t pubkey[TEST_DATA_SIZE] = {0};
+
+	xform.mldsa.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_KEYGEN;
+	self->op->asym->mldsa.keygen.seed.data = vector->seed.data;
+	self->op->asym->mldsa.keygen.seed.length = vector->seed.length;
+	self->op->asym->mldsa.keygen.privkey.data = privkey;
+	self->op->asym->mldsa.keygen.privkey.length = 0;
+	self->op->asym->mldsa.keygen.pubkey.data = pubkey;
+	self->op->asym->mldsa.keygen.pubkey.length = 0;
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA KeyGen)");
+
+	debug_hexdump(stdout, "Private key",
+		self->result_op->asym->mldsa.keygen.privkey.data,
+		self->result_op->asym->mldsa.keygen.privkey.length);
+	debug_hexdump(stdout, "Public key",
+		self->result_op->asym->mldsa.keygen.pubkey.data,
+		self->result_op->asym->mldsa.keygen.pubkey.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.keygen.privkey.length,
+		rte_crypto_ml_dsa_privkey_size[vector->param],
+		"Incorrect Private key length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.keygen.pubkey.length,
+		rte_crypto_ml_dsa_pubkey_size[vector->param],
+		"Incorrect Public key length\n");
+
+	/* If the seed is all zero, keys are deterministic */
+	if (memcmp(vector->seed.data, (uint8_t [32]) {0},
+			vector->seed.length) == 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->privkey.data,
+			self->result_op->asym->mldsa.keygen.privkey.data,
+			self->result_op->asym->mldsa.keygen.privkey.length,
+			"Incorrect Private key\n");
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->pubkey.data,
+			self->result_op->asym->mldsa.keygen.pubkey.data,
+			self->result_op->asym->mldsa.keygen.pubkey.length,
+			"Incorrect Public key\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic keygen test passed\n");
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_sign(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	struct rte_cryptodev_info dev_info;
+	uint8_t sign[TEST_DATA_SIZE] = {0};
+	size_t sign_len;
+
+	xform.mldsa.param = vector->param;
+	xform.mldsa.sign_deterministic = vector->sign_deterministic;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+
+	rte_cryptodev_info_get(dev_id, &dev_info);
+
+	/* Check if prehash is supported */
+	if (vector->hash) {
+		if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MLDSA_SIGN_PREHASH)) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support prehash in ML-DSA signature generation. Test skipped\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Sign */
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_SIGN;
+	self->op->asym->mldsa.siggen.seed.data = vector->seed.data;
+	self->op->asym->mldsa.siggen.seed.length = vector->seed.length;
+	self->op->asym->mldsa.siggen.privkey.data = vector->privkey.data;
+	self->op->asym->mldsa.siggen.privkey.length = vector->privkey.length;
+	self->op->asym->mldsa.siggen.message.data = vector->message.data;
+	self->op->asym->mldsa.siggen.message.length = vector->message.length;
+	self->op->asym->mldsa.siggen.ctx.data = vector->context.data;
+	self->op->asym->mldsa.siggen.ctx.length = vector->context.length;
+	self->op->asym->mldsa.siggen.mu.data = vector->mu.data;
+	self->op->asym->mldsa.siggen.mu.length = vector->mu.length;
+	self->op->asym->mldsa.siggen.sign.data = sign;
+	self->op->asym->mldsa.siggen.sign.length =
+		rte_crypto_ml_dsa_sign_size[vector->param];
+	self->op->asym->mldsa.siggen.hash = vector->hash;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Sign)");
+
+	debug_hexdump(stdout, "Signature",
+		self->result_op->asym->mldsa.siggen.sign.data,
+		self->result_op->asym->mldsa.siggen.sign.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.siggen.sign.length,
+		rte_crypto_ml_dsa_sign_size[vector->param],
+		"Incorrect Signature length\n");
+
+	/* Verify signature if it is deterministic */
+	if (vector->sign_deterministic) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->sign.data,
+			self->result_op->asym->mldsa.siggen.sign.data,
+			self->result_op->asym->mldsa.siggen.sign.length,
+			"Incorrect Signature\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic signature test passed\n");
+	}
+
+	/* Verify the signature */
+	sign_len = self->result_op->asym->mldsa.siggen.sign.length;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	TEST_ASSERT_EQUAL(self->result_op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+		"Failed to verify the signature");
+
+	/* Negative test */
+	sign[0] ^= 0x01;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one_no_status_check(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	if (self->result_op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_verify(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t sign[TEST_DATA_SIZE] = {0};
+	size_t sign_len;
+
+	xform.mldsa.param = vector->param;
+	xform.mldsa.sign_deterministic = vector->sign_deterministic;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Verify the signature */
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = vector->sign.data;
+	self->op->asym->mldsa.sigver.sign.length = vector->sign.length;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	TEST_ASSERT_EQUAL(self->result_op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+		"Failed to verify the signature");
+
+	/* Negative test */
+	memcpy(sign, vector->sign.data, vector->sign.length);
+	sign_len = vector->sign.length;
+	sign[0] ^= 0x01;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one_no_status_check(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	if (self->result_op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+test_mlkem_keygen(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_KEYGEN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM keygen operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_keygen_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_KEYGEN] &
+			(1 << mlkem_keygen_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_keygen_test_vectors[i].param,
+				mlkem_keygen_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_keygen_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_keygen(&mlkem_keygen_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_keygen_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_keygen_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mlkem_encap(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_ENCAP))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM encap operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_encap_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_ENCAP] &
+			(1 << mlkem_encap_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_encap_test_vectors[i].param,
+				mlkem_encap_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_encap_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_encap(&mlkem_encap_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_encap_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_encap_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mlkem_decap(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_DECAP))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM decap operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_decap_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_DECAP] &
+			(1 << mlkem_decap_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_decap_test_vectors[i].param,
+				mlkem_decap_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_decap_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_decap(&mlkem_decap_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_decap_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_decap_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_keygen(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_KEYGEN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA keygen operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_keygen_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_KEYGEN] &
+			(1 << mldsa_keygen_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_keygen_test_vectors[i].param,
+				mldsa_keygen_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_keygen_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_keygen(&mldsa_keygen_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_keygen_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_keygen_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_sign(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_SIGN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA sign operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_sign_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_SIGN] &
+			(1 << mldsa_sign_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_sign_test_vectors[i].param,
+				mldsa_sign_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_sign_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_sign(&mldsa_sign_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_sign_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_sign_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_verify(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_VERIFY))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA verify operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_verify_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_VERIFY] &
+			(1 << mldsa_verify_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_verify_test_vectors[i].param,
+				mldsa_verify_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_verify_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_verify(&mldsa_verify_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_verify_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_verify_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
 #define SET_RSA_PARAM(arg, vector, coef) \
 	uint8_t coef[TEST_DATA_SIZE] = { }; \
 	memcpy(coef, vector->coef.data, vector->coef.len); \
@@ -3987,6 +4837,12 @@ static struct unit_test_suite cryptodev_openssl_asym_testsuite  = {
 			ut_setup_asym, ut_teardown_asym,
 			modular_exponentiation, &modex_group_test_cases[7]),
 		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_eddsa_sign_verify_all_curve),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_keygen),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_encap),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_decap),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_keygen),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_sign),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_verify),
 		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
 };
app/test/test_cryptodev_ml_dsa_test_vectors.h new file +1856 -0

1,856 lines not on this page · raw message

app/test/test_cryptodev_ml_kem_test_vectors.h new file +873 -0

264 lines not on this page · raw message

The rest of this diff is not shown. View the raw message.

Signature · 1 line
2.37.1

Part of the diff is not shown here. View the raw message.

#5 lore raw
In reply to Gowrishankar Muthukrishnan
Quoted 9 lines

Subject: [PATCH v1 0/3] cryptodev: support PQC ML algorithms

This series added support for PQC ML-KEM and ML-DSA algorithms.

Gowrishankar Muthukrishnan (3):
cryptodev: support PQC ML algorithms
crypto/openssl: add ML crypto support
app/test: add ML crypto test vectors

Quoted 16 lines
 app/test/test_cryptodev_asym.c                |  856 ++++++++
 app/test/test_cryptodev_ml_dsa_test_vectors.h | 1856 +++++++++++++++++
 app/test/test_cryptodev_ml_kem_test_vectors.h |  873 ++++++++
 doc/guides/cryptodevs/features/default.ini    |    2 +
 doc/guides/cryptodevs/features/openssl.ini    |    2 +
 doc/guides/prog_guide/cryptodev_lib.rst       |    3 +-
 doc/guides/rel_notes/release_25_11.rst        |   11 +
 drivers/crypto/openssl/openssl_pmd_private.h  |   16 +
 drivers/crypto/openssl/rte_openssl_pmd.c      |  868 ++++++++
 drivers/crypto/openssl/rte_openssl_pmd_ops.c  |  129 ++
 lib/cryptodev/rte_crypto_asym.h               |  306 +++
 lib/cryptodev/rte_cryptodev.c                 |   60 +
 lib/cryptodev/rte_cryptodev.h                 |   15 +-
 13 files changed, 4994 insertions(+), 3 deletions(-)
 create mode 100644 app/test/test_cryptodev_ml_dsa_test_vectors.h
 create mode 100644 app/test/test_cryptodev_ml_kem_test_vectors.h

Please fix compilation on lower OpenSSL versions.

Quoted 3 lines

--
2.37.1

#6 lore raw

v2 cover cryptodev: support PQC ML algorithms

In reply to Gowrishankar Muthukrishnan

This series added support for PQC ML-KEM and ML-DSA algorithms.

Gowrishankar Muthukrishnan (3):
cryptodev: support PQC ML algorithms
crypto/openssl: add ML crypto support
app/test: add ML crypto test vectors

 app/test/test_cryptodev_asym.c                |  856 ++++++++
 app/test/test_cryptodev_ml_dsa_test_vectors.h | 1856 +++++++++++++++++
 app/test/test_cryptodev_ml_kem_test_vectors.h |  873 ++++++++
 doc/guides/cryptodevs/features/default.ini    |    2 +
 doc/guides/cryptodevs/features/openssl.ini    |    2 +
 doc/guides/prog_guide/cryptodev_lib.rst       |    3 +-
 doc/guides/rel_notes/release_25_11.rst        |   11 +
 drivers/crypto/openssl/openssl_pmd_private.h  |   16 +
 drivers/crypto/openssl/rte_openssl_pmd.c      |  870 ++++++++
 drivers/crypto/openssl/rte_openssl_pmd_ops.c  |  131 ++
 lib/cryptodev/rte_crypto_asym.h               |  306 +++
 lib/cryptodev/rte_cryptodev.c                 |   60 +
 lib/cryptodev/rte_cryptodev.h                 |   15 +-
 13 files changed, 4998 insertions(+), 3 deletions(-)
 create mode 100644 app/test/test_cryptodev_ml_dsa_test_vectors.h
 create mode 100644 app/test/test_cryptodev_ml_kem_test_vectors.h
Signature · 1 line
2.37.1
#7 lore raw

PATCH v2 1/3 cryptodev: support PQC ML algorithms

Add support for PQC ML-KEM and ML-DSA algorithms.

---
 doc/guides/cryptodevs/features/default.ini |   2 +
 doc/guides/prog_guide/cryptodev_lib.rst    |   3 +-
 doc/guides/rel_notes/release_25_11.rst     |  11 +
 lib/cryptodev/rte_crypto_asym.h            | 306 +++++++++++++++++++++
 lib/cryptodev/rte_cryptodev.c              |  60 ++++
 lib/cryptodev/rte_cryptodev.h              |  15 +-
 6 files changed, 394 insertions(+), 3 deletions(-)
doc/guides/cryptodevs/features/default.ini +2 -0
index 116ffce249..64198f013a 100644
@@ -134,6 +134,8 @@ ECPM                    =
 ECDH                    =
 SM2                     =
 EdDSA                   =
+ML-DSA                  =
+ML-KEM                  =
 
 ;
 ; Supported Operating systems of a default crypto driver.
doc/guides/prog_guide/cryptodev_lib.rst +2 -1
index b54efcb74e..f0ee44eb54 100644
@@ -928,7 +928,8 @@ Asymmetric Cryptography
 The cryptodev library currently provides support for the following asymmetric
 Crypto operations; RSA, Modular exponentiation and inversion, Diffie-Hellman and
 Elliptic Curve Diffie-Hellman public and/or private key generation and shared
-secret compute, DSA and EdDSA signature generation and verification.
+secret compute, DSA and EdDSA signature generation and verification,
+PQC ML-KEM and ML-DSA algorithms.
 
 Session and Session Management
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
doc/guides/rel_notes/release_25_11.rst +11 -0
index c3b94e1896..9d47f762d7 100644
@@ -76,6 +76,14 @@ New Features
   * Added multi-process per port.
   * Optimized code.
 
+* **Added PQC ML-KEM and ML-DSA support.**
+
+  * Added PQC ML-KEM support with reference to FIPS203.
+  * Added PQC ML-DSA support with reference to FIPS204.
+
+* **Updated openssl crypto driver.**
+
+  * Added support for PQC ML-KEM and ML-DSA algorithms.
 
 Removed Items
 -------------
@@ -138,6 +146,9 @@ ABI Changes
 * stack: The structure ``rte_stack_lf_head`` alignment has been updated to 16 bytes
   to avoid unaligned accesses.
 
+* cryptodev: The enum ``rte_crypto_asym_xform_type``, struct ``rte_crypto_asym_xform``
+  and struct ``rte_crypto_asym_op`` are updated to include new values to support
+  ML-KEM and ML-DSA.
 
 Known Issues
 ------------
lib/cryptodev/rte_crypto_asym.h +306 -0

336 lines not on this page · raw message

lib/cryptodev/rte_cryptodev.c +60 -0

66 lines not on this page · raw message

lib/cryptodev/rte_cryptodev.h +13 -2
index eaf0e50d37..37a6a5e49b 100644
@@ -167,10 +167,13 @@ struct rte_cryptodev_asymmetric_xform_capability {
 	uint32_t op_types;
 	/**<
 	 * Bitmask for supported rte_crypto_asym_op_type or
+	 * rte_crypto_ml_kem_op_type or rte_crypto_ml_dsa_op_type or
 	 * rte_crypto_asym_ke_type. Which enum is used is determined
 	 * by the rte_crypto_asym_xform_type. For key exchange algorithms
-	 * like Diffie-Hellman it is rte_crypto_asym_ke_type, for others
-	 * it is rte_crypto_asym_op_type.
+	 * like Diffie-Hellman it is rte_crypto_asym_ke_type,
+	 * for ML-KEM algorithms it is rte_crypto_ml_kem_op_type,
+	 * for ML-DSA algorithms it is rte_crypto_ml_dsa_op_type,
+	 * or others it is rte_crypto_asym_op_type.
 	 */
 
 	__extension__
@@ -188,6 +191,12 @@ struct rte_cryptodev_asymmetric_xform_capability {
 
 		uint32_t op_capa[RTE_CRYPTO_ASYM_OP_LIST_END];
 		/**< Operation specific capabilities. */
+
+		uint32_t mlkem_capa[RTE_CRYPTO_ML_KEM_OP_END];
+		/**< Bitmask of supported ML-KEM parameter sets. */
+
+		uint32_t mldsa_capa[RTE_CRYPTO_ML_DSA_OP_END];
+		/**< Bitmask of supported ML-DSA parameter sets. */
 	};
 
 	uint64_t hash_algos;
@@ -577,6 +586,8 @@ rte_cryptodev_asym_get_xform_string(enum rte_crypto_asym_xform_type xform_enum);
 /**< Support inner checksum computation/verification */
 #define RTE_CRYPTODEV_FF_SECURITY_RX_INJECT		(1ULL << 28)
 /**< Support Rx injection after security processing */
+#define RTE_CRYPTODEV_FF_MLDSA_SIGN_PREHASH		(1ULL << 29)
+/**< Support Pre Hash ML-DSA Signature Generation */
 
 /**
  * Get the name of a crypto device feature flag
Signature · 1 line
2.37.1
#8 lore raw

PATCH v2 2/3 crypto/openssl: add ML crypto support

In reply to Gowrishankar Muthukrishnan

Add ML-KEM and ML-DSA support.

---
v2:
- compilation fixed for unsupported openssl versions.

---
 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 | 131 +++
 4 files changed, 1019 insertions(+)
doc/guides/cryptodevs/features/openssl.ini +2 -0
index f0074a46f8..df6e7de316 100644
@@ -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.
drivers/crypto/openssl/openssl_pmd_private.h +16 -0
index 4a6a088870..7f87840b84 100644
@@ -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_ */
drivers/crypto/openssl/rte_openssl_pmd.c +870 -0

888 lines not on this page · raw message

drivers/crypto/openssl/rte_openssl_pmd_ops.c +131 -0

153 lines not on this page · raw message

Signature · 1 line
2.37.1
#9 lore raw

PATCH v2 3/3 app/test: add ML crypto test vectors

In reply to Gowrishankar Muthukrishnan

Add ML-KEM and ML-DSA test vectors.

---
 app/test/test_cryptodev_asym.c                |  856 ++++++++
 app/test/test_cryptodev_ml_dsa_test_vectors.h | 1856 +++++++++++++++++
 app/test/test_cryptodev_ml_kem_test_vectors.h |  873 ++++++++
 3 files changed, 3585 insertions(+)
 create mode 100644 app/test/test_cryptodev_ml_dsa_test_vectors.h
 create mode 100644 app/test/test_cryptodev_ml_kem_test_vectors.h
app/test/test_cryptodev_asym.c +856 -0
index 20afb5e98b..942a23e3b3 100644
@@ -24,6 +24,8 @@
 #include "test_cryptodev_mod_test_vectors.h"
 #include "test_cryptodev_rsa_test_vectors.h"
 #include "test_cryptodev_sm2_test_vectors.h"
+#include "test_cryptodev_ml_kem_test_vectors.h"
+#include "test_cryptodev_ml_dsa_test_vectors.h"
 #include "test_cryptodev_asym_util.h"
 #include "test.h"
 
@@ -3629,6 +3631,33 @@ static int send_one(void)
 	return TEST_SUCCESS;
 }
 
+static int send_one_no_status_check(void)
+{
+	int ticks = 0;
+
+	if (rte_cryptodev_enqueue_burst(params->valid_devs[0], 0,
+			&self->op, 1) != 1) {
+		RTE_LOG(ERR, USER1,
+			"line %u FAILED: Error sending packet for operation on device %d",
+			__LINE__, params->valid_devs[0]);
+		return TEST_FAILED;
+	}
+	while (rte_cryptodev_dequeue_burst(params->valid_devs[0], 0,
+			&self->result_op, 1) == 0) {
+		rte_delay_ms(1);
+		ticks++;
+		if (ticks >= DEQ_TIMEOUT) {
+			RTE_LOG(ERR, USER1,
+				"line %u FAILED: Cannot dequeue the crypto op on device %d",
+				__LINE__, params->valid_devs[0]);
+			return TEST_FAILED;
+		}
+	}
+	TEST_ASSERT_NOT_NULL(self->result_op,
+		"Failed to process asym crypto op");
+	return TEST_SUCCESS;
+}
+
 static int
 modular_cmpeq(const uint8_t *a, size_t a_len, const uint8_t *b, size_t b_len)
 {
@@ -3735,6 +3764,827 @@ modular_multiplicative_inverse(const void *test_data)
 	return TEST_SUCCESS;
 }
 
+static int
+mlkem_keygen(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t ek[TEST_DATA_SIZE] = {0};
+	uint8_t dk[TEST_DATA_SIZE] = {0};
+
+	xform.mlkem.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_KEYGEN;
+	self->op->asym->mlkem.keygen.d.data = vector->d.data;
+	self->op->asym->mlkem.keygen.d.length = vector->d.length;
+	self->op->asym->mlkem.keygen.z.data = vector->z.data;
+	self->op->asym->mlkem.keygen.z.length = vector->z.length;
+	self->op->asym->mlkem.keygen.dk.data = dk;
+	self->op->asym->mlkem.keygen.dk.length = 0;
+	self->op->asym->mlkem.keygen.ek.data = ek;
+	self->op->asym->mlkem.keygen.ek.length = 0;
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM KeyGen)");
+	debug_hexdump(stdout, "Decapsulation key",
+		self->result_op->asym->mlkem.keygen.dk.data,
+		self->result_op->asym->mlkem.keygen.dk.length);
+	debug_hexdump(stdout, "Encapsulation key",
+		self->result_op->asym->mlkem.keygen.ek.data,
+		self->result_op->asym->mlkem.keygen.ek.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.keygen.dk.length,
+		rte_crypto_ml_kem_privkey_size[vector->param],
+		"Incorrect Decapsulation key length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.keygen.ek.length,
+		rte_crypto_ml_kem_pubkey_size[vector->param],
+		"Incorrect Encapsulation key length\n");
+
+	/* If the seed is all zero, keys are deterministic */
+	if (memcmp(vector->d.data, (uint8_t [32]) {0},
+			vector->d.length) == 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->dk.data,
+			self->result_op->asym->mlkem.keygen.dk.data,
+			self->result_op->asym->mlkem.keygen.dk.length,
+			"Incorrect Decapsulation key\n");
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->ek.data,
+			self->result_op->asym->mlkem.keygen.ek.data,
+			self->result_op->asym->mlkem.keygen.ek.length,
+			"Incorrect Encapsulation key\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic keygen test passed\n");
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mlkem_encap(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t cipher[TEST_DATA_SIZE] = {0};
+	uint8_t skcopy[TEST_DATA_SIZE] = {0};
+	uint8_t sk[TEST_DATA_SIZE] = {0};
+	size_t cipher_len;
+
+	xform.mlkem.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Encapsulate */
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_ENCAP;
+	self->op->asym->mlkem.encap.message.data = vector->message.data;
+	self->op->asym->mlkem.encap.message.length = vector->message.length;
+	self->op->asym->mlkem.encap.ek.data = vector->ek.data;
+	self->op->asym->mlkem.encap.ek.length = vector->ek.length;
+	self->op->asym->mlkem.encap.cipher.data = cipher;
+	self->op->asym->mlkem.encap.cipher.length =
+		rte_crypto_ml_kem_cipher_size[vector->param];
+	self->op->asym->mlkem.encap.sk.data = sk;
+	self->op->asym->mlkem.encap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Encap)");
+	debug_hexdump(stdout, "Cipher",
+		self->result_op->asym->mlkem.encap.cipher.data,
+		self->result_op->asym->mlkem.encap.cipher.length);
+	debug_hexdump(stdout, "Shared secret from encap",
+		self->result_op->asym->mlkem.encap.sk.data,
+		self->result_op->asym->mlkem.encap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.encap.cipher.length,
+		rte_crypto_ml_kem_cipher_size[vector->param],
+		"Incorrect Cipher length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.encap.sk.length, 32,
+		"Incorrect Shared key length\n");
+
+	/* If random message is set, cipher and shared secret are deterministic */
+	if (vector->message.length != 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->cipher.data,
+			self->result_op->asym->mlkem.encap.cipher.data,
+			self->result_op->asym->mlkem.encap.cipher.length,
+			"Incorrect Cipher\n");
+
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->sk.data,
+			self->result_op->asym->mlkem.encap.sk.data,
+			self->result_op->asym->mlkem.encap.sk.length,
+			"Incorrect Shared secret\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic encap test passed\n");
+	}
+
+	/* Decapsulate and verify */
+	cipher_len = self->result_op->asym->mlkem.encap.cipher.length;
+	memcpy(skcopy, self->result_op->asym->mlkem.encap.sk.data,
+		self->result_op->asym->mlkem.encap.sk.length);
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from decap",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(self->result_op->asym->mlkem.decap.sk.data,
+		skcopy, self->result_op->asym->mlkem.decap.sk.length,
+		"Incorrect Shared secret\n");
+
+	/* Negative test */
+	cipher[0] ^= 0x01;
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from negative test",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+
+	if (!memcmp(self->result_op->asym->mlkem.decap.sk.data, skcopy, 32)) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mlkem_decap(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t cipher[TEST_DATA_SIZE] = {0};
+	uint8_t sk[TEST_DATA_SIZE] = {0};
+	size_t cipher_len;
+
+	xform.mlkem.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Decapsulate and verify */
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = vector->cipher.data;
+	self->op->asym->mlkem.decap.cipher.length = vector->cipher.length;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from decap",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(self->result_op->asym->mlkem.decap.sk.data,
+		vector->sk.data, vector->sk.length,
+		"Incorrect Shared secret\n");
+
+	/* Negative test */
+	memcpy(cipher, vector->cipher.data, vector->cipher.length);
+	cipher_len = vector->cipher.length;
+	cipher[0] ^= 0x01;
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from negative test",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+
+	if (!memcmp(self->result_op->asym->mlkem.decap.sk.data,
+		vector->sk.data, vector->sk.length)) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_keygen(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t privkey[TEST_DATA_SIZE] = {0};
+	uint8_t pubkey[TEST_DATA_SIZE] = {0};
+
+	xform.mldsa.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_KEYGEN;
+	self->op->asym->mldsa.keygen.seed.data = vector->seed.data;
+	self->op->asym->mldsa.keygen.seed.length = vector->seed.length;
+	self->op->asym->mldsa.keygen.privkey.data = privkey;
+	self->op->asym->mldsa.keygen.privkey.length = 0;
+	self->op->asym->mldsa.keygen.pubkey.data = pubkey;
+	self->op->asym->mldsa.keygen.pubkey.length = 0;
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA KeyGen)");
+
+	debug_hexdump(stdout, "Private key",
+		self->result_op->asym->mldsa.keygen.privkey.data,
+		self->result_op->asym->mldsa.keygen.privkey.length);
+	debug_hexdump(stdout, "Public key",
+		self->result_op->asym->mldsa.keygen.pubkey.data,
+		self->result_op->asym->mldsa.keygen.pubkey.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.keygen.privkey.length,
+		rte_crypto_ml_dsa_privkey_size[vector->param],
+		"Incorrect Private key length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.keygen.pubkey.length,
+		rte_crypto_ml_dsa_pubkey_size[vector->param],
+		"Incorrect Public key length\n");
+
+	/* If the seed is all zero, keys are deterministic */
+	if (memcmp(vector->seed.data, (uint8_t [32]) {0},
+			vector->seed.length) == 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->privkey.data,
+			self->result_op->asym->mldsa.keygen.privkey.data,
+			self->result_op->asym->mldsa.keygen.privkey.length,
+			"Incorrect Private key\n");
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->pubkey.data,
+			self->result_op->asym->mldsa.keygen.pubkey.data,
+			self->result_op->asym->mldsa.keygen.pubkey.length,
+			"Incorrect Public key\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic keygen test passed\n");
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_sign(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	struct rte_cryptodev_info dev_info;
+	uint8_t sign[TEST_DATA_SIZE] = {0};
+	size_t sign_len;
+
+	xform.mldsa.param = vector->param;
+	xform.mldsa.sign_deterministic = vector->sign_deterministic;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+
+	rte_cryptodev_info_get(dev_id, &dev_info);
+
+	/* Check if prehash is supported */
+	if (vector->hash) {
+		if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MLDSA_SIGN_PREHASH)) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support prehash in ML-DSA signature generation. Test skipped\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Sign */
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_SIGN;
+	self->op->asym->mldsa.siggen.seed.data = vector->seed.data;
+	self->op->asym->mldsa.siggen.seed.length = vector->seed.length;
+	self->op->asym->mldsa.siggen.privkey.data = vector->privkey.data;
+	self->op->asym->mldsa.siggen.privkey.length = vector->privkey.length;
+	self->op->asym->mldsa.siggen.message.data = vector->message.data;
+	self->op->asym->mldsa.siggen.message.length = vector->message.length;
+	self->op->asym->mldsa.siggen.ctx.data = vector->context.data;
+	self->op->asym->mldsa.siggen.ctx.length = vector->context.length;
+	self->op->asym->mldsa.siggen.mu.data = vector->mu.data;
+	self->op->asym->mldsa.siggen.mu.length = vector->mu.length;
+	self->op->asym->mldsa.siggen.sign.data = sign;
+	self->op->asym->mldsa.siggen.sign.length =
+		rte_crypto_ml_dsa_sign_size[vector->param];
+	self->op->asym->mldsa.siggen.hash = vector->hash;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Sign)");
+
+	debug_hexdump(stdout, "Signature",
+		self->result_op->asym->mldsa.siggen.sign.data,
+		self->result_op->asym->mldsa.siggen.sign.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.siggen.sign.length,
+		rte_crypto_ml_dsa_sign_size[vector->param],
+		"Incorrect Signature length\n");
+
+	/* Verify signature if it is deterministic */
+	if (vector->sign_deterministic) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->sign.data,
+			self->result_op->asym->mldsa.siggen.sign.data,
+			self->result_op->asym->mldsa.siggen.sign.length,
+			"Incorrect Signature\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic signature test passed\n");
+	}
+
+	/* Verify the signature */
+	sign_len = self->result_op->asym->mldsa.siggen.sign.length;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	TEST_ASSERT_EQUAL(self->result_op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+		"Failed to verify the signature");
+
+	/* Negative test */
+	sign[0] ^= 0x01;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one_no_status_check(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	if (self->result_op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_verify(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t sign[TEST_DATA_SIZE] = {0};
+	size_t sign_len;
+
+	xform.mldsa.param = vector->param;
+	xform.mldsa.sign_deterministic = vector->sign_deterministic;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Verify the signature */
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = vector->sign.data;
+	self->op->asym->mldsa.sigver.sign.length = vector->sign.length;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	TEST_ASSERT_EQUAL(self->result_op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+		"Failed to verify the signature");
+
+	/* Negative test */
+	memcpy(sign, vector->sign.data, vector->sign.length);
+	sign_len = vector->sign.length;
+	sign[0] ^= 0x01;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one_no_status_check(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	if (self->result_op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+test_mlkem_keygen(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_KEYGEN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM keygen operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_keygen_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_KEYGEN] &
+			(1 << mlkem_keygen_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_keygen_test_vectors[i].param,
+				mlkem_keygen_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_keygen_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_keygen(&mlkem_keygen_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_keygen_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_keygen_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mlkem_encap(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_ENCAP))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM encap operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_encap_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_ENCAP] &
+			(1 << mlkem_encap_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_encap_test_vectors[i].param,
+				mlkem_encap_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_encap_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_encap(&mlkem_encap_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_encap_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_encap_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mlkem_decap(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_DECAP))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM decap operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_decap_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_DECAP] &
+			(1 << mlkem_decap_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_decap_test_vectors[i].param,
+				mlkem_decap_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_decap_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_decap(&mlkem_decap_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_decap_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_decap_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_keygen(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_KEYGEN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA keygen operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_keygen_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_KEYGEN] &
+			(1 << mldsa_keygen_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_keygen_test_vectors[i].param,
+				mldsa_keygen_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_keygen_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_keygen(&mldsa_keygen_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_keygen_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_keygen_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_sign(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_SIGN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA sign operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_sign_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_SIGN] &
+			(1 << mldsa_sign_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_sign_test_vectors[i].param,
+				mldsa_sign_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_sign_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_sign(&mldsa_sign_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_sign_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_sign_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_verify(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_VERIFY))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA verify operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_verify_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_VERIFY] &
+			(1 << mldsa_verify_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_verify_test_vectors[i].param,
+				mldsa_verify_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_verify_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_verify(&mldsa_verify_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_verify_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_verify_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
 #define SET_RSA_PARAM(arg, vector, coef) \
 	uint8_t coef[TEST_DATA_SIZE] = { }; \
 	memcpy(coef, vector->coef.data, vector->coef.len); \
@@ -3987,6 +4837,12 @@ static struct unit_test_suite cryptodev_openssl_asym_testsuite  = {
 			ut_setup_asym, ut_teardown_asym,
 			modular_exponentiation, &modex_group_test_cases[7]),
 		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_eddsa_sign_verify_all_curve),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_keygen),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_encap),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_decap),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_keygen),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_sign),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_verify),
 		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
 };
app/test/test_cryptodev_ml_dsa_test_vectors.h new file +1856 -0

1,856 lines not on this page · raw message

app/test/test_cryptodev_ml_kem_test_vectors.h new file +873 -0

264 lines not on this page · raw message

The rest of this diff is not shown. View the raw message.

Signature · 1 line
2.37.1

Part of the diff is not shown here. View the raw message.

#10 lore raw

v3 cover cryptodev: support PQC ML algorithms

In reply to Gowrishankar Muthukrishnan

This series added support for PQC ML-KEM and ML-DSA algorithms.

Gowrishankar Muthukrishnan (3):
cryptodev: support PQC ML algorithms
crypto/openssl: add ML crypto support
app/test: add ML crypto test vectors

 app/test/test_cryptodev_asym.c                |  856 ++++++++
 app/test/test_cryptodev_ml_dsa_test_vectors.h | 1856 +++++++++++++++++
 app/test/test_cryptodev_ml_kem_test_vectors.h |  873 ++++++++
 doc/guides/cryptodevs/features/default.ini    |    2 +
 doc/guides/cryptodevs/features/openssl.ini    |    2 +
 doc/guides/prog_guide/cryptodev_lib.rst       |    3 +-
 doc/guides/rel_notes/release_25_11.rst        |   11 +
 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 ++
 lib/cryptodev/rte_crypto_asym.h               |  306 +++
 lib/cryptodev/rte_cryptodev.c                 |   60 +
 lib/cryptodev/rte_cryptodev.h                 |   15 +-
 13 files changed, 5000 insertions(+), 3 deletions(-)
 create mode 100644 app/test/test_cryptodev_ml_dsa_test_vectors.h
 create mode 100644 app/test/test_cryptodev_ml_kem_test_vectors.h
Signature · 1 line
2.37.1
#11 lore raw

PATCH v3 1/3 cryptodev: support PQC ML algorithms

Add support for PQC ML-KEM and ML-DSA algorithms.

---
 doc/guides/cryptodevs/features/default.ini |   2 +
 doc/guides/prog_guide/cryptodev_lib.rst    |   3 +-
 doc/guides/rel_notes/release_25_11.rst     |  11 +
 lib/cryptodev/rte_crypto_asym.h            | 306 +++++++++++++++++++++
 lib/cryptodev/rte_cryptodev.c              |  60 ++++
 lib/cryptodev/rte_cryptodev.h              |  15 +-
 6 files changed, 394 insertions(+), 3 deletions(-)
doc/guides/cryptodevs/features/default.ini +2 -0
index 116ffce249..64198f013a 100644
@@ -134,6 +134,8 @@ ECPM                    =
 ECDH                    =
 SM2                     =
 EdDSA                   =
+ML-DSA                  =
+ML-KEM                  =
 
 ;
 ; Supported Operating systems of a default crypto driver.
doc/guides/prog_guide/cryptodev_lib.rst +2 -1
index b54efcb74e..f0ee44eb54 100644
@@ -928,7 +928,8 @@ Asymmetric Cryptography
 The cryptodev library currently provides support for the following asymmetric
 Crypto operations; RSA, Modular exponentiation and inversion, Diffie-Hellman and
 Elliptic Curve Diffie-Hellman public and/or private key generation and shared
-secret compute, DSA and EdDSA signature generation and verification.
+secret compute, DSA and EdDSA signature generation and verification,
+PQC ML-KEM and ML-DSA algorithms.
 
 Session and Session Management
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
doc/guides/rel_notes/release_25_11.rst +11 -0
index c3b94e1896..9d47f762d7 100644
@@ -76,6 +76,14 @@ New Features
   * Added multi-process per port.
   * Optimized code.
 
+* **Added PQC ML-KEM and ML-DSA support.**
+
+  * Added PQC ML-KEM support with reference to FIPS203.
+  * Added PQC ML-DSA support with reference to FIPS204.
+
+* **Updated openssl crypto driver.**
+
+  * Added support for PQC ML-KEM and ML-DSA algorithms.
 
 Removed Items
 -------------
@@ -138,6 +146,9 @@ ABI Changes
 * stack: The structure ``rte_stack_lf_head`` alignment has been updated to 16 bytes
   to avoid unaligned accesses.
 
+* cryptodev: The enum ``rte_crypto_asym_xform_type``, struct ``rte_crypto_asym_xform``
+  and struct ``rte_crypto_asym_op`` are updated to include new values to support
+  ML-KEM and ML-DSA.
 
 Known Issues
 ------------
lib/cryptodev/rte_crypto_asym.h +306 -0

336 lines not on this page · raw message

lib/cryptodev/rte_cryptodev.c +60 -0

66 lines not on this page · raw message

lib/cryptodev/rte_cryptodev.h +13 -2
index eaf0e50d37..37a6a5e49b 100644
@@ -167,10 +167,13 @@ struct rte_cryptodev_asymmetric_xform_capability {
 	uint32_t op_types;
 	/**<
 	 * Bitmask for supported rte_crypto_asym_op_type or
+	 * rte_crypto_ml_kem_op_type or rte_crypto_ml_dsa_op_type or
 	 * rte_crypto_asym_ke_type. Which enum is used is determined
 	 * by the rte_crypto_asym_xform_type. For key exchange algorithms
-	 * like Diffie-Hellman it is rte_crypto_asym_ke_type, for others
-	 * it is rte_crypto_asym_op_type.
+	 * like Diffie-Hellman it is rte_crypto_asym_ke_type,
+	 * for ML-KEM algorithms it is rte_crypto_ml_kem_op_type,
+	 * for ML-DSA algorithms it is rte_crypto_ml_dsa_op_type,
+	 * or others it is rte_crypto_asym_op_type.
 	 */
 
 	__extension__
@@ -188,6 +191,12 @@ struct rte_cryptodev_asymmetric_xform_capability {
 
 		uint32_t op_capa[RTE_CRYPTO_ASYM_OP_LIST_END];
 		/**< Operation specific capabilities. */
+
+		uint32_t mlkem_capa[RTE_CRYPTO_ML_KEM_OP_END];
+		/**< Bitmask of supported ML-KEM parameter sets. */
+
+		uint32_t mldsa_capa[RTE_CRYPTO_ML_DSA_OP_END];
+		/**< Bitmask of supported ML-DSA parameter sets. */
 	};
 
 	uint64_t hash_algos;
@@ -577,6 +586,8 @@ rte_cryptodev_asym_get_xform_string(enum rte_crypto_asym_xform_type xform_enum);
 /**< Support inner checksum computation/verification */
 #define RTE_CRYPTODEV_FF_SECURITY_RX_INJECT		(1ULL << 28)
 /**< Support Rx injection after security processing */
+#define RTE_CRYPTODEV_FF_MLDSA_SIGN_PREHASH		(1ULL << 29)
+/**< Support Pre Hash ML-DSA Signature Generation */
 
 /**
  * Get the name of a crypto device feature flag
Signature · 1 line
2.37.1
#12 lore raw
Quoted 51 lines

Subject: [PATCH v3 1/3] cryptodev: support PQC ML algorithms

Add support for PQC ML-KEM and ML-DSA algorithms.

---
 doc/guides/cryptodevs/features/default.ini |   2 +
 doc/guides/prog_guide/cryptodev_lib.rst    |   3 +-
 doc/guides/rel_notes/release_25_11.rst     |  11 +
 lib/cryptodev/rte_crypto_asym.h            | 306 +++++++++++++++++++++
 lib/cryptodev/rte_cryptodev.c              |  60 ++++
 lib/cryptodev/rte_cryptodev.h              |  15 +-
 6 files changed, 394 insertions(+), 3 deletions(-)
doc/guides/cryptodevs/features/default.ini +2 -0
index 116ffce249..64198f013a 100644
@@ -134,6 +134,8 @@ ECPM                    =
 ECDH                    =
 SM2                     =
 EdDSA                   =
+ML-DSA                  =
+ML-KEM                  =
 
 ;
 ; Supported Operating systems of a default crypto driver.
doc/guides/prog_guide/cryptodev_lib.rst +0 -0
index b54efcb74e..f0ee44eb54 100644
@@ -928,7 +928,8 @@ Asymmetric Cryptography
 The cryptodev library currently provides support for the following asymmetric
 Crypto operations; RSA, Modular exponentiation and inversion, Diffie-Hellman

and
Elliptic Curve Diffie-Hellman public and/or private key generation and shared

doc/guides/prog_guide/cryptodev_lib.rst +2 -1
-secret compute, DSA and EdDSA signature generation and verification.
+secret compute, DSA and EdDSA signature generation and verification,
+PQC ML-KEM and ML-DSA algorithms.
 
 Session and Session Management
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
doc/guides/rel_notes/release_25_11.rst +0 -0
index c3b94e1896..9d47f762d7 100644
@@ -76,6 +76,14 @@ New Features
   * Added multi-process per port.

doc/guides/rel_notes/release_25_11.rst New Features · line 86

Quoted 10 lines
doc/guides/rel_notes/release_25_11.rst +8 -0
   * Optimized code.
 
+* **Added PQC ML-KEM and ML-DSA support.**
+
+  * Added PQC ML-KEM support with reference to FIPS203.
+  * Added PQC ML-DSA support with reference to FIPS204.
+
+* **Updated openssl crypto driver.**
+
+  * Added support for PQC ML-KEM and ML-DSA algorithms.

Split the openssl update into your 2/3 patch.

Quoted 61 lines
doc/guides/rel_notes/release_25_11.rst +0 -0
 Removed Items
 -------------
@@ -138,6 +146,9 @@ ABI Changes
 * stack: The structure ``rte_stack_lf_head`` alignment has been updated to 16

bytes
to avoid unaligned accesses.

+* cryptodev: The enum ``rte_crypto_asym_xform_type``, struct ``rte_crypto_asym_xform``
+ and struct ``rte_crypto_asym_op`` are updated to include new values to support

doc/guides/rel_notes/release_25_11.rst +1 -0
+  ML-KEM and ML-DSA.
 
 Known Issues
 ------------
lib/cryptodev/rte_crypto_asym.h +23 -0
index 9787b710e7..14a0e57467 100644
@@ -37,6 +37,20 @@ rte_crypto_asym_ke_strings[];
 extern const char *
 rte_crypto_asym_op_strings[];
 
+/** PQC ML crypto op parameters size */
+extern const uint16_t
+rte_crypto_ml_kem_pubkey_size[];
+extern const uint16_t
+rte_crypto_ml_kem_privkey_size[];
+extern const uint16_t
+rte_crypto_ml_kem_cipher_size[];
+extern const uint16_t
+rte_crypto_ml_dsa_pubkey_size[];
+extern const uint16_t
+rte_crypto_ml_dsa_privkey_size[];
+extern const uint16_t
+rte_crypto_ml_dsa_sign_size[];
+
 #ifdef __cplusplus
 }
 #endif
@@ -144,6 +158,14 @@ enum rte_crypto_asym_xform_type {
 	/**< Edwards Curve Digital Signature Algorithm
 	 * Perform Signature Generation and Verification.
 	 */
+	RTE_CRYPTO_ASYM_XFORM_ML_KEM,
+	/**< Module Lattice based Key Encapsulation Mechanism
+	 * Performs Key Pair Generation, Encapsulation and Decapsulation.
+	 */
+	RTE_CRYPTO_ASYM_XFORM_ML_DSA
+	/**< Module Lattice based Digital Signature Algorithm
+	 * Performs Key Pair Generation, Signature Generation and Verification.
+	 */
 };
 
 /**
@@ -720,6 +742,282 @@ struct rte_crypto_sm2_op_param {
 	 */
 };
 
+/**

lib/cryptodev/rte_crypto_asym.h struct rte_crypto_sm2_op_param { · line 755

Quoted 10 lines
lib/cryptodev/rte_crypto_asym.h +10 -0
+ * PQC ML-KEM algorithms
+ *
+ * List of ML-KEM algorithms used in PQC
+ */
+enum rte_crypto_ml_kem_param_set {
+	RTE_CRYPTO_ML_KEM_PARAM_NONE,
+	RTE_CRYPTO_ML_KEM_PARAM_512,
+	RTE_CRYPTO_ML_KEM_PARAM_768,
+	RTE_CRYPTO_ML_KEM_PARAM_1024,
+};

Can we drop PARAM and use RTE_CRYPTO_ML_KEM_512

Quoted 12 lines
lib/cryptodev/rte_crypto_asym.h +12 -0
+
+/**
+ * PQC ML-KEM op types
+ *
+ * List of ML-KEM op types in PQC
+ */
+enum rte_crypto_ml_kem_op_type {
+	RTE_CRYPTO_ML_KEM_OP_KEYGEN,
+	RTE_CRYPTO_ML_KEM_OP_KEYVER,
+	RTE_CRYPTO_ML_KEM_OP_ENCAP,
+	RTE_CRYPTO_ML_KEM_OP_DECAP,
+	RTE_CRYPTO_ML_KEM_OP_END

lib/cryptodev/rte_crypto_asym.h struct rte_crypto_sm2_op_param { · line 777

Quoted 10 lines
lib/cryptodev/rte_crypto_asym.h +10 -0
+};
+
+/**
+ * PQC ML-KEM transform data
+ *
+ * Structure describing ML-KEM xform params
+ */
+struct rte_crypto_ml_kem_xform {
+	enum rte_crypto_ml_kem_param_set param;
+};

Doxygen comments missing.

Quoted 110 lines
lib/cryptodev/rte_crypto_asym.h +110 -0
+
+/**
+ * PQC ML-KEM KEYGEN op
+ *
+ * Parameters for PQC ML-KEM key generation operation
+ */
+struct rte_crypto_ml_kem_keygen_op {
+	rte_crypto_param d;
+	/**< The seed d value (of 32 bytes in length) to generate key pair.*/
+
+	rte_crypto_param z;
+	/**< The seed z value (of 32 bytes in length) to generate key pair.*/
+
+	rte_crypto_param ek;
+	/**<
+	 * Pointer to output data
+	 * - The computed encapsulation key.
+	 * - Refer `rte_crypto_ml_kem_pubkey_size` for size of buffer.
+	 */
+
+	rte_crypto_param dk;
+	/**<
+	 * Pointer to output data
+	 * - The computed decapsulation key.
+	 * - Refer `rte_crypto_ml_kem_privkey_size` for size of buffer.
+	 */
+};
+
+/**
+ * PQC ML-KEM KEYVER op
+ *
+ * Parameters for PQC ML-KEM key verification operation
+ */
+struct rte_crypto_ml_kem_keyver_op {
+	enum rte_crypto_ml_kem_op_type op;
+	/**<
+	 * Op associated with key to be verified is one of below:
+	 * - Encapsulation op
+	 * - Decapsulation op
+	 */
+
+	rte_crypto_param key;
+	/**<
+	 * KEM key to check.
+	 * - ek in case of encapsulation op.
+	 * - dk in case of decapsulation op.
+	 */
+};
+
+/**
+ * PQC ML-KEM ENCAP op
+ *
+ * Parameters for PQC ML-KEM encapsulation operation
+ */
+struct rte_crypto_ml_kem_encap_op {
+	rte_crypto_param message;
+	/**< The message (of 32 bytes in length) for randomness.*/
+
+	rte_crypto_param ek;
+	/**< The encapsulation key.*/
+
+	rte_crypto_param cipher;
+	/**<
+	 * Pointer to output data
+	 * - The computed cipher.
+	 * - Refer `rte_crypto_ml_kem_cipher_size` for size of buffer.
+	 */
+
+	rte_crypto_param sk;
+	/**<
+	 * Pointer to output data
+	 * - The computed shared secret key (32 bytes).
+	 */
+};
+
+/**
+ * PQC ML-KEM DECAP op
+ *
+ * Parameters for PQC ML-KEM decapsulation operation
+ */
+struct rte_crypto_ml_kem_decap_op {
+	rte_crypto_param cipher;
+	/**< The cipher to be decapsulated.*/
+
+	rte_crypto_param dk;
+	/**< The decapsulation key.*/
+
+	rte_crypto_param sk;
+	/**<
+	 * Pointer to output data
+	 * - The computed shared secret key (32 bytes).
+	 */
+};
+
+/**
+ * PQC ML-KEM op
+ *
+ * Parameters for PQC ML-KEM operation
+ */
+struct rte_crypto_ml_kem_op {
+	enum rte_crypto_ml_kem_op_type op;
+	union {
+		struct rte_crypto_ml_kem_keygen_op keygen;
+		struct rte_crypto_ml_kem_keyver_op keyver;
+		struct rte_crypto_ml_kem_encap_op encap;
+		struct rte_crypto_ml_kem_decap_op decap;
+	};
+};
+
+/**

lib/cryptodev/rte_crypto_asym.h struct rte_crypto_sm2_op_param { · line 897

Quoted 10 lines
lib/cryptodev/rte_crypto_asym.h +10 -0
+ * PQC ML-DSA algorithms
+ *
+ * List of ML-DSA algorithms used in PQC
+ */
+enum rte_crypto_ml_dsa_param_set {
+	RTE_CRYPTO_ML_DSA_PARAM_NONE,
+	RTE_CRYPTO_ML_DSA_PARAM_44,
+	RTE_CRYPTO_ML_DSA_PARAM_65,
+	RTE_CRYPTO_ML_DSA_PARAM_87,
+};

Can we drop PARAM?

Quoted 10 lines
lib/cryptodev/rte_crypto_asym.h +10 -0
+
+/**
+ * PQC ML-DSA op types
+ *
+ * List of ML-DSA op types in PQC
+ */
+enum rte_crypto_ml_dsa_op_type {
+	RTE_CRYPTO_ML_DSA_OP_KEYGEN,
+	RTE_CRYPTO_ML_DSA_OP_SIGN,
+	RTE_CRYPTO_ML_DSA_OP_VERIFY,

lib/cryptodev/rte_crypto_asym.h struct rte_crypto_sm2_op_param { · line 917

Quoted 10 lines
lib/cryptodev/rte_crypto_asym.h +10 -0
+	RTE_CRYPTO_ML_DSA_OP_END
+};
+
+/**
+ * PQC ML-DSA transform data
+ *
+ * Structure describing ML-DSA xform params
+ */
+struct rte_crypto_ml_dsa_xform {
+	enum rte_crypto_ml_dsa_param_set param;

Add missing doxygen comments.

Quoted 244 lines
lib/cryptodev/rte_crypto_asym.h +111 -0
+
+	bool sign_deterministic;
+	/**< The signature generated using deterministic method. */
+
+	bool sign_prehash;
+	/**< The signature generated using prehash or pure routine. */
+};
+
+/**
+ * PQC ML-DSA KEYGEN op
+ *
+ * Parameters for PQC ML-DSA key generation operation
+ */
+struct rte_crypto_ml_dsa_keygen_op {
+	rte_crypto_param seed;
+	/**< The random seed (of 32 bytes in length) to generate key pair.*/
+
+	rte_crypto_param pubkey;
+	/**<
+	 * Pointer to output data
+	 * - The computed public key.
+	 * - Refer `rte_crypto_ml_dsa_pubkey_size` for size of buffer.
+	 */
+
+	rte_crypto_param privkey;
+	/**<
+	 * Pointer to output data
+	 * - The computed secret key.
+	 * - Refer `rte_crypto_ml_dsa_privkey_size` for size of buffer.
+	 */
+};
+
+/**
+ * PQC ML-DSA SIGGEN op
+ *
+ * Parameters for PQC ML-DSA sign operation
+ */
+struct rte_crypto_ml_dsa_siggen_op {
+	rte_crypto_param message;
+	/**< The message to generate signature.*/
+
+	rte_crypto_param mu;
+	/**< The mu to generate signature.*/
+
+	rte_crypto_param privkey;
+	/**< The secret key to generate signature.*/
+
+	rte_crypto_param seed;
+	/**< The seed to generate signature.*/
+
+	rte_crypto_param ctx;
+	/**< The context key to generate signature.*/
+
+	enum rte_crypto_auth_algorithm hash;
+	/**< Hash function to generate signature. */
+
+	rte_crypto_param sign;
+	/**<
+	 * Pointer to output data
+	 * - The computed signature.
+	 * - Refer `rte_crypto_ml_dsa_sign_size` for size of buffer.
+	 */
+};
+
+/**
+ * PQC ML-DSA SIGVER op
+ *
+ * Parameters for PQC ML-DSA verify operation
+ */
+struct rte_crypto_ml_dsa_sigver_op {
+	rte_crypto_param pubkey;
+	/**< The public key to verify signature.*/
+
+	rte_crypto_param message;
+	/**< The message used to verify signature.*/
+
+	rte_crypto_param sign;
+	/**< The signature to verify.*/
+
+	rte_crypto_param mu;
+	/**< The mu used to generate signature.*/
+
+	rte_crypto_param ctx;
+	/**< The context key to generate signature.*/
+
+	enum rte_crypto_auth_algorithm hash;
+	/**< Hash function to generate signature. */
+};
+
+/**
+ * PQC ML-DSA op
+ *
+ * Parameters for PQC ML-DSA operation
+ */
+struct rte_crypto_ml_dsa_op {
+	enum rte_crypto_ml_dsa_op_type op;
+	union {
+		struct rte_crypto_ml_dsa_keygen_op keygen;
+		struct rte_crypto_ml_dsa_siggen_op siggen;
+		struct rte_crypto_ml_dsa_sigver_op sigver;
+	};
+};
+
 /**
  * Asymmetric crypto transform data
  *
@@ -751,6 +1049,12 @@ struct rte_crypto_asym_xform {
 		/**< EC xform parameters, used by elliptic curve based
 		 * operations.
 		 */
+
+		struct rte_crypto_ml_kem_xform mlkem;
+		/**< PQC ML-KEM xform parameters */
+
+		struct rte_crypto_ml_dsa_xform mldsa;
+		/**< PQC ML-DSA xform parameters */
 	};
 };
 
@@ -778,6 +1082,8 @@ struct rte_crypto_asym_op {
 		struct rte_crypto_ecpm_op_param ecpm;
 		struct rte_crypto_sm2_op_param sm2;
 		struct rte_crypto_eddsa_op_param eddsa;
+		struct rte_crypto_ml_kem_op mlkem;
+		struct rte_crypto_ml_dsa_op mldsa;
 	};
 	uint16_t flags;
 	/**<
lib/cryptodev/rte_cryptodev.c +60 -0
index bb7bab4dd5..fd40c8a64c 100644
@@ -229,6 +229,66 @@ const char *rte_crypto_asym_ke_strings[] = {
 	[RTE_CRYPTO_ASYM_KE_PUB_KEY_VERIFY] = "pub_ec_key_verify"
 };
 
+/**
+ * Public key size used in PQC ML-KEM based crypto ops.
+ */
+RTE_EXPORT_SYMBOL(rte_crypto_ml_kem_pubkey_size)
+const uint16_t rte_crypto_ml_kem_pubkey_size[] = {
+	[RTE_CRYPTO_ML_KEM_PARAM_512] = 800,
+	[RTE_CRYPTO_ML_KEM_PARAM_768] = 1184,
+	[RTE_CRYPTO_ML_KEM_PARAM_1024] = 1568,
+};
+
+/**
+ * Private key size used in PQC ML-KEM based crypto ops.
+ */
+RTE_EXPORT_SYMBOL(rte_crypto_ml_kem_privkey_size)
+const uint16_t rte_crypto_ml_kem_privkey_size[] = {
+	[RTE_CRYPTO_ML_KEM_PARAM_512] = 1632,
+	[RTE_CRYPTO_ML_KEM_PARAM_768] = 2400,
+	[RTE_CRYPTO_ML_KEM_PARAM_1024] = 3168,
+};
+
+/**
+ * Cipher size used in PQC ML-KEM based crypto ops.
+ */
+RTE_EXPORT_SYMBOL(rte_crypto_ml_kem_cipher_size)
+const uint16_t rte_crypto_ml_kem_cipher_size[] = {
+	[RTE_CRYPTO_ML_KEM_PARAM_512] = 768,
+	[RTE_CRYPTO_ML_KEM_PARAM_768] = 1088,
+	[RTE_CRYPTO_ML_KEM_PARAM_1024] = 1568,
+};
+
+/**
+ * Public key size used in PQC ML-DSA based crypto ops.
+ */
+RTE_EXPORT_SYMBOL(rte_crypto_ml_dsa_pubkey_size)
+const uint16_t rte_crypto_ml_dsa_pubkey_size[] = {
+	[RTE_CRYPTO_ML_DSA_PARAM_44] = 1312,
+	[RTE_CRYPTO_ML_DSA_PARAM_65] = 1952,
+	[RTE_CRYPTO_ML_DSA_PARAM_87] = 2592,
+};
+
+/**
+ * Private key size used in PQC ML-DSA based crypto ops.
+ */
+RTE_EXPORT_SYMBOL(rte_crypto_ml_dsa_privkey_size)
+const uint16_t rte_crypto_ml_dsa_privkey_size[] = {
+	[RTE_CRYPTO_ML_DSA_PARAM_44] = 2560,
+	[RTE_CRYPTO_ML_DSA_PARAM_65] = 4032,
+	[RTE_CRYPTO_ML_DSA_PARAM_87] = 4896,
+};
+
+/**
+ * Sign size used in PQC ML-KEM based crypto ops.
+ */
+RTE_EXPORT_SYMBOL(rte_crypto_ml_dsa_sign_size)
+const uint16_t rte_crypto_ml_dsa_sign_size[] = {
+	[RTE_CRYPTO_ML_DSA_PARAM_44] = 2420,
+	[RTE_CRYPTO_ML_DSA_PARAM_65] = 3309,
+	[RTE_CRYPTO_ML_DSA_PARAM_87] = 4627,
+};
+
 struct rte_cryptodev_sym_session_pool_private_data {
 	uint16_t sess_data_sz;
 	/**< driver session data size */
lib/cryptodev/rte_cryptodev.h +13 -2
index eaf0e50d37..37a6a5e49b 100644
@@ -167,10 +167,13 @@ struct rte_cryptodev_asymmetric_xform_capability {
 	uint32_t op_types;
 	/**<
 	 * Bitmask for supported rte_crypto_asym_op_type or
+	 * rte_crypto_ml_kem_op_type or rte_crypto_ml_dsa_op_type or
 	 * rte_crypto_asym_ke_type. Which enum is used is determined
 	 * by the rte_crypto_asym_xform_type. For key exchange algorithms
-	 * like Diffie-Hellman it is rte_crypto_asym_ke_type, for others
-	 * it is rte_crypto_asym_op_type.
+	 * like Diffie-Hellman it is rte_crypto_asym_ke_type,
+	 * for ML-KEM algorithms it is rte_crypto_ml_kem_op_type,
+	 * for ML-DSA algorithms it is rte_crypto_ml_dsa_op_type,
+	 * or others it is rte_crypto_asym_op_type.
 	 */
 
 	__extension__
@@ -188,6 +191,12 @@ struct rte_cryptodev_asymmetric_xform_capability {
 
 		uint32_t op_capa[RTE_CRYPTO_ASYM_OP_LIST_END];
 		/**< Operation specific capabilities. */
+
+		uint32_t mlkem_capa[RTE_CRYPTO_ML_KEM_OP_END];
+		/**< Bitmask of supported ML-KEM parameter sets. */
+
+		uint32_t mldsa_capa[RTE_CRYPTO_ML_DSA_OP_END];
+		/**< Bitmask of supported ML-DSA parameter sets. */
 	};
 
 	uint64_t hash_algos;
@@ -577,6 +586,8 @@ rte_cryptodev_asym_get_xform_string(enum
 rte_crypto_asym_xform_type xform_enum);
 /**< Support inner checksum computation/verification */
 #define RTE_CRYPTODEV_FF_SECURITY_RX_INJECT		(1ULL << 28)
 /**< Support Rx injection after security processing */
+#define RTE_CRYPTODEV_FF_MLDSA_SIGN_PREHASH		(1ULL << 29)
+/**< Support Pre Hash ML-DSA Signature Generation */
 
 /**

* Get the name of a crypto device feature flag
--
2.37.1

#13 lore raw

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

In reply to Gowrishankar Muthukrishnan

Add ML-KEM and ML-DSA support.

---
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(+)
doc/guides/cryptodevs/features/openssl.ini +2 -0
index f0074a46f8..df6e7de316 100644
@@ -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.
drivers/crypto/openssl/openssl_pmd_private.h +16 -0
index 4a6a088870..7f87840b84 100644
@@ -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_ */
drivers/crypto/openssl/rte_openssl_pmd.c +870 -0

888 lines not on this page · raw message

drivers/crypto/openssl/rte_openssl_pmd_ops.c +133 -0

155 lines not on this page · raw message

Signature · 1 line
2.37.1
#14 lore raw

PATCH v3 3/3 app/test: add ML crypto test vectors

In reply to Gowrishankar Muthukrishnan

Add ML-KEM and ML-DSA test vectors.

---
 app/test/test_cryptodev_asym.c                |  856 ++++++++
 app/test/test_cryptodev_ml_dsa_test_vectors.h | 1856 +++++++++++++++++
 app/test/test_cryptodev_ml_kem_test_vectors.h |  873 ++++++++
 3 files changed, 3585 insertions(+)
 create mode 100644 app/test/test_cryptodev_ml_dsa_test_vectors.h
 create mode 100644 app/test/test_cryptodev_ml_kem_test_vectors.h
app/test/test_cryptodev_asym.c +856 -0
index 20afb5e98b..942a23e3b3 100644
@@ -24,6 +24,8 @@
 #include "test_cryptodev_mod_test_vectors.h"
 #include "test_cryptodev_rsa_test_vectors.h"
 #include "test_cryptodev_sm2_test_vectors.h"
+#include "test_cryptodev_ml_kem_test_vectors.h"
+#include "test_cryptodev_ml_dsa_test_vectors.h"
 #include "test_cryptodev_asym_util.h"
 #include "test.h"
 
@@ -3629,6 +3631,33 @@ static int send_one(void)
 	return TEST_SUCCESS;
 }
 
+static int send_one_no_status_check(void)
+{
+	int ticks = 0;
+
+	if (rte_cryptodev_enqueue_burst(params->valid_devs[0], 0,
+			&self->op, 1) != 1) {
+		RTE_LOG(ERR, USER1,
+			"line %u FAILED: Error sending packet for operation on device %d",
+			__LINE__, params->valid_devs[0]);
+		return TEST_FAILED;
+	}
+	while (rte_cryptodev_dequeue_burst(params->valid_devs[0], 0,
+			&self->result_op, 1) == 0) {
+		rte_delay_ms(1);
+		ticks++;
+		if (ticks >= DEQ_TIMEOUT) {
+			RTE_LOG(ERR, USER1,
+				"line %u FAILED: Cannot dequeue the crypto op on device %d",
+				__LINE__, params->valid_devs[0]);
+			return TEST_FAILED;
+		}
+	}
+	TEST_ASSERT_NOT_NULL(self->result_op,
+		"Failed to process asym crypto op");
+	return TEST_SUCCESS;
+}
+
 static int
 modular_cmpeq(const uint8_t *a, size_t a_len, const uint8_t *b, size_t b_len)
 {
@@ -3735,6 +3764,827 @@ modular_multiplicative_inverse(const void *test_data)
 	return TEST_SUCCESS;
 }
 
+static int
+mlkem_keygen(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t ek[TEST_DATA_SIZE] = {0};
+	uint8_t dk[TEST_DATA_SIZE] = {0};
+
+	xform.mlkem.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_KEYGEN;
+	self->op->asym->mlkem.keygen.d.data = vector->d.data;
+	self->op->asym->mlkem.keygen.d.length = vector->d.length;
+	self->op->asym->mlkem.keygen.z.data = vector->z.data;
+	self->op->asym->mlkem.keygen.z.length = vector->z.length;
+	self->op->asym->mlkem.keygen.dk.data = dk;
+	self->op->asym->mlkem.keygen.dk.length = 0;
+	self->op->asym->mlkem.keygen.ek.data = ek;
+	self->op->asym->mlkem.keygen.ek.length = 0;
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM KeyGen)");
+	debug_hexdump(stdout, "Decapsulation key",
+		self->result_op->asym->mlkem.keygen.dk.data,
+		self->result_op->asym->mlkem.keygen.dk.length);
+	debug_hexdump(stdout, "Encapsulation key",
+		self->result_op->asym->mlkem.keygen.ek.data,
+		self->result_op->asym->mlkem.keygen.ek.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.keygen.dk.length,
+		rte_crypto_ml_kem_privkey_size[vector->param],
+		"Incorrect Decapsulation key length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.keygen.ek.length,
+		rte_crypto_ml_kem_pubkey_size[vector->param],
+		"Incorrect Encapsulation key length\n");
+
+	/* If the seed is all zero, keys are deterministic */
+	if (memcmp(vector->d.data, (uint8_t [32]) {0},
+			vector->d.length) == 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->dk.data,
+			self->result_op->asym->mlkem.keygen.dk.data,
+			self->result_op->asym->mlkem.keygen.dk.length,
+			"Incorrect Decapsulation key\n");
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->ek.data,
+			self->result_op->asym->mlkem.keygen.ek.data,
+			self->result_op->asym->mlkem.keygen.ek.length,
+			"Incorrect Encapsulation key\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic keygen test passed\n");
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mlkem_encap(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t cipher[TEST_DATA_SIZE] = {0};
+	uint8_t skcopy[TEST_DATA_SIZE] = {0};
+	uint8_t sk[TEST_DATA_SIZE] = {0};
+	size_t cipher_len;
+
+	xform.mlkem.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Encapsulate */
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_ENCAP;
+	self->op->asym->mlkem.encap.message.data = vector->message.data;
+	self->op->asym->mlkem.encap.message.length = vector->message.length;
+	self->op->asym->mlkem.encap.ek.data = vector->ek.data;
+	self->op->asym->mlkem.encap.ek.length = vector->ek.length;
+	self->op->asym->mlkem.encap.cipher.data = cipher;
+	self->op->asym->mlkem.encap.cipher.length =
+		rte_crypto_ml_kem_cipher_size[vector->param];
+	self->op->asym->mlkem.encap.sk.data = sk;
+	self->op->asym->mlkem.encap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Encap)");
+	debug_hexdump(stdout, "Cipher",
+		self->result_op->asym->mlkem.encap.cipher.data,
+		self->result_op->asym->mlkem.encap.cipher.length);
+	debug_hexdump(stdout, "Shared secret from encap",
+		self->result_op->asym->mlkem.encap.sk.data,
+		self->result_op->asym->mlkem.encap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.encap.cipher.length,
+		rte_crypto_ml_kem_cipher_size[vector->param],
+		"Incorrect Cipher length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.encap.sk.length, 32,
+		"Incorrect Shared key length\n");
+
+	/* If random message is set, cipher and shared secret are deterministic */
+	if (vector->message.length != 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->cipher.data,
+			self->result_op->asym->mlkem.encap.cipher.data,
+			self->result_op->asym->mlkem.encap.cipher.length,
+			"Incorrect Cipher\n");
+
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->sk.data,
+			self->result_op->asym->mlkem.encap.sk.data,
+			self->result_op->asym->mlkem.encap.sk.length,
+			"Incorrect Shared secret\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic encap test passed\n");
+	}
+
+	/* Decapsulate and verify */
+	cipher_len = self->result_op->asym->mlkem.encap.cipher.length;
+	memcpy(skcopy, self->result_op->asym->mlkem.encap.sk.data,
+		self->result_op->asym->mlkem.encap.sk.length);
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from decap",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(self->result_op->asym->mlkem.decap.sk.data,
+		skcopy, self->result_op->asym->mlkem.decap.sk.length,
+		"Incorrect Shared secret\n");
+
+	/* Negative test */
+	cipher[0] ^= 0x01;
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from negative test",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+
+	if (!memcmp(self->result_op->asym->mlkem.decap.sk.data, skcopy, 32)) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mlkem_decap(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t cipher[TEST_DATA_SIZE] = {0};
+	uint8_t sk[TEST_DATA_SIZE] = {0};
+	size_t cipher_len;
+
+	xform.mlkem.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Decapsulate and verify */
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = vector->cipher.data;
+	self->op->asym->mlkem.decap.cipher.length = vector->cipher.length;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from decap",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(self->result_op->asym->mlkem.decap.sk.data,
+		vector->sk.data, vector->sk.length,
+		"Incorrect Shared secret\n");
+
+	/* Negative test */
+	memcpy(cipher, vector->cipher.data, vector->cipher.length);
+	cipher_len = vector->cipher.length;
+	cipher[0] ^= 0x01;
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from negative test",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+
+	if (!memcmp(self->result_op->asym->mlkem.decap.sk.data,
+		vector->sk.data, vector->sk.length)) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_keygen(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t privkey[TEST_DATA_SIZE] = {0};
+	uint8_t pubkey[TEST_DATA_SIZE] = {0};
+
+	xform.mldsa.param = vector->param;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_KEYGEN;
+	self->op->asym->mldsa.keygen.seed.data = vector->seed.data;
+	self->op->asym->mldsa.keygen.seed.length = vector->seed.length;
+	self->op->asym->mldsa.keygen.privkey.data = privkey;
+	self->op->asym->mldsa.keygen.privkey.length = 0;
+	self->op->asym->mldsa.keygen.pubkey.data = pubkey;
+	self->op->asym->mldsa.keygen.pubkey.length = 0;
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA KeyGen)");
+
+	debug_hexdump(stdout, "Private key",
+		self->result_op->asym->mldsa.keygen.privkey.data,
+		self->result_op->asym->mldsa.keygen.privkey.length);
+	debug_hexdump(stdout, "Public key",
+		self->result_op->asym->mldsa.keygen.pubkey.data,
+		self->result_op->asym->mldsa.keygen.pubkey.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.keygen.privkey.length,
+		rte_crypto_ml_dsa_privkey_size[vector->param],
+		"Incorrect Private key length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.keygen.pubkey.length,
+		rte_crypto_ml_dsa_pubkey_size[vector->param],
+		"Incorrect Public key length\n");
+
+	/* If the seed is all zero, keys are deterministic */
+	if (memcmp(vector->seed.data, (uint8_t [32]) {0},
+			vector->seed.length) == 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->privkey.data,
+			self->result_op->asym->mldsa.keygen.privkey.data,
+			self->result_op->asym->mldsa.keygen.privkey.length,
+			"Incorrect Private key\n");
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->pubkey.data,
+			self->result_op->asym->mldsa.keygen.pubkey.data,
+			self->result_op->asym->mldsa.keygen.pubkey.length,
+			"Incorrect Public key\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic keygen test passed\n");
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_sign(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	struct rte_cryptodev_info dev_info;
+	uint8_t sign[TEST_DATA_SIZE] = {0};
+	size_t sign_len;
+
+	xform.mldsa.param = vector->param;
+	xform.mldsa.sign_deterministic = vector->sign_deterministic;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+
+	rte_cryptodev_info_get(dev_id, &dev_info);
+
+	/* Check if prehash is supported */
+	if (vector->hash) {
+		if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MLDSA_SIGN_PREHASH)) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support prehash in ML-DSA signature generation. Test skipped\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Sign */
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_SIGN;
+	self->op->asym->mldsa.siggen.seed.data = vector->seed.data;
+	self->op->asym->mldsa.siggen.seed.length = vector->seed.length;
+	self->op->asym->mldsa.siggen.privkey.data = vector->privkey.data;
+	self->op->asym->mldsa.siggen.privkey.length = vector->privkey.length;
+	self->op->asym->mldsa.siggen.message.data = vector->message.data;
+	self->op->asym->mldsa.siggen.message.length = vector->message.length;
+	self->op->asym->mldsa.siggen.ctx.data = vector->context.data;
+	self->op->asym->mldsa.siggen.ctx.length = vector->context.length;
+	self->op->asym->mldsa.siggen.mu.data = vector->mu.data;
+	self->op->asym->mldsa.siggen.mu.length = vector->mu.length;
+	self->op->asym->mldsa.siggen.sign.data = sign;
+	self->op->asym->mldsa.siggen.sign.length =
+		rte_crypto_ml_dsa_sign_size[vector->param];
+	self->op->asym->mldsa.siggen.hash = vector->hash;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Sign)");
+
+	debug_hexdump(stdout, "Signature",
+		self->result_op->asym->mldsa.siggen.sign.data,
+		self->result_op->asym->mldsa.siggen.sign.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.siggen.sign.length,
+		rte_crypto_ml_dsa_sign_size[vector->param],
+		"Incorrect Signature length\n");
+
+	/* Verify signature if it is deterministic */
+	if (vector->sign_deterministic) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->sign.data,
+			self->result_op->asym->mldsa.siggen.sign.data,
+			self->result_op->asym->mldsa.siggen.sign.length,
+			"Incorrect Signature\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic signature test passed\n");
+	}
+
+	/* Verify the signature */
+	sign_len = self->result_op->asym->mldsa.siggen.sign.length;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	TEST_ASSERT_EQUAL(self->result_op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+		"Failed to verify the signature");
+
+	/* Negative test */
+	sign[0] ^= 0x01;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one_no_status_check(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	if (self->result_op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_verify(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t sign[TEST_DATA_SIZE] = {0};
+	size_t sign_len;
+
+	xform.mldsa.param = vector->param;
+	xform.mldsa.sign_deterministic = vector->sign_deterministic;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Verify the signature */
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = vector->sign.data;
+	self->op->asym->mldsa.sigver.sign.length = vector->sign.length;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	TEST_ASSERT_EQUAL(self->result_op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+		"Failed to verify the signature");
+
+	/* Negative test */
+	memcpy(sign, vector->sign.data, vector->sign.length);
+	sign_len = vector->sign.length;
+	sign[0] ^= 0x01;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one_no_status_check(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	if (self->result_op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+test_mlkem_keygen(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_KEYGEN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM keygen operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_keygen_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_KEYGEN] &
+			(1 << mlkem_keygen_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_keygen_test_vectors[i].param,
+				mlkem_keygen_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_keygen_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_keygen(&mlkem_keygen_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_keygen_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_keygen_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mlkem_encap(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_ENCAP))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM encap operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_encap_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_ENCAP] &
+			(1 << mlkem_encap_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_encap_test_vectors[i].param,
+				mlkem_encap_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_encap_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_encap(&mlkem_encap_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_encap_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_encap_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mlkem_decap(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_DECAP))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM decap operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_decap_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_DECAP] &
+			(1 << mlkem_decap_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_decap_test_vectors[i].param,
+				mlkem_decap_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_decap_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_decap(&mlkem_decap_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_decap_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_decap_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_keygen(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_KEYGEN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA keygen operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_keygen_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_KEYGEN] &
+			(1 << mldsa_keygen_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_keygen_test_vectors[i].param,
+				mldsa_keygen_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_keygen_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_keygen(&mldsa_keygen_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_keygen_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_keygen_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_sign(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_SIGN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA sign operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_sign_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_SIGN] &
+			(1 << mldsa_sign_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_sign_test_vectors[i].param,
+				mldsa_sign_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_sign_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_sign(&mldsa_sign_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_sign_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_sign_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_verify(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_VERIFY))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA verify operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_verify_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_VERIFY] &
+			(1 << mldsa_verify_test_vectors[i].param))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_verify_test_vectors[i].param,
+				mldsa_verify_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_verify_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_verify(&mldsa_verify_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_verify_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_verify_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
 #define SET_RSA_PARAM(arg, vector, coef) \
 	uint8_t coef[TEST_DATA_SIZE] = { }; \
 	memcpy(coef, vector->coef.data, vector->coef.len); \
@@ -3987,6 +4837,12 @@ static struct unit_test_suite cryptodev_openssl_asym_testsuite  = {
 			ut_setup_asym, ut_teardown_asym,
 			modular_exponentiation, &modex_group_test_cases[7]),
 		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_eddsa_sign_verify_all_curve),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_keygen),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_encap),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_decap),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_keygen),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_sign),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_verify),
 		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
 };
app/test/test_cryptodev_ml_dsa_test_vectors.h new file +1856 -0

1,856 lines not on this page · raw message

app/test/test_cryptodev_ml_kem_test_vectors.h new file +873 -0

264 lines not on this page · raw message

The rest of this diff is not shown. View the raw message.

Signature · 1 line
2.37.1

Part of the diff is not shown here. View the raw message.

#15 lore raw

v4 cover cryptodev: support PQC ML algorithms

In reply to Gowrishankar Muthukrishnan

This series added support for PQC ML-KEM and ML-DSA algorithms.

v4:
- Enum and variable name changes.

Gowrishankar Muthukrishnan (3):
cryptodev: support PQC ML algorithms
crypto/openssl: add ML crypto support
app/test: add ML crypto test vectors

 app/test/test_cryptodev_asym.c                |  856 ++++++++
 app/test/test_cryptodev_ml_dsa_test_vectors.h | 1856 +++++++++++++++++
 app/test/test_cryptodev_ml_kem_test_vectors.h |  873 ++++++++
 doc/guides/cryptodevs/features/default.ini    |    2 +
 doc/guides/cryptodevs/features/openssl.ini    |    2 +
 doc/guides/prog_guide/cryptodev_lib.rst       |    3 +-
 doc/guides/rel_notes/release_25_11.rst        |   11 +
 drivers/crypto/openssl/openssl_pmd_private.h  |   17 +
 drivers/crypto/openssl/rte_openssl_pmd.c      |  870 ++++++++
 drivers/crypto/openssl/rte_openssl_pmd_ops.c  |  133 ++
 lib/cryptodev/rte_crypto_asym.h               |  308 +++
 lib/cryptodev/rte_cryptodev.c                 |   60 +
 lib/cryptodev/rte_cryptodev.h                 |   15 +-
 13 files changed, 5003 insertions(+), 3 deletions(-)
 create mode 100644 app/test/test_cryptodev_ml_dsa_test_vectors.h
 create mode 100644 app/test/test_cryptodev_ml_kem_test_vectors.h
Signature · 1 line
2.37.1
#16 lore raw

PATCH v4 1/3 cryptodev: support PQC ML algorithms

Add support for PQC ML-KEM and ML-DSA algorithms.

---
v4:
- enum and var name changes

---
 doc/guides/cryptodevs/features/default.ini |   2 +
 doc/guides/prog_guide/cryptodev_lib.rst    |   3 +-
 doc/guides/rel_notes/release_25_11.rst     |   7 +
 lib/cryptodev/rte_crypto_asym.h            | 308 +++++++++++++++++++++
 lib/cryptodev/rte_cryptodev.c              |  60 ++++
 lib/cryptodev/rte_cryptodev.h              |  15 +-
 6 files changed, 392 insertions(+), 3 deletions(-)
doc/guides/cryptodevs/features/default.ini +2 -0
index 116ffce249..64198f013a 100644
@@ -134,6 +134,8 @@ ECPM                    =
 ECDH                    =
 SM2                     =
 EdDSA                   =
+ML-DSA                  =
+ML-KEM                  =
 
 ;
 ; Supported Operating systems of a default crypto driver.
doc/guides/prog_guide/cryptodev_lib.rst +2 -1
index b54efcb74e..f0ee44eb54 100644
@@ -928,7 +928,8 @@ Asymmetric Cryptography
 The cryptodev library currently provides support for the following asymmetric
 Crypto operations; RSA, Modular exponentiation and inversion, Diffie-Hellman and
 Elliptic Curve Diffie-Hellman public and/or private key generation and shared
-secret compute, DSA and EdDSA signature generation and verification.
+secret compute, DSA and EdDSA signature generation and verification,
+PQC ML-KEM and ML-DSA algorithms.
 
 Session and Session Management
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
doc/guides/rel_notes/release_25_11.rst +7 -0
index c3b94e1896..62b8767631 100644
@@ -76,6 +76,10 @@ New Features
   * Added multi-process per port.
   * Optimized code.
 
+* **Added PQC ML-KEM and ML-DSA support.**
+
+  * Added PQC ML-KEM support with reference to FIPS203.
+  * Added PQC ML-DSA support with reference to FIPS204.
 
 Removed Items
 -------------
@@ -138,6 +142,9 @@ ABI Changes
 * stack: The structure ``rte_stack_lf_head`` alignment has been updated to 16 bytes
   to avoid unaligned accesses.
 
+* cryptodev: The enum ``rte_crypto_asym_xform_type``, struct ``rte_crypto_asym_xform``
+  and struct ``rte_crypto_asym_op`` are updated to include new values to support
+  ML-KEM and ML-DSA.
 
 Known Issues
 ------------
lib/cryptodev/rte_crypto_asym.h +308 -0

338 lines not on this page · raw message

lib/cryptodev/rte_cryptodev.c +60 -0

66 lines not on this page · raw message

lib/cryptodev/rte_cryptodev.h +13 -2
index eaf0e50d37..37a6a5e49b 100644
@@ -167,10 +167,13 @@ struct rte_cryptodev_asymmetric_xform_capability {
 	uint32_t op_types;
 	/**<
 	 * Bitmask for supported rte_crypto_asym_op_type or
+	 * rte_crypto_ml_kem_op_type or rte_crypto_ml_dsa_op_type or
 	 * rte_crypto_asym_ke_type. Which enum is used is determined
 	 * by the rte_crypto_asym_xform_type. For key exchange algorithms
-	 * like Diffie-Hellman it is rte_crypto_asym_ke_type, for others
-	 * it is rte_crypto_asym_op_type.
+	 * like Diffie-Hellman it is rte_crypto_asym_ke_type,
+	 * for ML-KEM algorithms it is rte_crypto_ml_kem_op_type,
+	 * for ML-DSA algorithms it is rte_crypto_ml_dsa_op_type,
+	 * or others it is rte_crypto_asym_op_type.
 	 */
 
 	__extension__
@@ -188,6 +191,12 @@ struct rte_cryptodev_asymmetric_xform_capability {
 
 		uint32_t op_capa[RTE_CRYPTO_ASYM_OP_LIST_END];
 		/**< Operation specific capabilities. */
+
+		uint32_t mlkem_capa[RTE_CRYPTO_ML_KEM_OP_END];
+		/**< Bitmask of supported ML-KEM parameter sets. */
+
+		uint32_t mldsa_capa[RTE_CRYPTO_ML_DSA_OP_END];
+		/**< Bitmask of supported ML-DSA parameter sets. */
 	};
 
 	uint64_t hash_algos;
@@ -577,6 +586,8 @@ rte_cryptodev_asym_get_xform_string(enum rte_crypto_asym_xform_type xform_enum);
 /**< Support inner checksum computation/verification */
 #define RTE_CRYPTODEV_FF_SECURITY_RX_INJECT		(1ULL << 28)
 /**< Support Rx injection after security processing */
+#define RTE_CRYPTODEV_FF_MLDSA_SIGN_PREHASH		(1ULL << 29)
+/**< Support Pre Hash ML-DSA Signature Generation */
 
 /**
  * Get the name of a crypto device feature flag
Signature · 1 line
2.37.1
Applied
#17 lore raw
Quoted 11 lines

-----Original Message-----
From: Gowrishankar Muthukrishnan <[email protected]>
Sent: Saturday, October 4, 2025 8:53 AM
To: [email protected]; Akhil Goyal <[email protected]>; Fan Zhang <[email protected]>; Kai Ji <[email protected]>
Cc: Anoob Joseph <[email protected]>; Gowrishankar Muthukrishnan <[email protected]>
Subject: [PATCH v4 1/3] cryptodev: support PQC ML algorithms

Quoted 6 lines

Add support for PQC ML-KEM and ML-DSA algorithms.

---
v4:
- enum and var name changes

Series Acked-by: Akhil Goyal <[email protected]>

Applied to dpdk-next-crypto

#18 lore raw

PATCH v4 2/3 crypto/openssl: add ML crypto support

In reply to Gowrishankar Muthukrishnan

Add ML-KEM and ML-DSA support.

---
v4:
- var name changes

---
 doc/guides/cryptodevs/features/openssl.ini   |   2 +
 doc/guides/rel_notes/release_25_11.rst       |   4 +
 drivers/crypto/openssl/openssl_pmd_private.h |  17 +
 drivers/crypto/openssl/rte_openssl_pmd.c     | 870 +++++++++++++++++++
 drivers/crypto/openssl/rte_openssl_pmd_ops.c | 133 +++
 5 files changed, 1026 insertions(+)
doc/guides/cryptodevs/features/openssl.ini +2 -0
index f0074a46f8..df6e7de316 100644
@@ -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.
doc/guides/rel_notes/release_25_11.rst +4 -0
index 62b8767631..9d47f762d7 100644
@@ -81,6 +81,10 @@ New Features
   * Added PQC ML-KEM support with reference to FIPS203.
   * Added PQC ML-DSA support with reference to FIPS204.
 
+* **Updated openssl crypto driver.**
+
+  * Added support for PQC ML-KEM and ML-DSA algorithms.
+
 Removed Items
 -------------
 
drivers/crypto/openssl/openssl_pmd_private.h +17 -0
index 4a6a088870..fe89e522e1 100644
@@ -249,6 +249,20 @@ struct __rte_cache_aligned openssl_asym_session {
 			OSSL_PARAM * params;
 #endif
 		} eddsa;
+		struct {
+			uint8_t type;
+#if (OPENSSL_VERSION_NUMBER >= 0x30500000L)
+			EVP_PKEY_CTX * pctx;
+#endif
+		} ml_kem;
+		struct {
+			uint8_t type;
+			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,7 @@ openssl_reset_session(struct openssl_session *sess);
 /** device specific operations function pointer structure */
 extern struct rte_cryptodev_ops *rte_openssl_pmd_ops;
 
+/** ML parameter type names */
+extern const char *ml_kem_type_names[];
+extern const char *ml_dsa_type_names[];
 #endif /* _OPENSSL_PMD_PRIVATE_H_ */
drivers/crypto/openssl/rte_openssl_pmd.c +870 -0

888 lines not on this page · raw message

drivers/crypto/openssl/rte_openssl_pmd_ops.c +133 -0

155 lines not on this page · raw message

Signature · 1 line
2.37.1
#19 lore raw

PATCH v4 3/3 app/test: add ML crypto test vectors

In reply to Gowrishankar Muthukrishnan

Add ML-KEM and ML-DSA test vectors.

---
v4:
- var name changes.

---
 app/test/test_cryptodev_asym.c                |  856 ++++++++
 app/test/test_cryptodev_ml_dsa_test_vectors.h | 1856 +++++++++++++++++
 app/test/test_cryptodev_ml_kem_test_vectors.h |  873 ++++++++
 3 files changed, 3585 insertions(+)
 create mode 100644 app/test/test_cryptodev_ml_dsa_test_vectors.h
 create mode 100644 app/test/test_cryptodev_ml_kem_test_vectors.h
app/test/test_cryptodev_asym.c +856 -0
index 20afb5e98b..5e5ff2f308 100644
@@ -24,6 +24,8 @@
 #include "test_cryptodev_mod_test_vectors.h"
 #include "test_cryptodev_rsa_test_vectors.h"
 #include "test_cryptodev_sm2_test_vectors.h"
+#include "test_cryptodev_ml_kem_test_vectors.h"
+#include "test_cryptodev_ml_dsa_test_vectors.h"
 #include "test_cryptodev_asym_util.h"
 #include "test.h"
 
@@ -3629,6 +3631,33 @@ static int send_one(void)
 	return TEST_SUCCESS;
 }
 
+static int send_one_no_status_check(void)
+{
+	int ticks = 0;
+
+	if (rte_cryptodev_enqueue_burst(params->valid_devs[0], 0,
+			&self->op, 1) != 1) {
+		RTE_LOG(ERR, USER1,
+			"line %u FAILED: Error sending packet for operation on device %d",
+			__LINE__, params->valid_devs[0]);
+		return TEST_FAILED;
+	}
+	while (rte_cryptodev_dequeue_burst(params->valid_devs[0], 0,
+			&self->result_op, 1) == 0) {
+		rte_delay_ms(1);
+		ticks++;
+		if (ticks >= DEQ_TIMEOUT) {
+			RTE_LOG(ERR, USER1,
+				"line %u FAILED: Cannot dequeue the crypto op on device %d",
+				__LINE__, params->valid_devs[0]);
+			return TEST_FAILED;
+		}
+	}
+	TEST_ASSERT_NOT_NULL(self->result_op,
+		"Failed to process asym crypto op");
+	return TEST_SUCCESS;
+}
+
 static int
 modular_cmpeq(const uint8_t *a, size_t a_len, const uint8_t *b, size_t b_len)
 {
@@ -3735,6 +3764,827 @@ modular_multiplicative_inverse(const void *test_data)
 	return TEST_SUCCESS;
 }
 
+static int
+mlkem_keygen(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t ek[TEST_DATA_SIZE] = {0};
+	uint8_t dk[TEST_DATA_SIZE] = {0};
+
+	xform.mlkem.type = vector->type;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_KEYGEN;
+	self->op->asym->mlkem.keygen.d.data = vector->d.data;
+	self->op->asym->mlkem.keygen.d.length = vector->d.length;
+	self->op->asym->mlkem.keygen.z.data = vector->z.data;
+	self->op->asym->mlkem.keygen.z.length = vector->z.length;
+	self->op->asym->mlkem.keygen.dk.data = dk;
+	self->op->asym->mlkem.keygen.dk.length = 0;
+	self->op->asym->mlkem.keygen.ek.data = ek;
+	self->op->asym->mlkem.keygen.ek.length = 0;
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM KeyGen)");
+	debug_hexdump(stdout, "Decapsulation key",
+		self->result_op->asym->mlkem.keygen.dk.data,
+		self->result_op->asym->mlkem.keygen.dk.length);
+	debug_hexdump(stdout, "Encapsulation key",
+		self->result_op->asym->mlkem.keygen.ek.data,
+		self->result_op->asym->mlkem.keygen.ek.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.keygen.dk.length,
+		rte_crypto_ml_kem_privkey_size[vector->type],
+		"Incorrect Decapsulation key length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.keygen.ek.length,
+		rte_crypto_ml_kem_pubkey_size[vector->type],
+		"Incorrect Encapsulation key length\n");
+
+	/* If the seed is all zero, keys are deterministic */
+	if (memcmp(vector->d.data, (uint8_t [32]) {0},
+			vector->d.length) == 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->dk.data,
+			self->result_op->asym->mlkem.keygen.dk.data,
+			self->result_op->asym->mlkem.keygen.dk.length,
+			"Incorrect Decapsulation key\n");
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->ek.data,
+			self->result_op->asym->mlkem.keygen.ek.data,
+			self->result_op->asym->mlkem.keygen.ek.length,
+			"Incorrect Encapsulation key\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic keygen test passed\n");
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mlkem_encap(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t cipher[TEST_DATA_SIZE] = {0};
+	uint8_t skcopy[TEST_DATA_SIZE] = {0};
+	uint8_t sk[TEST_DATA_SIZE] = {0};
+	size_t cipher_len;
+
+	xform.mlkem.type = vector->type;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Encapsulate */
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_ENCAP;
+	self->op->asym->mlkem.encap.message.data = vector->message.data;
+	self->op->asym->mlkem.encap.message.length = vector->message.length;
+	self->op->asym->mlkem.encap.ek.data = vector->ek.data;
+	self->op->asym->mlkem.encap.ek.length = vector->ek.length;
+	self->op->asym->mlkem.encap.cipher.data = cipher;
+	self->op->asym->mlkem.encap.cipher.length =
+		rte_crypto_ml_kem_cipher_size[vector->type];
+	self->op->asym->mlkem.encap.sk.data = sk;
+	self->op->asym->mlkem.encap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Encap)");
+	debug_hexdump(stdout, "Cipher",
+		self->result_op->asym->mlkem.encap.cipher.data,
+		self->result_op->asym->mlkem.encap.cipher.length);
+	debug_hexdump(stdout, "Shared secret from encap",
+		self->result_op->asym->mlkem.encap.sk.data,
+		self->result_op->asym->mlkem.encap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.encap.cipher.length,
+		rte_crypto_ml_kem_cipher_size[vector->type],
+		"Incorrect Cipher length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.encap.sk.length, 32,
+		"Incorrect Shared key length\n");
+
+	/* If random message is set, cipher and shared secret are deterministic */
+	if (vector->message.length != 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->cipher.data,
+			self->result_op->asym->mlkem.encap.cipher.data,
+			self->result_op->asym->mlkem.encap.cipher.length,
+			"Incorrect Cipher\n");
+
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->sk.data,
+			self->result_op->asym->mlkem.encap.sk.data,
+			self->result_op->asym->mlkem.encap.sk.length,
+			"Incorrect Shared secret\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic encap test passed\n");
+	}
+
+	/* Decapsulate and verify */
+	cipher_len = self->result_op->asym->mlkem.encap.cipher.length;
+	memcpy(skcopy, self->result_op->asym->mlkem.encap.sk.data,
+		self->result_op->asym->mlkem.encap.sk.length);
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from decap",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(self->result_op->asym->mlkem.decap.sk.data,
+		skcopy, self->result_op->asym->mlkem.decap.sk.length,
+		"Incorrect Shared secret\n");
+
+	/* Negative test */
+	cipher[0] ^= 0x01;
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from negative test",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+
+	if (!memcmp(self->result_op->asym->mlkem.decap.sk.data, skcopy, 32)) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mlkem_decap(const void *test_data)
+{
+	const struct crypto_testsuite_mlkem_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t cipher[TEST_DATA_SIZE] = {0};
+	uint8_t sk[TEST_DATA_SIZE] = {0};
+	size_t cipher_len;
+
+	xform.mlkem.type = vector->type;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Decapsulate and verify */
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = vector->cipher.data;
+	self->op->asym->mlkem.decap.cipher.length = vector->cipher.length;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from decap",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(self->result_op->asym->mlkem.decap.sk.data,
+		vector->sk.data, vector->sk.length,
+		"Incorrect Shared secret\n");
+
+	/* Negative test */
+	memcpy(cipher, vector->cipher.data, vector->cipher.length);
+	cipher_len = vector->cipher.length;
+	cipher[0] ^= 0x01;
+	memset(sk, 0, sizeof(sk));
+
+	self->op->asym->mlkem.op = RTE_CRYPTO_ML_KEM_OP_DECAP;
+	self->op->asym->mlkem.decap.dk.data = vector->dk.data;
+	self->op->asym->mlkem.decap.dk.length = vector->dk.length;
+	self->op->asym->mlkem.decap.cipher.data = cipher;
+	self->op->asym->mlkem.decap.cipher.length = cipher_len;
+	self->op->asym->mlkem.decap.sk.data = sk;
+	self->op->asym->mlkem.decap.sk.length = 32;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-KEM Decap)");
+
+	debug_hexdump(stdout, "Shared secret from negative test",
+		self->result_op->asym->mlkem.decap.sk.data,
+		self->result_op->asym->mlkem.decap.sk.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mlkem.decap.sk.length, 32,
+		"Incorrect Shared secret length\n");
+
+	if (!memcmp(self->result_op->asym->mlkem.decap.sk.data,
+		vector->sk.data, vector->sk.length)) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_keygen(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t privkey[TEST_DATA_SIZE] = {0};
+	uint8_t pubkey[TEST_DATA_SIZE] = {0};
+
+	xform.mldsa.type = vector->type;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_KEYGEN;
+	self->op->asym->mldsa.keygen.seed.data = vector->seed.data;
+	self->op->asym->mldsa.keygen.seed.length = vector->seed.length;
+	self->op->asym->mldsa.keygen.privkey.data = privkey;
+	self->op->asym->mldsa.keygen.privkey.length = 0;
+	self->op->asym->mldsa.keygen.pubkey.data = pubkey;
+	self->op->asym->mldsa.keygen.pubkey.length = 0;
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA KeyGen)");
+
+	debug_hexdump(stdout, "Private key",
+		self->result_op->asym->mldsa.keygen.privkey.data,
+		self->result_op->asym->mldsa.keygen.privkey.length);
+	debug_hexdump(stdout, "Public key",
+		self->result_op->asym->mldsa.keygen.pubkey.data,
+		self->result_op->asym->mldsa.keygen.pubkey.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.keygen.privkey.length,
+		rte_crypto_ml_dsa_privkey_size[vector->type],
+		"Incorrect Private key length\n");
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.keygen.pubkey.length,
+		rte_crypto_ml_dsa_pubkey_size[vector->type],
+		"Incorrect Public key length\n");
+
+	/* If the seed is all zero, keys are deterministic */
+	if (memcmp(vector->seed.data, (uint8_t [32]) {0},
+			vector->seed.length) == 0) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->privkey.data,
+			self->result_op->asym->mldsa.keygen.privkey.data,
+			self->result_op->asym->mldsa.keygen.privkey.length,
+			"Incorrect Private key\n");
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->pubkey.data,
+			self->result_op->asym->mldsa.keygen.pubkey.data,
+			self->result_op->asym->mldsa.keygen.pubkey.length,
+			"Incorrect Public key\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic keygen test passed\n");
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_sign(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	struct rte_cryptodev_info dev_info;
+	uint8_t sign[TEST_DATA_SIZE] = {0};
+	size_t sign_len;
+
+	xform.mldsa.type = vector->type;
+	xform.mldsa.sign_deterministic = vector->sign_deterministic;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+
+	rte_cryptodev_info_get(dev_id, &dev_info);
+
+	/* Check if prehash is supported */
+	if (vector->hash) {
+		if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MLDSA_SIGN_PREHASH)) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support prehash in ML-DSA signature generation. Test skipped\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Sign */
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_SIGN;
+	self->op->asym->mldsa.siggen.seed.data = vector->seed.data;
+	self->op->asym->mldsa.siggen.seed.length = vector->seed.length;
+	self->op->asym->mldsa.siggen.privkey.data = vector->privkey.data;
+	self->op->asym->mldsa.siggen.privkey.length = vector->privkey.length;
+	self->op->asym->mldsa.siggen.message.data = vector->message.data;
+	self->op->asym->mldsa.siggen.message.length = vector->message.length;
+	self->op->asym->mldsa.siggen.ctx.data = vector->context.data;
+	self->op->asym->mldsa.siggen.ctx.length = vector->context.length;
+	self->op->asym->mldsa.siggen.mu.data = vector->mu.data;
+	self->op->asym->mldsa.siggen.mu.length = vector->mu.length;
+	self->op->asym->mldsa.siggen.sign.data = sign;
+	self->op->asym->mldsa.siggen.sign.length =
+		rte_crypto_ml_dsa_sign_size[vector->type];
+	self->op->asym->mldsa.siggen.hash = vector->hash;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Sign)");
+
+	debug_hexdump(stdout, "Signature",
+		self->result_op->asym->mldsa.siggen.sign.data,
+		self->result_op->asym->mldsa.siggen.sign.length);
+
+	/* Verify the result with the test vector */
+	TEST_ASSERT_EQUAL(self->result_op->asym->mldsa.siggen.sign.length,
+		rte_crypto_ml_dsa_sign_size[vector->type],
+		"Incorrect Signature length\n");
+
+	/* Verify signature if it is deterministic */
+	if (vector->sign_deterministic) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(vector->sign.data,
+			self->result_op->asym->mldsa.siggen.sign.data,
+			self->result_op->asym->mldsa.siggen.sign.length,
+			"Incorrect Signature\n");
+		RTE_LOG(DEBUG, USER1, "Deterministic signature test passed\n");
+	}
+
+	/* Verify the signature */
+	sign_len = self->result_op->asym->mldsa.siggen.sign.length;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	TEST_ASSERT_EQUAL(self->result_op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+		"Failed to verify the signature");
+
+	/* Negative test */
+	sign[0] ^= 0x01;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one_no_status_check(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	if (self->result_op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+mldsa_verify(const void *test_data)
+{
+	const struct crypto_testsuite_mldsa_params *vector = test_data;
+	const uint8_t dev_id = params->valid_devs[0];
+	struct rte_crypto_asym_xform xform = {0};
+	uint8_t sign[TEST_DATA_SIZE] = {0};
+	size_t sign_len;
+
+	xform.mldsa.type = vector->type;
+	xform.mldsa.sign_deterministic = vector->sign_deterministic;
+	xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	if (rte_cryptodev_asym_session_create(dev_id, &xform,
+			params->session_mpool, &self->sess) < 0) {
+		RTE_LOG(ERR, USER1, "line %u FAILED: Session creation failed",
+			__LINE__);
+		return TEST_FAILED;
+	}
+
+	rte_crypto_op_attach_asym_session(self->op, self->sess);
+
+	/* Verify the signature */
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = vector->sign.data;
+	self->op->asym->mldsa.sigver.sign.length = vector->sign.length;
+
+	TEST_ASSERT_SUCCESS(send_one(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	TEST_ASSERT_EQUAL(self->result_op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+		"Failed to verify the signature");
+
+	/* Negative test */
+	memcpy(sign, vector->sign.data, vector->sign.length);
+	sign_len = vector->sign.length;
+	sign[0] ^= 0x01;
+
+	self->op->asym->mldsa.op = RTE_CRYPTO_ML_DSA_OP_VERIFY;
+	self->op->asym->mldsa.sigver.message.data = vector->message.data;
+	self->op->asym->mldsa.sigver.message.length = vector->message.length;
+	self->op->asym->mldsa.sigver.ctx.data = vector->context.data;
+	self->op->asym->mldsa.sigver.ctx.length = vector->context.length;
+	self->op->asym->mldsa.sigver.mu.data = vector->mu.data;
+	self->op->asym->mldsa.sigver.mu.length = vector->mu.length;
+	self->op->asym->mldsa.sigver.pubkey.data = vector->pubkey.data;
+	self->op->asym->mldsa.sigver.pubkey.length = vector->pubkey.length;
+	self->op->asym->mldsa.sigver.sign.data = sign;
+	self->op->asym->mldsa.sigver.sign.length = sign_len;
+
+	TEST_ASSERT_SUCCESS(send_one_no_status_check(),
+		"Failed to process crypto op (ML-DSA Verify)");
+
+	/* Verify the result */
+	if (self->result_op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
+		rte_cryptodev_asym_session_free(dev_id, self->sess);
+		return TEST_FAILED;
+	}
+
+	rte_cryptodev_asym_session_free(dev_id, self->sess);
+	return TEST_SUCCESS;
+}
+
+static int
+test_mlkem_keygen(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_KEYGEN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM keygen operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_keygen_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_KEYGEN] &
+			(1 << mlkem_keygen_test_vectors[i].type))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_keygen_test_vectors[i].type,
+				mlkem_keygen_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_keygen_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_keygen(&mlkem_keygen_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_keygen_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_keygen_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mlkem_encap(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_ENCAP))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM encap operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_encap_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_ENCAP] &
+			(1 << mlkem_encap_test_vectors[i].type))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_encap_test_vectors[i].type,
+				mlkem_encap_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_encap_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_encap(&mlkem_encap_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_encap_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_encap_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mlkem_decap(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-KEM is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_KEM;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_KEM_OP_DECAP))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-KEM decap operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mlkem_decap_test_vectors); i++) {
+		if (!(capa->mlkem_capa[RTE_CRYPTO_ML_KEM_OP_DECAP] &
+			(1 << mlkem_decap_test_vectors[i].type))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-KEM param %u. TestCase %s skipped\n",
+				mlkem_decap_test_vectors[i].type,
+				mlkem_decap_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mlkem_decap_test_vectors[i].name);
+			continue;
+		}
+		ret = mlkem_decap(&mlkem_decap_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mlkem_decap_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mlkem_decap_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_keygen(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_KEYGEN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA keygen operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_keygen_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_KEYGEN] &
+			(1 << mldsa_keygen_test_vectors[i].type))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_keygen_test_vectors[i].type,
+				mldsa_keygen_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_keygen_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_keygen(&mldsa_keygen_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_keygen_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_keygen_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_sign(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_SIGN))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA sign operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_sign_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_SIGN] &
+			(1 << mldsa_sign_test_vectors[i].type))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_sign_test_vectors[i].type,
+				mldsa_sign_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_sign_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_sign(&mldsa_sign_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_sign_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_sign_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
+static int
+test_mldsa_verify(void)
+{
+	struct crypto_testsuite_params_asym *ts_params = &testsuite_params;
+	const struct rte_cryptodev_asymmetric_xform_capability *capa;
+	struct rte_cryptodev_asym_capability_idx idx;
+	uint8_t dev_id = ts_params->valid_devs[0];
+	int overall_status = TEST_SUCCESS;
+	int ret;
+
+	/* Check if ML-DSA is supported */
+	idx.type = RTE_CRYPTO_ASYM_XFORM_ML_DSA;
+	capa = rte_cryptodev_asym_capability_get(dev_id, &idx);
+	if (capa == NULL) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	if (!(capa->op_types & (1 <<  RTE_CRYPTO_ML_DSA_OP_VERIFY))) {
+		RTE_LOG(DEBUG, USER1,
+			"Device doesn't support ML-DSA verify operation. Test skipped\n");
+		return TEST_SKIPPED;
+	}
+
+	for (uint8_t i = 0; i < RTE_DIM(mldsa_verify_test_vectors); i++) {
+		if (!(capa->mldsa_capa[RTE_CRYPTO_ML_DSA_OP_VERIFY] &
+			(1 << mldsa_verify_test_vectors[i].type))) {
+			RTE_LOG(DEBUG, USER1,
+				"Device doesn't support ML-DSA param %u. TestCase %s skipped\n",
+				mldsa_verify_test_vectors[i].type,
+				mldsa_verify_test_vectors[i].name);
+			printf("  %u) TestCase %s: skipped\n", i,
+				mldsa_verify_test_vectors[i].name);
+			continue;
+		}
+		ret = mldsa_verify(&mldsa_verify_test_vectors[i]);
+		if (ret == TEST_SUCCESS || ret == TEST_SKIPPED) {
+			printf("  %u) TestCase %s: %s\n", i, mldsa_verify_test_vectors[i].name,
+				(ret == TEST_SKIPPED) ? "skipped" : "passed");
+				continue;
+		}
+
+		printf("  %u) TestCase %s: failed\n", i, mldsa_verify_test_vectors[i].name);
+		overall_status = TEST_FAILED;
+	}
+
+	return overall_status;
+}
+
 #define SET_RSA_PARAM(arg, vector, coef) \
 	uint8_t coef[TEST_DATA_SIZE] = { }; \
 	memcpy(coef, vector->coef.data, vector->coef.len); \
@@ -3987,6 +4837,12 @@ static struct unit_test_suite cryptodev_openssl_asym_testsuite  = {
 			ut_setup_asym, ut_teardown_asym,
 			modular_exponentiation, &modex_group_test_cases[7]),
 		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_eddsa_sign_verify_all_curve),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_keygen),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_encap),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mlkem_decap),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_keygen),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_sign),
+		TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mldsa_verify),
 		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
 };
app/test/test_cryptodev_ml_dsa_test_vectors.h new file +1856 -0

1,856 lines not on this page · raw message

app/test/test_cryptodev_ml_kem_test_vectors.h new file +873 -0

264 lines not on this page · raw message

The rest of this diff is not shown. View the raw message.

Signature · 1 line
2.37.1

Part of the diff is not shown here. View the raw message.