Add a cryptodev validation application using Wycheproof JSON test vectors. Document it as a second section in the crypto validation guide.
Signed-off-by: Kai Ji <[email protected]> --- MAINTAINERS | 5 + app/meson.build | 1 + app/wycheproof_validation/main.c | 2106 +++++++++++++++++ app/wycheproof_validation/meson.build | 20 + doc/guides/rel_notes/release_26_11.rst | 6 + .../sample_app_ug/crypto_validation.rst | 50 + 6 files changed, 2188 insertions(+) create mode 100644 app/wycheproof_validation/main.c create mode 100644 app/wycheproof_validation/meson.build diff --git a/MAINTAINERS b/MAINTAINERS index 736f39c70e..d258f4cea4 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -2116,3 +2116,8 @@ F: examples/vmdq/ F: doc/guides/sample_app_ug/vmdq_forwarding.rst F: examples/vmdq_dcb/ F: doc/guides/sample_app_ug/vmdq_dcb_forwarding.rst + +Wycheproof validation application +M: Kai Ji <[email protected]> +F: app/wycheproof_validation/ +F: doc/guides/sample_app_ug/crypto_validation.rst diff --git a/app/meson.build b/app/meson.build index 927f79d0b3..6239e05093 100644 --- a/app/meson.build +++ b/app/meson.build @@ -34,6 +34,7 @@ apps = [ 'test-sad', 'test-security-perf', 'validate-bpf', + 'wycheproof_validation', ] if get_option('tests') diff --git a/app/wycheproof_validation/main.c b/app/wycheproof_validation/main.c new file mode 100644 index 0000000000..9b8182f15b --- /dev/null +++ b/app/wycheproof_validation/main.c @@ -0,0 +1,2106 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2026 + */ + +#include <dirent.h> +#include <errno.h> +#include <getopt.h> +#include <inttypes.h> +#include <limits.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/stat.h> + +#include <jansson.h> + +#include <rte_cryptodev.h> +#include <rte_cycles.h> +#include <rte_eal.h> +#include <rte_errno.h> +#include <rte_mbuf.h> +#include <rte_mempool.h> +#include <rte_malloc.h> +#include <rte_memory.h> + +#define DEFAULT_MBUF_DATA_ROOM 16384 +#define NUM_QP_DESCRIPTORS 128 +#define MAX_IV_LEN 512 +#define MAX_EC_BYTESIZE 66 +/* CCM AAD is prefixed with an 18-byte reserved area (B0 block + length). */ +#define AES_CCM_AAD_OFFSET 18 +#define IV_OFFSET (sizeof(struct rte_crypto_op) + sizeof(struct rte_crypto_sym_op)) + +struct wycheproof_data { + uint8_t *key; + uint8_t *iv; + uint8_t *aad; + uint8_t *msg; + uint8_t *ct; + uint8_t *tag; + uint32_t key_len; + uint32_t iv_len; + uint32_t aad_len; + uint32_t msg_len; + uint32_t ct_len; + uint32_t tag_len; + json_int_t tc_id; + const char *result; +}; + +struct app_env { + uint8_t dev_id; + uint8_t hash_dev_id; + bool hash_dev_own; + uint32_t mbuf_data_room; + const char *vectors_path; + bool debug; + struct rte_mempool *mbuf_pool; + struct rte_mempool *session_pool; + struct rte_mempool *op_pool; + struct rte_mempool *asym_session_pool; + struct rte_mempool *asym_op_pool; +}; + +struct app_stats { + uint64_t passed; + uint64_t failed; + uint64_t skipped_capability; + uint64_t skipped_acceptable; + uint64_t skipped_unsupported; +}; + +static struct app_env env = { + .mbuf_data_room = DEFAULT_MBUF_DATA_ROOM, +}; + +static void +usage(const char *program) +{ + printf("%s [EAL options] -- " + "--vectors PATH [--cryptodev NAME | --cryptodev-id ID]\n" + "\t[--mbuf-dataroom BYTES] [--debug]\n", + program); +} + +static void +debug_vector(const char *type, const char *algorithm, + const struct wycheproof_data *vector, const char *reason) +{ + if (env.debug) + printf("%s %s tcId=%" JSON_INTEGER_FORMAT " result=%s: %s\n", type, + algorithm, vector->tc_id, vector->result, reason); +} + +static void +debug_file(const char *type, const char *path, const char *reason) +{ + if (env.debug) + printf("%s %s: %s\n", type, path, reason); +} + +static int +parse_uint32(const char *text, uint32_t *value) +{ + char *end; + unsigned long parsed; + + errno = 0; + parsed = strtoul(text, &end, 10); + if (errno != 0 || *text == '\0' || *end != '\0' || parsed > UINT32_MAX) + return -EINVAL; + + *value = parsed; + return 0; +} + +static int +parse_args(int argc, char **argv) +{ + static const struct option options[] = { + { "vectors", required_argument, NULL, 'v' }, + { "cryptodev", required_argument, NULL, 'c' }, + { "cryptodev-id", required_argument, NULL, 'd' }, + { "mbuf-dataroom", required_argument, NULL, 'm' }, + { "debug", no_argument, NULL, 'D' }, + { NULL, 0, NULL, 0 }, + }; + bool have_device = false; + int option; + + if (rte_cryptodev_count() == 0) + return -ENODEV; + env.dev_id = 0; + + while ((option = getopt_long(argc, argv, "v:c:d:m:D", options, NULL)) != -1) { + uint32_t value; + int dev_id; + + switch (option) { + case 'v': + env.vectors_path = optarg; + break; + case 'c': + dev_id = rte_cryptodev_get_dev_id(optarg); + if (dev_id < 0) + return dev_id; + env.dev_id = dev_id; + have_device = true; + break; + case 'd': + if (parse_uint32(optarg, &value) != 0 || value > UINT8_MAX || + !rte_cryptodev_is_valid_dev(value)) + return -EINVAL; + env.dev_id = value; + have_device = true; + break; + case 'm': + if (parse_uint32(optarg, &env.mbuf_data_room) != 0 || + env.mbuf_data_room < RTE_PKTMBUF_HEADROOM || + env.mbuf_data_room > UINT16_MAX) + return -EINVAL; + break; + case 'D': + env.debug = true; + break; + default: + return -EINVAL; + } + } + + if (env.vectors_path == NULL) + return -EINVAL; + if (!have_device) + printf("Using cryptodev %u (%s)\n", env.dev_id, + rte_cryptodev_name_get(env.dev_id)); + + return 0; +} + +static int +app_init(void) +{ + struct rte_cryptodev_config config = { + .socket_id = rte_socket_id(), + .nb_queue_pairs = 1, + .ff_disable = 0, + }; + struct rte_cryptodev_qp_conf queue_pair = { + .nb_descriptors = NUM_QP_DESCRIPTORS, + .mp_session = NULL, + }; + struct rte_cryptodev_info dev_info; + uint32_t session_size; + int ret; + + rte_cryptodev_info_get(env.dev_id, &dev_info); + if (dev_info.max_nb_queue_pairs < config.nb_queue_pairs) + return -ENOTSUP; + + ret = rte_cryptodev_configure(env.dev_id, &config); + if (ret < 0) + return ret; + + env.mbuf_pool = rte_pktmbuf_pool_create("WYCHEPROOF_MBUF_POOL", 64, 0, 0, + env.mbuf_data_room, rte_socket_id()); + if (env.mbuf_pool == NULL) { + ret = -rte_errno; + goto error; + } + + session_size = rte_cryptodev_sym_get_private_session_size(env.dev_id); + { + /* The hashing device may differ from the target device, so size the + * session pool for the largest sym session across all devices. + */ + uint8_t d; + + for (d = 0; d < rte_cryptodev_count(); d++) { + uint32_t s = rte_cryptodev_sym_get_private_session_size(d); + + if (s > session_size) + session_size = s; + } + } + env.session_pool = rte_cryptodev_sym_session_pool_create("WYCHEPROOF_SESSION_POOL", + 64, session_size, 0, 0, rte_socket_id()); + if (env.session_pool == NULL) { + ret = -rte_errno; + goto error; + } + + /* priv_size is measured from the end of the sym op; the IV lives there. */ + env.op_pool = rte_crypto_op_pool_create("WYCHEPROOF_OP_POOL", + RTE_CRYPTO_OP_TYPE_SYMMETRIC, 64, 0, MAX_IV_LEN, rte_socket_id()); + if (env.op_pool == NULL) { + ret = -rte_errno; + goto error; + } + + /* Asymmetric pools are best-effort; DSA/ECDSA paths gate on the + * device asymmetric feature flag at runtime. + */ + env.asym_session_pool = rte_cryptodev_asym_session_pool_create( + "WYCHEPROOF_ASYM_SESS", 16, 0, 0, rte_socket_id()); + env.asym_op_pool = rte_crypto_op_pool_create("WYCHEPROOF_ASYM_OP", + RTE_CRYPTO_OP_TYPE_ASYMMETRIC, 64, 0, 0, rte_socket_id()); + + queue_pair.mp_session = env.session_pool; + ret = rte_cryptodev_queue_pair_setup(env.dev_id, 0, &queue_pair, + rte_socket_id()); + if (ret < 0) + goto error; + + ret = rte_cryptodev_start(env.dev_id); + if (ret < 0) + goto error; + + /* Digest computation for DSA/ECDSA needs a symmetric-auth device. The + * target device may be asym-only (for example QAT), so pick a separate + * sym-capable device for hashing when needed. + */ + env.hash_dev_id = env.dev_id; + env.hash_dev_own = false; + { + struct rte_cryptodev_sym_capability_idx hash_idx = { + .type = RTE_CRYPTO_SYM_XFORM_AUTH, + .algo.auth = RTE_CRYPTO_AUTH_SHA256, + }; + uint8_t count = rte_cryptodev_count(); + uint8_t d; + + if (rte_cryptodev_sym_capability_get(env.dev_id, &hash_idx) == NULL) { + for (d = 0; d < count; d++) { + struct rte_cryptodev_qp_conf hash_qp = { + .nb_descriptors = NUM_QP_DESCRIPTORS, + .mp_session = NULL, + }; + + if (d == env.dev_id) + continue; + if (rte_cryptodev_sym_capability_get(d, &hash_idx) == NULL) + continue; + if (rte_cryptodev_configure(d, &config) < 0) + continue; + hash_qp.mp_session = env.session_pool; + if (rte_cryptodev_queue_pair_setup(d, 0, &hash_qp, + rte_socket_id()) < 0 || + rte_cryptodev_start(d) < 0) { + rte_cryptodev_close(d); + continue; + } + env.hash_dev_id = d; + env.hash_dev_own = true; + break; + } + } + } + + return 0; + +error: + rte_mempool_free(env.asym_op_pool); + rte_mempool_free(env.asym_session_pool); + rte_mempool_free(env.op_pool); + rte_mempool_free(env.session_pool); + rte_mempool_free(env.mbuf_pool); + env.asym_op_pool = NULL; + env.asym_session_pool = NULL; + env.op_pool = NULL; + env.session_pool = NULL; + env.mbuf_pool = NULL; + rte_cryptodev_close(env.dev_id); + return ret; +} + +static void +app_uninit(void) +{ + if (env.hash_dev_own) { + rte_cryptodev_stop(env.hash_dev_id); + rte_cryptodev_close(env.hash_dev_id); + } + rte_cryptodev_stop(env.dev_id); + rte_cryptodev_close(env.dev_id); + rte_mempool_free(env.asym_op_pool); + rte_mempool_free(env.asym_session_pool); + rte_mempool_free(env.op_pool); + rte_mempool_free(env.session_pool); + rte_mempool_free(env.mbuf_pool); +} + +static void +free_vector(struct wycheproof_data *vector) +{ + rte_free_sensitive(vector->key); + rte_free(vector->iv); + rte_free(vector->aad); + rte_free(vector->msg); + rte_free(vector->ct); + rte_free(vector->tag); + memset(vector, 0, sizeof(*vector)); +} + +static int +hex_value(char character) +{ + if (character >= '0' && character <= '9') + return character - '0'; + if (character >= 'a' && character <= 'f') + return character - 'a' + 10; + if (character >= 'A' && character <= 'F') + return character - 'A' + 10; + return -1; +} + +static int +decode_hex(json_t *value, uint8_t **buffer, uint32_t *length) +{ + const char *hex; + size_t hex_length; + uint8_t *decoded; + size_t index; + + if (!json_is_string(value)) + return -EINVAL; + + hex = json_string_value(value); + hex_length = strlen(hex); + if ((hex_length & 1) != 0 || hex_length / 2 > UINT32_MAX) + return -EINVAL; + + *length = hex_length / 2; + if (*length == 0) + return 0; + + decoded = rte_malloc(NULL, *length, 0); + if (decoded == NULL) + return -ENOMEM; + + for (index = 0; index < *length; index++) { + int high = hex_value(hex[index * 2]); + int low = hex_value(hex[index * 2 + 1]); + + if (high < 0 || low < 0) { + rte_free(decoded); + return -EINVAL; + } + decoded[index] = (high << 4) | low; + } + + *buffer = decoded; + return 0; +} + +static int +parse_vector(json_t *test, struct wycheproof_data *vector) +{ + json_t *tc_id; + int ret; + + memset(vector, 0, sizeof(*vector)); + tc_id = json_object_get(test, "tcId"); + vector->result = json_string_value(json_object_get(test, "result")); + if (!json_is_integer(tc_id) || vector->result == NULL) + return -EINVAL; + vector->tc_id = json_integer_value(tc_id); + + ret = decode_hex(json_object_get(test, "key"), &vector->key, &vector->key_len); + if (ret != 0) + goto error; + ret = decode_hex(json_object_get(test, "iv"), &vector->iv, &vector->iv_len); + if (ret != 0) + goto error; + ret = decode_hex(json_object_get(test, "aad"), &vector->aad, &vector->aad_len); + if (ret != 0) + goto error; + ret = decode_hex(json_object_get(test, "msg"), &vector->msg, &vector->msg_len); + if (ret != 0) + goto error; + ret = decode_hex(json_object_get(test, "ct"), &vector->ct, &vector->ct_len); + if (ret != 0) + goto error; + ret = decode_hex(json_object_get(test, "tag"), &vector->tag, &vector->tag_len); + if (ret != 0) + goto error; + + return 0; + +error: + free_vector(vector); + return ret; +} + +static int +parse_mac_vector(json_t *test, struct wycheproof_data *vector) +{ + json_t *tc_id; + int ret; + + memset(vector, 0, sizeof(*vector)); + tc_id = json_object_get(test, "tcId"); + vector->result = json_string_value(json_object_get(test, "result")); + if (!json_is_integer(tc_id) || vector->result == NULL) + return -EINVAL; + vector->tc_id = json_integer_value(tc_id); + + ret = decode_hex(json_object_get(test, "key"), &vector->key, &vector->key_len); + if (ret != 0) + goto error; + ret = decode_hex(json_object_get(test, "msg"), &vector->msg, &vector->msg_len); + if (ret != 0) + goto error; + ret = decode_hex(json_object_get(test, "tag"), &vector->tag, &vector->tag_len); + if (ret != 0) + goto error; + + return 0; + +error: + free_vector(vector); + return ret; +} + +static int +parse_mac_with_iv_vector(json_t *test, struct wycheproof_data *vector) +{ + int ret; + + ret = parse_mac_vector(test, vector); + if (ret != 0) + return ret; + ret = decode_hex(json_object_get(test, "iv"), &vector->iv, &vector->iv_len); + if (ret != 0) + free_vector(vector); + return ret; +} + +/* Bounded wait for one completed op; NULL on timeout so a stuck PMD fails the + * vector instead of hanging the tool. + */ +static struct rte_crypto_op * +dequeue_one(uint8_t dev_id) +{ + struct rte_crypto_op *completed = NULL; + uint64_t deadline = rte_get_timer_cycles() + rte_get_timer_hz(); + + while (rte_cryptodev_dequeue_burst(dev_id, 0, &completed, 1) == 0) { + if (rte_get_timer_cycles() > deadline) + return NULL; + rte_pause(); + } + return completed; +} + +static int +check_aead_capability(const struct wycheproof_data *vector, + enum rte_crypto_aead_algorithm algorithm) +{ + struct rte_cryptodev_sym_capability_idx index = { + .type = RTE_CRYPTO_SYM_XFORM_AEAD, + .algo.aead = algorithm, + }; + const struct rte_cryptodev_symmetric_capability *capability; + + capability = rte_cryptodev_sym_capability_get(env.dev_id, &index); + if (capability == NULL) + return -ENOTSUP; + + return rte_cryptodev_sym_capability_check_aead(capability, vector->key_len, + vector->tag_len, vector->aad_len, vector->iv_len); +} + +static int +run_aead(const struct wycheproof_data *vector, enum rte_crypto_aead_algorithm algorithm, + enum rte_crypto_aead_operation operation, uint8_t **output, uint8_t **digest, + enum rte_crypto_op_status *status) +{ + struct rte_crypto_sym_xform xform = { 0 }; + struct rte_cryptodev_sym_session *session = NULL; + struct rte_crypto_op *operation_op = NULL; + struct rte_mbuf *mbuf = NULL; + struct rte_crypto_op *completed = NULL; + struct rte_crypto_sym_op *sym_op; + uint8_t *aad = NULL; + uint8_t *input; + uint32_t input_len; + int ret = -ENOMEM; + + *output = NULL; + *digest = NULL; + xform.type = RTE_CRYPTO_SYM_XFORM_AEAD; + xform.aead.algo = algorithm; + xform.aead.op = operation; + xform.aead.key.data = vector->key; + xform.aead.key.length = vector->key_len; + xform.aead.iv.offset = IV_OFFSET; + xform.aead.iv.length = vector->iv_len; + xform.aead.aad_length = vector->aad_len; + xform.aead.digest_length = vector->tag_len; + + session = rte_cryptodev_sym_session_create(env.dev_id, &xform, env.session_pool); + if (session == NULL) + goto out; + + operation_op = rte_crypto_op_alloc(env.op_pool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); + if (operation_op == NULL) + goto out; + + mbuf = rte_pktmbuf_alloc(env.mbuf_pool); + if (mbuf == NULL) + goto out; + input = operation == RTE_CRYPTO_AEAD_OP_ENCRYPT ? vector->msg : vector->ct; + input_len = operation == RTE_CRYPTO_AEAD_OP_ENCRYPT ? vector->msg_len : vector->ct_len; + if (input_len > rte_pktmbuf_tailroom(mbuf)) { + ret = -EMSGSIZE; + goto out; + } + if (input_len != 0) + memcpy(rte_pktmbuf_append(mbuf, input_len), input, input_len); + + *digest = rte_malloc(NULL, vector->tag_len, RTE_CACHE_LINE_SIZE); + if (*digest == NULL && vector->tag_len != 0) + goto out; + if (operation == RTE_CRYPTO_AEAD_OP_DECRYPT && vector->tag_len != 0) + memcpy(*digest, vector->tag, vector->tag_len); + + sym_op = operation_op->sym; + sym_op->m_src = mbuf; + sym_op->aead.data.offset = 0; + sym_op->aead.data.length = input_len; + if (algorithm == RTE_CRYPTO_AEAD_AES_CCM) { + aad = rte_zmalloc(NULL, + RTE_ALIGN_CEIL(vector->aad_len + AES_CCM_AAD_OFFSET, 16), 0); + if (aad == NULL) + goto out; + if (vector->aad_len != 0) + memcpy(aad + AES_CCM_AAD_OFFSET, vector->aad, vector->aad_len); + sym_op->aead.aad.data = aad; + sym_op->aead.aad.phys_addr = rte_malloc_virt2iova(aad); + memcpy(rte_crypto_op_ctod_offset(operation_op, uint8_t *, IV_OFFSET) + 1, + vector->iv, vector->iv_len); + } else { + sym_op->aead.aad.data = vector->aad; + sym_op->aead.aad.phys_addr = rte_malloc_virt2iova(vector->aad); + memcpy(rte_crypto_op_ctod_offset(operation_op, uint8_t *, IV_OFFSET), vector->iv, + vector->iv_len); + } + sym_op->aead.digest.data = *digest; + sym_op->aead.digest.phys_addr = rte_malloc_virt2iova(*digest); + rte_crypto_op_attach_sym_session(operation_op, session); + + if (rte_cryptodev_enqueue_burst(env.dev_id, 0, &operation_op, 1) != 1) { + ret = -EIO; + goto out; + } + completed = dequeue_one(env.dev_id); + if (completed == NULL) + /* Device wedged: op still owned by the PMD. Abort without freeing + * in-flight state; teardown stops the device. + */ + return -ETIMEDOUT; + + *status = completed->status; + if (*status == RTE_CRYPTO_OP_STATUS_SUCCESS && input_len != 0) { + *output = rte_malloc(NULL, input_len, 0); + if (*output == NULL) + goto out; + memcpy(*output, rte_pktmbuf_mtod(mbuf, uint8_t *), input_len); + } + ret = 0; + +out: + rte_free(aad); + rte_pktmbuf_free(mbuf); + rte_crypto_op_free(operation_op); + rte_cryptodev_sym_session_free(env.dev_id, session); + if (ret != 0) { + rte_free(*output); + rte_free(*digest); + *output = NULL; + *digest = NULL; + } + return ret; +} + +static int +run_hmac(const struct wycheproof_data *vector, enum rte_crypto_auth_algorithm algorithm, + enum rte_crypto_auth_operation operation, uint8_t **digest, + enum rte_crypto_op_status *status) +{ + struct rte_crypto_sym_xform xform = { 0 }; + struct rte_cryptodev_sym_session *session = NULL; + struct rte_crypto_op *op = NULL; + struct rte_crypto_op *completed = NULL; + struct rte_mbuf *mbuf = NULL; + const struct rte_cryptodev_symmetric_capability *capability; + struct rte_cryptodev_sym_capability_idx index = { + .type = RTE_CRYPTO_SYM_XFORM_AUTH, + .algo.auth = algorithm, + }; + int ret = -ENOMEM; + + *digest = NULL; + capability = rte_cryptodev_sym_capability_get(env.dev_id, &index); + if (capability == NULL || rte_cryptodev_sym_capability_check_auth(capability, + vector->key_len, vector->tag_len, 0) != 0) + return -ENOTSUP; + + xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + xform.auth.algo = algorithm; + xform.auth.op = operation; + xform.auth.key.data = vector->key; + xform.auth.key.length = vector->key_len; + xform.auth.digest_length = vector->tag_len; + session = rte_cryptodev_sym_session_create(env.dev_id, &xform, env.session_pool); + if (session == NULL) + goto out; + + op = rte_crypto_op_alloc(env.op_pool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); + if (op == NULL) + goto out; + mbuf = rte_pktmbuf_alloc(env.mbuf_pool); + if (mbuf == NULL) + goto out; + if (vector->msg_len > rte_pktmbuf_tailroom(mbuf)) { + ret = -EMSGSIZE; + goto out; + } + if (vector->msg_len != 0) + memcpy(rte_pktmbuf_append(mbuf, vector->msg_len), vector->msg, vector->msg_len); + + *digest = rte_malloc(NULL, vector->tag_len, RTE_CACHE_LINE_SIZE); + if (*digest == NULL && vector->tag_len != 0) + goto out; + if (operation == RTE_CRYPTO_AUTH_OP_VERIFY && vector->tag_len != 0) + memcpy(*digest, vector->tag, vector->tag_len); + + op->sym->m_src = mbuf; + op->sym->auth.data.offset = 0; + op->sym->auth.data.length = vector->msg_len; + op->sym->auth.digest.data = *digest; + op->sym->auth.digest.phys_addr = rte_malloc_virt2iova(*digest); + rte_crypto_op_attach_sym_session(op, session); + if (rte_cryptodev_enqueue_burst(env.dev_id, 0, &op, 1) != 1) { + ret = -EIO; + goto out; + } + completed = dequeue_one(env.dev_id); + if (completed == NULL) + /* Device wedged: op still owned by the PMD. Abort without freeing + * in-flight state; teardown stops the device. + */ + return -ETIMEDOUT; + *status = completed->status; + ret = 0; + +out: + rte_pktmbuf_free(mbuf); + rte_crypto_op_free(op); + rte_cryptodev_sym_session_free(env.dev_id, session); + if (ret != 0) { + rte_free(*digest); + *digest = NULL; + } + return ret; +} + +static int +run_gmac(const struct wycheproof_data *vector, enum rte_crypto_auth_operation operation, + uint8_t **digest, enum rte_crypto_op_status *status) +{ + struct rte_crypto_sym_xform xform = { 0 }; + struct rte_cryptodev_sym_session *session = NULL; + struct rte_crypto_op *op = NULL; + struct rte_crypto_op *completed = NULL; + struct rte_mbuf *mbuf = NULL; + const struct rte_cryptodev_symmetric_capability *capability; + struct rte_cryptodev_sym_capability_idx index = { + .type = RTE_CRYPTO_SYM_XFORM_AUTH, + .algo.auth = RTE_CRYPTO_AUTH_AES_GMAC, + }; + int ret = -ENOMEM; + + *digest = NULL; + capability = rte_cryptodev_sym_capability_get(env.dev_id, &index); + if (capability == NULL || rte_cryptodev_sym_capability_check_auth(capability, + vector->key_len, vector->tag_len, vector->iv_len) != 0) + return -ENOTSUP; + + xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC; + xform.auth.op = operation; + xform.auth.key.data = vector->key; + xform.auth.key.length = vector->key_len; + xform.auth.iv.offset = IV_OFFSET; + xform.auth.iv.length = vector->iv_len; + xform.auth.digest_length = vector->tag_len; + session = rte_cryptodev_sym_session_create(env.dev_id, &xform, env.session_pool); + if (session == NULL) + goto out; + + op = rte_crypto_op_alloc(env.op_pool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); + if (op == NULL) + goto out; + mbuf = rte_pktmbuf_alloc(env.mbuf_pool); + if (mbuf == NULL) + goto out; + if (vector->msg_len > rte_pktmbuf_tailroom(mbuf)) { + ret = -EMSGSIZE; + goto out; + } + if (vector->msg_len != 0) + memcpy(rte_pktmbuf_append(mbuf, vector->msg_len), vector->msg, vector->msg_len); + + *digest = rte_malloc(NULL, vector->tag_len, RTE_CACHE_LINE_SIZE); + if (*digest == NULL && vector->tag_len != 0) + goto out; + if (operation == RTE_CRYPTO_AUTH_OP_VERIFY && vector->tag_len != 0) + memcpy(*digest, vector->tag, vector->tag_len); + + op->sym->m_src = mbuf; + op->sym->auth.data.offset = 0; + op->sym->auth.data.length = vector->msg_len; + op->sym->auth.digest.data = *digest; + op->sym->auth.digest.phys_addr = rte_malloc_virt2iova(*digest); + memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET), vector->iv, vector->iv_len); + rte_crypto_op_attach_sym_session(op, session); + if (rte_cryptodev_enqueue_burst(env.dev_id, 0, &op, 1) != 1) { + ret = -EIO; + goto out; + } + completed = dequeue_one(env.dev_id); + if (completed == NULL) + /* Device wedged: op still owned by the PMD. Abort without freeing + * in-flight state; teardown stops the device. + */ + return -ETIMEDOUT; + *status = completed->status; + ret = 0; + +out: + rte_pktmbuf_free(mbuf); + rte_crypto_op_free(op); + rte_cryptodev_sym_session_free(env.dev_id, session); + if (ret != 0) { + rte_free(*digest); + *digest = NULL; + } + return ret; +} + +static int +validate_aead_vector(const struct wycheproof_data *vector, + enum rte_crypto_aead_algorithm algorithm, const char *name, + struct app_stats *stats) +{ + uint8_t *output = NULL; + uint8_t *digest = NULL; + enum rte_crypto_op_status status = RTE_CRYPTO_OP_STATUS_ERROR; + int ret; + + if (strcmp(vector->result, "acceptable") == 0) { + stats->skipped_acceptable++; + debug_vector("SKIP", name, vector, "acceptable result policy"); + return 0; + } + if (strcmp(vector->result, "valid") != 0 && strcmp(vector->result, "invalid") != 0) { + stats->skipped_unsupported++; + debug_vector("SKIP", name, vector, "unknown result"); + return 0; + } + /* CCM writes the IV one byte into the reserved area (after the flags byte). */ + if (vector->iv_len + (algorithm == RTE_CRYPTO_AEAD_AES_CCM ? 1u : 0u) > MAX_IV_LEN || + vector->msg_len != vector->ct_len || + vector->msg_len > env.mbuf_data_room - RTE_PKTMBUF_HEADROOM) { + stats->skipped_unsupported++; + debug_vector("SKIP", name, vector, "unsupported message length"); + return 0; + } + if (check_aead_capability(vector, algorithm) != 0) { + stats->skipped_capability++; + debug_vector("SKIP", name, vector, "PMD capability"); + return 0; + } + + if (strcmp(vector->result, "valid") == 0) { + ret = run_aead(vector, algorithm, RTE_CRYPTO_AEAD_OP_ENCRYPT, &output, &digest, + &status); + if (ret == -ETIMEDOUT) + return -ETIMEDOUT; + if (ret == -EMSGSIZE) + goto unsupported; + if (ret != 0 || status != RTE_CRYPTO_OP_STATUS_SUCCESS || + (vector->ct_len != 0 && + memcmp(output, vector->ct, vector->ct_len) != 0) || + (vector->tag_len != 0 && + memcmp(digest, vector->tag, vector->tag_len) != 0)) + goto failed; + rte_free(output); + rte_free(digest); + output = NULL; + digest = NULL; + ret = run_aead(vector, algorithm, RTE_CRYPTO_AEAD_OP_DECRYPT, &output, &digest, + &status); + if (ret == -ETIMEDOUT) + return -ETIMEDOUT; + if (ret == -EMSGSIZE) + goto unsupported; + if (ret != 0 || status != RTE_CRYPTO_OP_STATUS_SUCCESS || + (vector->msg_len != 0 && + memcmp(output, vector->msg, vector->msg_len) != 0)) + goto failed; + } else { + ret = run_aead(vector, algorithm, RTE_CRYPTO_AEAD_OP_DECRYPT, &output, &digest, + &status); + if (ret == -ETIMEDOUT) + return -ETIMEDOUT; + if (ret == -EMSGSIZE) + goto unsupported; + if (ret != 0 || status != RTE_CRYPTO_OP_STATUS_AUTH_FAILED) + goto failed; + } + + stats->passed++; + rte_free(output); + rte_free(digest); + return 0; + +unsupported: + stats->skipped_unsupported++; + debug_vector("SKIP", name, vector, "message length exceeds mbuf"); + rte_free(output); + rte_free(digest); + return 0; + +failed: + if (env.debug) + printf("FAIL %s tcId=%" JSON_INTEGER_FORMAT " result=%s status=%d ret=%d\n", + name, vector->tc_id, vector->result, status, ret); + stats->failed++; + rte_free(output); + rte_free(digest); + return 0; +} + +static int +process_aead(json_t *root, enum rte_crypto_aead_algorithm algorithm, + const char *name, struct app_stats *stats) +{ + json_t *groups = json_object_get(root, "testGroups"); + json_t *group; + size_t group_index; + + if (!json_is_array(groups)) + return -EINVAL; + + json_array_foreach(groups, group_index, group) { + json_t *tests = json_object_get(group, "tests"); + json_t *test; + size_t test_index; + + if (!json_is_array(tests)) + return -EINVAL; + json_array_foreach(tests, test_index, test) { + struct wycheproof_data vector; + int ret = parse_vector(test, &vector); + + if (ret != 0) { + if (env.debug) + printf("SKIP %s group=%zu test=%zu: malformed vector\n", + name, group_index, test_index); + stats->skipped_unsupported++; + continue; + } + ret = validate_aead_vector(&vector, algorithm, name, stats); + if (ret == -ETIMEDOUT) + return -ETIMEDOUT; + free_vector(&vector); + } + } + + return 0; +} + +static int +process_hmac(json_t *root, enum rte_crypto_auth_algorithm algorithm, + const char *name, struct app_stats *stats) +{ + json_t *groups = json_object_get(root, "testGroups"); + json_t *group; + size_t group_index; + + if (!json_is_array(groups)) + return -EINVAL; + json_array_foreach(groups, group_index, group) { + json_t *tests = json_object_get(group, "tests"); + json_t *test; + size_t test_index; + + if (!json_is_array(tests)) + return -EINVAL; + json_array_foreach(tests, test_index, test) { + struct wycheproof_data vector; + uint8_t *digest = NULL; + enum rte_crypto_op_status status = RTE_CRYPTO_OP_STATUS_ERROR; + int ret; + + ret = parse_mac_vector(test, &vector); + if (ret != 0) { + if (env.debug) + printf("SKIP %s group=%zu test=%zu: malformed vector\n", + name, group_index, test_index); + stats->skipped_unsupported++; + continue; + } + if (strcmp(vector.result, "acceptable") == 0) { + stats->skipped_acceptable++; + debug_vector("SKIP", name, &vector, "acceptable result policy"); + } else if (strcmp(vector.result, "valid") == 0) { + ret = run_hmac(&vector, algorithm, RTE_CRYPTO_AUTH_OP_GENERATE, + &digest, &status); + if (ret == -ENOTSUP) { + stats->skipped_capability++; + debug_vector("SKIP", name, &vector, "PMD capability"); + } else if (ret == -ETIMEDOUT) { + return -ETIMEDOUT; + } else if (ret == -EMSGSIZE) { + stats->skipped_unsupported++; + debug_vector("SKIP", name, &vector, + "message length exceeds mbuf"); + } else if (ret != 0 || status != RTE_CRYPTO_OP_STATUS_SUCCESS || + (vector.tag_len != 0 && + memcmp(digest, vector.tag, vector.tag_len) != 0)) { + debug_vector("FAIL", name, &vector, + "generated tag mismatch"); + stats->failed++; + } else + stats->passed++; + } else if (strcmp(vector.result, "invalid") == 0) { + ret = run_hmac(&vector, algorithm, RTE_CRYPTO_AUTH_OP_VERIFY, + &digest, &status); + if (ret == -ENOTSUP) { + stats->skipped_capability++; + debug_vector("SKIP", name, &vector, "PMD capability"); + } else if (ret == -ETIMEDOUT) { + return -ETIMEDOUT; + } else if (ret == -EMSGSIZE) { + stats->skipped_unsupported++; + debug_vector("SKIP", name, &vector, + "message length exceeds mbuf"); + } else if (ret != 0 || status != RTE_CRYPTO_OP_STATUS_AUTH_FAILED) { + debug_vector("FAIL", name, &vector, + "authentication unexpectedly succeeded"); + stats->failed++; + } else + stats->passed++; + } else { + stats->skipped_unsupported++; + debug_vector("SKIP", name, &vector, "unknown result"); + } + rte_free(digest); + free_vector(&vector); + } + } + return 0; +} + +static int +process_gmac(json_t *root, struct app_stats *stats) +{ + json_t *groups = json_object_get(root, "testGroups"); + json_t *group; + size_t group_index; + + if (!json_is_array(groups)) + return -EINVAL; + json_array_foreach(groups, group_index, group) { + json_t *tests = json_object_get(group, "tests"); + json_t *test; + size_t test_index; + + if (!json_is_array(tests)) + return -EINVAL; + json_array_foreach(tests, test_index, test) { + struct wycheproof_data vector; + uint8_t *digest = NULL; + enum rte_crypto_op_status status = RTE_CRYPTO_OP_STATUS_ERROR; + int ret; + + ret = parse_mac_with_iv_vector(test, &vector); + if (ret != 0) { + if (env.debug) + printf("SKIP AES-GMAC group=%zu test=%zu: " + "malformed vector\n", + group_index, test_index); + stats->skipped_unsupported++; + continue; + } + if (vector.iv_len > MAX_IV_LEN) { + stats->skipped_unsupported++; + debug_vector("SKIP", "AES-GMAC", &vector, "IV too large"); + rte_free(digest); + free_vector(&vector); + continue; + } + if (strcmp(vector.result, "valid") == 0) + ret = run_gmac(&vector, RTE_CRYPTO_AUTH_OP_GENERATE, + &digest, &status); + else if (strcmp(vector.result, "invalid") == 0) + ret = run_gmac(&vector, RTE_CRYPTO_AUTH_OP_VERIFY, + &digest, &status); + else if (strcmp(vector.result, "acceptable") == 0) { + stats->skipped_acceptable++; + debug_vector("SKIP", "AES-GMAC", &vector, + "acceptable result policy"); + ret = 0; + } else { + stats->skipped_unsupported++; + debug_vector("SKIP", "AES-GMAC", &vector, "unknown result"); + ret = 0; + } + if (ret == -ENOTSUP) { + stats->skipped_capability++; + debug_vector("SKIP", "AES-GMAC", &vector, "PMD capability"); + } else if (ret == -ETIMEDOUT) { + return -ETIMEDOUT; + } else if (ret == -EMSGSIZE) { + stats->skipped_unsupported++; + debug_vector("SKIP", "AES-GMAC", &vector, + "message length exceeds mbuf"); + } else if ((strcmp(vector.result, "valid") == 0 && + (ret != 0 || status != RTE_CRYPTO_OP_STATUS_SUCCESS || + (vector.tag_len != 0 && + memcmp(digest, vector.tag, vector.tag_len) != 0))) || + (strcmp(vector.result, "invalid") == 0 && + (ret != 0 || status != RTE_CRYPTO_OP_STATUS_AUTH_FAILED))) { + debug_vector("FAIL", "AES-GMAC", &vector, + "unexpected operation result"); + stats->failed++; + } else if (strcmp(vector.result, "valid") == 0 || + strcmp(vector.result, "invalid") == 0) + stats->passed++; + rte_free(digest); + free_vector(&vector); + } + } + return 0; +} + +struct dsa_group { + uint8_t *p; + uint8_t *q; + uint8_t *g; + uint8_t *y; + uint32_t p_len; + uint32_t q_len; + uint32_t g_len; + uint32_t y_len; + enum rte_crypto_auth_algorithm hash; + uint32_t digest_len; +}; + +static int +map_sha(const char *name, enum rte_crypto_auth_algorithm *algo, uint32_t *digest_len) +{ + if (strcmp(name, "SHA-1") == 0) { + *algo = RTE_CRYPTO_AUTH_SHA1; + *digest_len = 20; + } else if (strcmp(name, "SHA-224") == 0) { + *algo = RTE_CRYPTO_AUTH_SHA224; + *digest_len = 28; + } else if (strcmp(name, "SHA-256") == 0) { + *algo = RTE_CRYPTO_AUTH_SHA256; + *digest_len = 32; + } else if (strcmp(name, "SHA-384") == 0) { + *algo = RTE_CRYPTO_AUTH_SHA384; + *digest_len = 48; + } else if (strcmp(name, "SHA-512") == 0) { + *algo = RTE_CRYPTO_AUTH_SHA512; + *digest_len = 64; + } else { + return -ENOTSUP; + } + return 0; +} + +/* Compute a plain (keyless) message digest through the cryptodev auth path. */ +static int +compute_hash(const uint8_t *msg, uint32_t msg_len, enum rte_crypto_auth_algorithm algo, + uint8_t *digest, uint32_t digest_len) +{ + struct rte_crypto_sym_xform xform = { 0 }; + struct rte_cryptodev_sym_session *session = NULL; + struct rte_crypto_op *op = NULL; + struct rte_crypto_op *completed = NULL; + struct rte_mbuf *mbuf = NULL; + const struct rte_cryptodev_symmetric_capability *capability; + struct rte_cryptodev_sym_capability_idx index = { + .type = RTE_CRYPTO_SYM_XFORM_AUTH, + .algo.auth = algo, + }; + uint8_t *op_digest = NULL; + int ret = -ENOMEM; + + capability = rte_cryptodev_sym_capability_get(env.hash_dev_id, &index); + if (capability == NULL || rte_cryptodev_sym_capability_check_auth(capability, + 0, digest_len, 0) != 0) + return -ENOTSUP; + + xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + xform.auth.algo = algo; + xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + xform.auth.digest_length = digest_len; + session = rte_cryptodev_sym_session_create(env.hash_dev_id, &xform, env.session_pool); + if (session == NULL) + goto out; + + op = rte_crypto_op_alloc(env.op_pool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); + if (op == NULL) + goto out; + mbuf = rte_pktmbuf_alloc(env.mbuf_pool); + if (mbuf == NULL) + goto out; + if (msg_len > rte_pktmbuf_tailroom(mbuf)) { + ret = -EMSGSIZE; + goto out; + } + if (msg_len != 0) + memcpy(rte_pktmbuf_append(mbuf, msg_len), msg, msg_len); + + op_digest = rte_malloc(NULL, digest_len, RTE_CACHE_LINE_SIZE); + if (op_digest == NULL) + goto out; + op->sym->m_src = mbuf; + op->sym->auth.data.offset = 0; + op->sym->auth.data.length = msg_len; + op->sym->auth.digest.data = op_digest; + op->sym->auth.digest.phys_addr = rte_malloc_virt2iova(op_digest); + rte_crypto_op_attach_sym_session(op, session); + if (rte_cryptodev_enqueue_burst(env.hash_dev_id, 0, &op, 1) != 1) { + ret = -EIO; + goto out; + } + completed = dequeue_one(env.hash_dev_id); + if (completed == NULL) + /* Device wedged: op still owned by the PMD. Abort without freeing + * in-flight state; teardown stops the device. + */ + return -ETIMEDOUT; + if (completed->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { + ret = -EIO; + goto out; + } + memcpy(digest, op_digest, digest_len); + ret = 0; + +out: + rte_free(op_digest); + rte_pktmbuf_free(mbuf); + rte_crypto_op_free(op); + rte_cryptodev_sym_session_free(env.hash_dev_id, session); + return ret; +} + +static int +run_dsa_verify(const struct dsa_group *group, const uint8_t *msg, uint32_t msg_len, + const uint8_t *r, uint32_t r_len, const uint8_t *s, uint32_t s_len, + enum rte_crypto_op_status *status) +{ + struct rte_crypto_asym_xform xform = { 0 }; + void *session = NULL; + struct rte_crypto_op *op = NULL; + struct rte_crypto_op *completed = NULL; + struct rte_cryptodev_info dev_info; + struct rte_cryptodev_asym_capability_idx index = { + .type = RTE_CRYPTO_ASYM_XFORM_DSA, + }; + const struct rte_cryptodev_asymmetric_xform_capability *capability; + uint8_t digest[64]; + int ret; + + if (env.asym_session_pool == NULL || env.asym_op_pool == NULL) + return -ENOTSUP; + rte_cryptodev_info_get(env.dev_id, &dev_info); + if ((dev_info.feature_flags & RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO) == 0) + return -ENOTSUP; + capability = rte_cryptodev_asym_capability_get(env.dev_id, &index); + if (capability == NULL || rte_cryptodev_asym_xform_capability_check_optype(capability, + RTE_CRYPTO_ASYM_OP_VERIFY) == 0) + return -ENOTSUP; + + ret = compute_hash(msg, msg_len, group->hash, digest, group->digest_len); + if (ret != 0) + return ret; + + xform.xform_type = RTE_CRYPTO_ASYM_XFORM_DSA; + xform.next = NULL; + xform.dsa.p.data = group->p; + xform.dsa.p.length = group->p_len; + xform.dsa.q.data = group->q; + xform.dsa.q.length = group->q_len; + xform.dsa.g.data = group->g; + xform.dsa.g.length = group->g_len; + + /* Coarse capability check cannot confirm every parameter; treat a + * session-create failure as unsupported rather than a hard failure. + */ + if (rte_cryptodev_asym_session_create(env.dev_id, &xform, env.asym_session_pool, + &session) < 0 || session == NULL) { + ret = -ENOTSUP; + goto out; + } + ret = -ENOMEM; + op = rte_crypto_op_alloc(env.asym_op_pool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC); + if (op == NULL) + goto out; + op->asym->dsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY; + /* DSA verify operates on the message digest. */ + op->asym->dsa.message.data = digest; + op->asym->dsa.message.length = group->digest_len; + op->asym->dsa.r.data = (uint8_t *)(uintptr_t)r; + op->asym->dsa.r.length = r_len; + op->asym->dsa.s.data = (uint8_t *)(uintptr_t)s; + op->asym->dsa.s.length = s_len; + op->asym->dsa.y.data = group->y; + op->asym->dsa.y.length = group->y_len; + rte_crypto_op_attach_asym_session(op, session); + if (rte_cryptodev_enqueue_burst(env.dev_id, 0, &op, 1) != 1) { + ret = -EIO; + goto out; + } + completed = dequeue_one(env.dev_id); + if (completed == NULL) + /* Device wedged: op still owned by the PMD. Abort without freeing + * in-flight state; teardown stops the device. + */ + return -ETIMEDOUT; + *status = completed->status; + ret = 0; + +out: + rte_crypto_op_free(op); + if (session != NULL) + rte_cryptodev_asym_session_free(env.dev_id, session); + return ret; +} + +static int +process_dsa_p1363(json_t *root, const char *name, struct app_stats *stats) +{ + json_t *groups = json_object_get(root, "testGroups"); + json_t *group; + size_t group_index; + + if (!json_is_array(groups)) + return -EINVAL; + json_array_foreach(groups, group_index, group) { + json_t *pub = json_object_get(group, "publicKey"); + json_t *tests = json_object_get(group, "tests"); + struct dsa_group dsa = { 0 }; + const char *sha; + json_t *test; + size_t test_index; + + if (!json_is_object(pub) || !json_is_array(tests)) + return -EINVAL; + sha = json_string_value(json_object_get(group, "sha")); + if (sha == NULL || map_sha(sha, &dsa.hash, &dsa.digest_len) != 0) { + stats->skipped_unsupported++; + continue; + } + if (decode_hex(json_object_get(pub, "p"), &dsa.p, &dsa.p_len) != 0 || + decode_hex(json_object_get(pub, "q"), &dsa.q, &dsa.q_len) != 0 || + decode_hex(json_object_get(pub, "g"), &dsa.g, &dsa.g_len) != 0 || + decode_hex(json_object_get(pub, "y"), &dsa.y, &dsa.y_len) != 0) { + rte_free(dsa.p); + rte_free(dsa.q); + rte_free(dsa.g); + rte_free(dsa.y); + stats->skipped_unsupported++; + continue; + } + json_array_foreach(tests, test_index, test) { + struct wycheproof_data vector; + uint8_t *sig = NULL; + uint32_t sig_len = 0; + enum rte_crypto_op_status status = RTE_CRYPTO_OP_STATUS_ERROR; + json_t *tc_id; + int ret; + + memset(&vector, 0, sizeof(vector)); + tc_id = json_object_get(test, "tcId"); + vector.result = json_string_value(json_object_get(test, "result")); + if (!json_is_integer(tc_id) || vector.result == NULL) { + stats->skipped_unsupported++; + continue; + } + vector.tc_id = json_integer_value(tc_id); + if (decode_hex(json_object_get(test, "msg"), &vector.msg, + &vector.msg_len) != 0 || + decode_hex(json_object_get(test, "sig"), + &sig, &sig_len) != 0) { + rte_free(vector.msg); + rte_free(sig); + stats->skipped_unsupported++; + continue; + } + if (strcmp(vector.result, "acceptable") == 0) { + stats->skipped_acceptable++; + debug_vector("SKIP", name, &vector, "acceptable result policy"); + rte_free(vector.msg); + rte_free(sig); + continue; + } + if ((sig_len & 1) != 0 || sig_len == 0) { + debug_vector("SKIP", name, &vector, "malformed P1363 signature"); + stats->skipped_unsupported++; + rte_free(vector.msg); + rte_free(sig); + continue; + } + ret = run_dsa_verify(&dsa, vector.msg, vector.msg_len, sig, sig_len / 2, + sig + sig_len / 2, sig_len / 2, &status); + if (ret == -ENOTSUP) { + stats->skipped_capability++; + debug_vector("SKIP", name, &vector, "PMD capability"); + } else if (ret == -ETIMEDOUT) { + return -ETIMEDOUT; + } else if (ret == -EMSGSIZE) { + stats->skipped_unsupported++; + debug_vector("SKIP", name, &vector, "message length exceeds mbuf"); + } else if ((strcmp(vector.result, "valid") == 0 && + (ret != 0 || status != RTE_CRYPTO_OP_STATUS_SUCCESS)) || + (strcmp(vector.result, "invalid") == 0 && + (ret != 0 || status == RTE_CRYPTO_OP_STATUS_SUCCESS))) { + debug_vector("FAIL", name, &vector, + "unexpected verification result"); + stats->failed++; + } else if (strcmp(vector.result, "valid") == 0 || + strcmp(vector.result, "invalid") == 0) { + stats->passed++; + } else { + stats->skipped_unsupported++; + debug_vector("SKIP", name, &vector, "unknown result"); + } + rte_free(vector.msg); + rte_free(sig); + } + rte_free(dsa.p); + rte_free(dsa.q); + rte_free(dsa.g); + rte_free(dsa.y); + } + return 0; +} + +static int +map_curve(const char *name, enum rte_crypto_curve_id *curve, uint32_t *bytesize) +{ + if (strcmp(name, "secp224r1") == 0) { + *curve = RTE_CRYPTO_EC_GROUP_SECP224R1; + *bytesize = 28; + } else if (strcmp(name, "secp256r1") == 0) { + *curve = RTE_CRYPTO_EC_GROUP_SECP256R1; + *bytesize = 32; + } else if (strcmp(name, "secp384r1") == 0) { + *curve = RTE_CRYPTO_EC_GROUP_SECP384R1; + *bytesize = 48; + } else if (strcmp(name, "secp521r1") == 0) { + *curve = RTE_CRYPTO_EC_GROUP_SECP521R1; + *bytesize = 66; + } else { + return -ENOTSUP; + } + return 0; +} + +/* Left-align an unsigned big-endian value into a fixed-width field. */ +static bool +value_equals_padded(const uint8_t *a, uint32_t a_len, const uint8_t *b, uint32_t b_len) +{ + while (a_len > 0 && a[0] == 0) { + a++; + a_len--; + } + while (b_len > 0 && b[0] == 0) { + b++; + b_len--; + } + return a_len == b_len && memcmp(a, b, a_len) == 0; +} + +/* Left-pad a big-endian value into a fixed-width field: strip leading zeros, + * reject values wider than the field, zero-pad the remaining prefix. + */ +static int +normalize_operand(const uint8_t *value, uint32_t value_len, uint8_t *out, uint32_t bytesize) +{ + while (value_len > 0 && value[0] == 0) { + value++; + value_len--; + } + if (value_len > bytesize) + return -EINVAL; + memset(out, 0, bytesize); + memcpy(out + bytesize - value_len, value, value_len); + return 0; +} + +static int +run_ecdh_ecpoint(enum rte_crypto_curve_id curve, uint32_t bytesize, + const uint8_t *priv, uint32_t priv_len, const uint8_t *pub_x, + const uint8_t *pub_y, uint8_t **shared_x, uint32_t *shared_len, + enum rte_crypto_op_status *status) +{ + struct rte_crypto_asym_xform xform = { 0 }; + void *session = NULL; + struct rte_crypto_op *op = NULL; + struct rte_crypto_op *completed = NULL; + struct rte_cryptodev_info dev_info; + struct rte_cryptodev_asym_capability_idx index = { + .type = RTE_CRYPTO_ASYM_XFORM_ECDH, + }; + const struct rte_cryptodev_asymmetric_xform_capability *capability; + uint8_t *out_x = NULL; + uint8_t *out_y = NULL; + uint8_t priv_buf[MAX_EC_BYTESIZE]; + int ret; + + *shared_x = NULL; + if (env.asym_session_pool == NULL || env.asym_op_pool == NULL) + return -ENOTSUP; + rte_cryptodev_info_get(env.dev_id, &dev_info); + if ((dev_info.feature_flags & RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO) == 0) + return -ENOTSUP; + capability = rte_cryptodev_asym_capability_get(env.dev_id, &index); + if (capability == NULL) + return -ENOTSUP; + if (rte_cryptodev_asym_xform_capability_check_optype(capability, + (enum rte_crypto_asym_op_type) + RTE_CRYPTO_ASYM_KE_SHARED_SECRET_COMPUTE) == 0) + return -ENOTSUP; + + if (bytesize > sizeof(priv_buf)) + return -ENOTSUP; + if (normalize_operand(priv, priv_len, priv_buf, bytesize) != 0) + return -EINVAL; + + xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ECDH; + xform.next = NULL; + xform.ec.curve_id = curve; + xform.ec.pkey.data = priv_buf; + xform.ec.pkey.length = bytesize; + xform.ec.q.x.data = (uint8_t *)(uintptr_t)pub_x; + xform.ec.q.x.length = bytesize; + xform.ec.q.y.data = (uint8_t *)(uintptr_t)pub_y; + xform.ec.q.y.length = bytesize; + + ret = -ENOMEM; + out_x = rte_zmalloc(NULL, bytesize, 0); + out_y = rte_zmalloc(NULL, bytesize, 0); + if (out_x == NULL || out_y == NULL) + goto out; + /* Coarse capability check cannot confirm curve support; treat a + * session-create failure as unsupported rather than a hard failure. + */ + if (rte_cryptodev_asym_session_create(env.dev_id, &xform, env.asym_session_pool, + &session) < 0 || session == NULL) { + ret = -ENOTSUP; + goto out; + } + op = rte_crypto_op_alloc(env.asym_op_pool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC); + if (op == NULL) + goto out; + op->asym->ecdh.ke_type = RTE_CRYPTO_ASYM_KE_SHARED_SECRET_COMPUTE; + op->asym->ecdh.priv_key.data = priv_buf; + op->asym->ecdh.priv_key.length = bytesize; + op->asym->ecdh.pub_key.x.data = (uint8_t *)(uintptr_t)pub_x; + op->asym->ecdh.pub_key.x.length = bytesize; + op->asym->ecdh.pub_key.y.data = (uint8_t *)(uintptr_t)pub_y; + op->asym->ecdh.pub_key.y.length = bytesize; + op->asym->ecdh.shared_secret.x.data = out_x; + op->asym->ecdh.shared_secret.x.length = bytesize; + op->asym->ecdh.shared_secret.y.data = out_y; + op->asym->ecdh.shared_secret.y.length = bytesize; + rte_crypto_op_attach_asym_session(op, session); + if (rte_cryptodev_enqueue_burst(env.dev_id, 0, &op, 1) != 1) { + ret = -EIO; + goto out; + } + completed = dequeue_one(env.dev_id); + if (completed == NULL) + /* Device wedged: op still owned by the PMD. Abort without freeing + * in-flight state; teardown stops the device. + */ + return -ETIMEDOUT; + *status = completed->status; + if (completed->status == RTE_CRYPTO_OP_STATUS_SUCCESS) { + *shared_x = out_x; + *shared_len = completed->asym->ecdh.shared_secret.x.length; + out_x = NULL; + } + ret = 0; + +out: + /* The private key was copied into the stack buffer; wipe it. */ + rte_memzero_explicit(priv_buf, sizeof(priv_buf)); + rte_free(out_x); + rte_free(out_y); + rte_crypto_op_free(op); + if (session != NULL) + rte_cryptodev_asym_session_free(env.dev_id, session); + return ret; +} + +static int +process_ecdh_ecpoint(json_t *root, const char *name, struct app_stats *stats) +{ + json_t *groups = json_object_get(root, "testGroups"); + json_t *group; + size_t group_index; + + if (!json_is_array(groups)) + return -EINVAL; + json_array_foreach(groups, group_index, group) { + json_t *tests = json_object_get(group, "tests"); + enum rte_crypto_curve_id curve; + uint32_t bytesize; + const char *curve_name; + json_t *test; + size_t test_index; + + if (!json_is_array(tests)) + return -EINVAL; + curve_name = json_string_value(json_object_get(group, "curve")); + if (curve_name == NULL || map_curve(curve_name, &curve, &bytesize) != 0) { + stats->skipped_unsupported++; + continue; + } + json_array_foreach(tests, test_index, test) { + struct wycheproof_data vector; + uint8_t *pub = NULL; + uint8_t *priv = NULL; + uint8_t *shared = NULL; + uint8_t *result_x = NULL; + uint32_t pub_len = 0, priv_len = 0, shared_len = 0, result_len = 0; + enum rte_crypto_op_status status = RTE_CRYPTO_OP_STATUS_ERROR; + bool matched; + json_t *tc_id; + int ret; + + memset(&vector, 0, sizeof(vector)); + tc_id = json_object_get(test, "tcId"); + vector.result = json_string_value(json_object_get(test, "result")); + if (!json_is_integer(tc_id) || vector.result == NULL) { + stats->skipped_unsupported++; + continue; + } + vector.tc_id = json_integer_value(tc_id); + if (decode_hex(json_object_get(test, "public"), &pub, &pub_len) != 0 || + decode_hex(json_object_get(test, "private"), &priv, + &priv_len) != 0 || + decode_hex(json_object_get(test, "shared"), &shared, + &shared_len) != 0) { + rte_free(pub); + rte_free_sensitive(priv); + rte_free(shared); + stats->skipped_unsupported++; + continue; + } + if (strcmp(vector.result, "acceptable") == 0) { + stats->skipped_acceptable++; + debug_vector("SKIP", name, &vector, "acceptable result policy"); + goto next; + } + /* Only uncompressed points (0x04 || x || y) map to the DPDK EC point. */ + if (pub_len != 1 + 2 * bytesize || pub[0] != 0x04) { + debug_vector("SKIP", name, &vector, + "non-uncompressed public point"); + stats->skipped_unsupported++; + goto next; + } + /* Invalid-curve rejection cases carry no expected shared secret; + * on-curve validation is a separate ECDH PUB_KEY_VERIFY op, not + * part of the raw shared-secret compute primitive. + */ + if (shared_len == 0) { + debug_vector("SKIP", name, &vector, + "no shared secret (point validation out of scope)"); + stats->skipped_unsupported++; + goto next; + } + ret = run_ecdh_ecpoint(curve, bytesize, priv, priv_len, pub + 1, + pub + 1 + bytesize, &result_x, &result_len, &status); + if (ret == -ENOTSUP) { + stats->skipped_capability++; + debug_vector("SKIP", name, &vector, "PMD capability"); + goto next; + } + if (ret == -ETIMEDOUT) + return -ETIMEDOUT; + if (ret == -EINVAL) { + stats->skipped_unsupported++; + debug_vector("SKIP", name, &vector, "operand wider than curve"); + goto next; + } + if (ret != 0) { + debug_vector("FAIL", name, &vector, "shared-secret computation failed"); + stats->failed++; + goto next; + } + matched = ret == 0 && status == RTE_CRYPTO_OP_STATUS_SUCCESS && + value_equals_padded(result_x, result_len, shared, shared_len); + if (strcmp(vector.result, "valid") == 0) { + if (ret == 0 && status == RTE_CRYPTO_OP_STATUS_SUCCESS && matched) { + stats->passed++; + } else if (ret == 0 && status == RTE_CRYPTO_OP_STATUS_SUCCESS) { + debug_vector("FAIL", name, &vector, "wrong shared secret"); + stats->failed++; + } else { + /* PMD returned an error for a valid vector. */ + debug_vector("FAIL", name, &vector, + "PMD could not compute"); + stats->failed++; + } + } else if (strcmp(vector.result, "invalid") == 0) { + if (matched) { + debug_vector("FAIL", name, &vector, + "produced forbidden secret"); + stats->failed++; + } else { + stats->passed++; + } + } else { + stats->skipped_unsupported++; + debug_vector("SKIP", name, &vector, "unknown result"); + } +next: + rte_free(result_x); + rte_free(pub); + rte_free_sensitive(priv); + rte_free(shared); + } + } + return 0; +} + +struct ecdsa_group { + uint8_t *wx; + uint8_t *wy; + uint32_t wx_len; + uint32_t wy_len; + enum rte_crypto_curve_id curve; + uint32_t bytesize; + enum rte_crypto_auth_algorithm hash; + uint32_t digest_len; +}; + +static int +run_ecdsa_verify(const struct ecdsa_group *group, const uint8_t *msg, uint32_t msg_len, + const uint8_t *r, uint32_t r_len, const uint8_t *s, uint32_t s_len, + enum rte_crypto_op_status *status) +{ + struct rte_crypto_asym_xform xform = { 0 }; + void *session = NULL; + struct rte_crypto_op *op = NULL; + struct rte_crypto_op *completed = NULL; + struct rte_cryptodev_info dev_info; + struct rte_cryptodev_asym_capability_idx index = { + .type = RTE_CRYPTO_ASYM_XFORM_ECDSA, + }; + const struct rte_cryptodev_asymmetric_xform_capability *capability; + uint8_t digest[64]; + uint8_t wx_buf[MAX_EC_BYTESIZE]; + uint8_t wy_buf[MAX_EC_BYTESIZE]; + uint32_t e_len; + int ret; + + if (env.asym_session_pool == NULL || env.asym_op_pool == NULL) + return -ENOTSUP; + rte_cryptodev_info_get(env.dev_id, &dev_info); + if ((dev_info.feature_flags & RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO) == 0) + return -ENOTSUP; + capability = rte_cryptodev_asym_capability_get(env.dev_id, &index); + if (capability == NULL || rte_cryptodev_asym_xform_capability_check_optype(capability, + RTE_CRYPTO_ASYM_OP_VERIFY) == 0) + return -ENOTSUP; + + ret = compute_hash(msg, msg_len, group->hash, digest, group->digest_len); + if (ret != 0) + return ret; + /* ECDSA uses e = leftmost Ln bits of the hash (byte-aligned truncation). */ + e_len = group->digest_len > group->bytesize ? group->bytesize : group->digest_len; + + if (group->bytesize > sizeof(wx_buf)) + return -ENOTSUP; + if (normalize_operand(group->wx, group->wx_len, wx_buf, group->bytesize) != 0 || + normalize_operand(group->wy, group->wy_len, wy_buf, group->bytesize) != 0) + return -EINVAL; + + xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ECDSA; + xform.next = NULL; + xform.ec.curve_id = group->curve; + xform.ec.q.x.data = wx_buf; + xform.ec.q.x.length = group->bytesize; + xform.ec.q.y.data = wy_buf; + xform.ec.q.y.length = group->bytesize; + + /* Coarse capability check cannot confirm curve support; treat a + * session-create failure as unsupported rather than a hard failure. + */ + if (rte_cryptodev_asym_session_create(env.dev_id, &xform, env.asym_session_pool, + &session) < 0 || session == NULL) { + ret = -ENOTSUP; + goto out; + } + ret = -ENOMEM; + op = rte_crypto_op_alloc(env.asym_op_pool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC); + if (op == NULL) + goto out; + op->asym->ecdsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY; + op->asym->ecdsa.message.data = digest; + op->asym->ecdsa.message.length = e_len; + op->asym->ecdsa.r.data = (uint8_t *)(uintptr_t)r; + op->asym->ecdsa.r.length = r_len; + op->asym->ecdsa.s.data = (uint8_t *)(uintptr_t)s; + op->asym->ecdsa.s.length = s_len; + rte_crypto_op_attach_asym_session(op, session); + if (rte_cryptodev_enqueue_burst(env.dev_id, 0, &op, 1) != 1) { + ret = -EIO; + goto out; + } + completed = dequeue_one(env.dev_id); + if (completed == NULL) + /* Device wedged: op still owned by the PMD. Abort without freeing + * in-flight state; teardown stops the device. + */ + return -ETIMEDOUT; + *status = completed->status; + ret = 0; + +out: + rte_crypto_op_free(op); + if (session != NULL) + rte_cryptodev_asym_session_free(env.dev_id, session); + return ret; +} + +static int +process_ecdsa_p1363(json_t *root, const char *name, struct app_stats *stats) +{ + json_t *groups = json_object_get(root, "testGroups"); + json_t *group; + size_t group_index; + + if (!json_is_array(groups)) + return -EINVAL; + json_array_foreach(groups, group_index, group) { + json_t *pub = json_object_get(group, "publicKey"); + json_t *tests = json_object_get(group, "tests"); + struct ecdsa_group ec = { 0 }; + const char *sha; + const char *curve_name; + json_t *test; + size_t test_index; + + if (!json_is_object(pub) || !json_is_array(tests)) + return -EINVAL; + sha = json_string_value(json_object_get(group, "sha")); + curve_name = json_string_value(json_object_get(pub, "curve")); + if (sha == NULL || curve_name == NULL || + map_sha(sha, &ec.hash, &ec.digest_len) != 0 || + map_curve(curve_name, &ec.curve, &ec.bytesize) != 0) { + stats->skipped_unsupported++; + continue; + } + if (decode_hex(json_object_get(pub, "wx"), &ec.wx, &ec.wx_len) != 0 || + decode_hex(json_object_get(pub, "wy"), &ec.wy, &ec.wy_len) != 0) { + rte_free(ec.wx); + rte_free(ec.wy); + stats->skipped_unsupported++; + continue; + } + json_array_foreach(tests, test_index, test) { + struct wycheproof_data vector; + uint8_t *sig = NULL; + uint32_t sig_len = 0; + enum rte_crypto_op_status status = RTE_CRYPTO_OP_STATUS_ERROR; + json_t *tc_id; + int ret; + + memset(&vector, 0, sizeof(vector)); + tc_id = json_object_get(test, "tcId"); + vector.result = json_string_value(json_object_get(test, "result")); + if (!json_is_integer(tc_id) || vector.result == NULL) { + stats->skipped_unsupported++; + continue; + } + vector.tc_id = json_integer_value(tc_id); + if (decode_hex(json_object_get(test, "msg"), &vector.msg, + &vector.msg_len) != 0 || + decode_hex(json_object_get(test, "sig"), + &sig, &sig_len) != 0) { + rte_free(vector.msg); + rte_free(sig); + stats->skipped_unsupported++; + continue; + } + if (strcmp(vector.result, "acceptable") == 0) { + stats->skipped_acceptable++; + debug_vector("SKIP", name, &vector, "acceptable result policy"); + rte_free(vector.msg); + rte_free(sig); + continue; + } + if (sig_len != 2 * ec.bytesize) { + debug_vector("SKIP", name, &vector, + "non-canonical P1363 signature size"); + stats->skipped_unsupported++; + rte_free(vector.msg); + rte_free(sig); + continue; + } + ret = run_ecdsa_verify(&ec, vector.msg, vector.msg_len, sig, sig_len / 2, + sig + sig_len / 2, sig_len / 2, &status); + if (ret == -ENOTSUP) { + stats->skipped_capability++; + debug_vector("SKIP", name, &vector, "PMD capability"); + } else if (ret == -ETIMEDOUT) { + return -ETIMEDOUT; + } else if (ret == -EMSGSIZE) { + stats->skipped_unsupported++; + debug_vector("SKIP", name, &vector, "message length exceeds mbuf"); + } else if (ret == -EINVAL) { + stats->skipped_unsupported++; + debug_vector("SKIP", name, &vector, "operand wider than curve"); + } else if (ret != 0) { + debug_vector("FAIL", name, &vector, "signature verification failed"); + stats->failed++; + } else if (strcmp(vector.result, "valid") == 0) { + if (ret == 0 && status == RTE_CRYPTO_OP_STATUS_SUCCESS) + stats->passed++; + else { + debug_vector("FAIL", name, &vector, + "valid signature rejected"); + stats->failed++; + } + } else if (strcmp(vector.result, "invalid") == 0) { + if (ret == 0 && status == RTE_CRYPTO_OP_STATUS_SUCCESS) { + debug_vector("FAIL", name, &vector, + "invalid signature accepted"); + stats->failed++; + } else { + stats->passed++; + } + } else { + stats->skipped_unsupported++; + debug_vector("SKIP", name, &vector, "unknown result"); + } + rte_free(vector.msg); + rte_free(sig); + } + rte_free(ec.wx); + rte_free(ec.wy); + } + return 0; +} + +static int +process_file(const char *path, struct app_stats *stats) +{ + json_error_t error; + json_t *root; + const char *algorithm; + const char *schema; + int ret; + + root = json_load_file(path, 0, &error); + if (root == NULL) { + printf("Cannot load %s: JSON error at line %d: %s\n", path, error.line, + error.text); + return -EINVAL; + } + algorithm = json_string_value(json_object_get(root, "algorithm")); + schema = json_string_value(json_object_get(root, "schema")); + if (algorithm == NULL || schema == NULL) { + debug_file("SKIP", path, "missing algorithm or schema"); + stats->skipped_unsupported++; + json_decref(root); + return 0; + } + if (strcmp(algorithm, "AES-GCM") == 0 && + strcmp(schema, "aead_test_schema_v1.json") == 0) { + printf("Processing AES-GCM vectors: %s\n", path); + ret = process_aead(root, RTE_CRYPTO_AEAD_AES_GCM, "AES-GCM", stats); + } else if (strcmp(algorithm, "AES-CCM") == 0 && + strcmp(schema, "aead_test_schema_v1.json") == 0) { + printf("Processing AES-CCM vectors: %s\n", path); + ret = process_aead(root, RTE_CRYPTO_AEAD_AES_CCM, "AES-CCM", stats); + } else if (strcmp(algorithm, "CHACHA20-POLY1305") == 0 && + strcmp(schema, "aead_test_schema_v1.json") == 0) { + printf("Processing ChaCha20-Poly1305 vectors: %s\n", path); + ret = process_aead(root, RTE_CRYPTO_AEAD_CHACHA20_POLY1305, + "ChaCha20-Poly1305", stats); + } else if (strcmp(algorithm, "SM4-GCM") == 0 && + strcmp(schema, "aead_test_schema_v1.json") == 0) { + printf("Processing SM4-GCM vectors: %s\n", path); + ret = process_aead(root, RTE_CRYPTO_AEAD_SM4_GCM, "SM4-GCM", stats); + } else if (strcmp(algorithm, "HMACSHA256") == 0 && + strcmp(schema, "mac_test_schema_v1.json") == 0) { + printf("Processing HMAC-SHA256 vectors: %s\n", path); + ret = process_hmac(root, RTE_CRYPTO_AUTH_SHA256_HMAC, "HMAC-SHA256", stats); + } else if (strcmp(algorithm, "HMACSHA1") == 0 && + strcmp(schema, "mac_test_schema_v1.json") == 0) { + printf("Processing HMAC-SHA1 vectors: %s\n", path); + ret = process_hmac(root, RTE_CRYPTO_AUTH_SHA1_HMAC, "HMAC-SHA1", stats); + } else if (strcmp(algorithm, "HMACSHA224") == 0 && + strcmp(schema, "mac_test_schema_v1.json") == 0) { + printf("Processing HMAC-SHA224 vectors: %s\n", path); + ret = process_hmac(root, RTE_CRYPTO_AUTH_SHA224_HMAC, "HMAC-SHA224", stats); + } else if (strcmp(algorithm, "HMACSHA384") == 0 && + strcmp(schema, "mac_test_schema_v1.json") == 0) { + printf("Processing HMAC-SHA384 vectors: %s\n", path); + ret = process_hmac(root, RTE_CRYPTO_AUTH_SHA384_HMAC, "HMAC-SHA384", stats); + } else if (strcmp(algorithm, "HMACSHA512") == 0 && + strcmp(schema, "mac_test_schema_v1.json") == 0) { + printf("Processing HMAC-SHA512 vectors: %s\n", path); + ret = process_hmac(root, RTE_CRYPTO_AUTH_SHA512_HMAC, "HMAC-SHA512", stats); + } else if (strcmp(algorithm, "HMACSHA3-224") == 0 && + strcmp(schema, "mac_test_schema_v1.json") == 0) { + printf("Processing HMAC-SHA3-224 vectors: %s\n", path); + ret = process_hmac(root, RTE_CRYPTO_AUTH_SHA3_224_HMAC, "HMAC-SHA3-224", stats); + } else if (strcmp(algorithm, "HMACSHA3-256") == 0 && + strcmp(schema, "mac_test_schema_v1.json") == 0) { + printf("Processing HMAC-SHA3-256 vectors: %s\n", path); + ret = process_hmac(root, RTE_CRYPTO_AUTH_SHA3_256_HMAC, "HMAC-SHA3-256", stats); + } else if (strcmp(algorithm, "HMACSHA3-384") == 0 && + strcmp(schema, "mac_test_schema_v1.json") == 0) { + printf("Processing HMAC-SHA3-384 vectors: %s\n", path); + ret = process_hmac(root, RTE_CRYPTO_AUTH_SHA3_384_HMAC, "HMAC-SHA3-384", stats); + } else if (strcmp(algorithm, "HMACSHA3-512") == 0 && + strcmp(schema, "mac_test_schema_v1.json") == 0) { + printf("Processing HMAC-SHA3-512 vectors: %s\n", path); + ret = process_hmac(root, RTE_CRYPTO_AUTH_SHA3_512_HMAC, "HMAC-SHA3-512", stats); + } else if (strcmp(algorithm, "HMACSM3") == 0 && + strcmp(schema, "mac_test_schema_v1.json") == 0) { + printf("Processing HMAC-SM3 vectors: %s\n", path); + ret = process_hmac(root, RTE_CRYPTO_AUTH_SM3_HMAC, "HMAC-SM3", stats); + } else if (strcmp(algorithm, "AES-CMAC") == 0 && + strcmp(schema, "mac_test_schema_v1.json") == 0) { + printf("Processing AES-CMAC vectors: %s\n", path); + ret = process_hmac(root, RTE_CRYPTO_AUTH_AES_CMAC, "AES-CMAC", stats); + } else if (strcmp(algorithm, "AES-GMAC") == 0 && + strcmp(schema, "mac_with_iv_test_schema_v1.json") == 0) { + printf("Processing AES-GMAC vectors: %s\n", path); + ret = process_gmac(root, stats); + } else if (strcmp(algorithm, "DSA") == 0 && + strcmp(schema, "dsa_p1363_verify_schema_v1.json") == 0) { + printf("Processing DSA (P1363) vectors: %s\n", path); + ret = process_dsa_p1363(root, "DSA", stats); + } else if (strcmp(algorithm, "ECDH") == 0 && + strcmp(schema, "ecdh_ecpoint_test_schema_v1.json") == 0) { + printf("Processing ECDH (ecpoint) vectors: %s\n", path); + ret = process_ecdh_ecpoint(root, "ECDH", stats); + } else if (strcmp(algorithm, "ECDSA") == 0 && + strcmp(schema, "ecdsa_p1363_verify_schema_v1.json") == 0) { + printf("Processing ECDSA (P1363) vectors: %s\n", path); + ret = process_ecdsa_p1363(root, "ECDSA", stats); + } else if (strncmp(algorithm, "AES-", strlen("AES-")) == 0 || + strncmp(algorithm, "SEED-", strlen("SEED-")) == 0 || + strcmp(algorithm, "SM4-CCM") == 0 || + strncmp(algorithm, "HMAC", strlen("HMAC")) == 0 || + strncmp(algorithm, "RSA", strlen("RSA")) == 0 || + strcmp(algorithm, "DSA") == 0 || + strcmp(algorithm, "ECDH") == 0 || + strcmp(algorithm, "ECDSA") == 0) { + debug_file("SKIP", path, algorithm); + stats->skipped_unsupported++; + ret = 0; + } else { + debug_file("SKIP", path, "unsupported vector file"); + stats->skipped_unsupported++; + ret = 0; + } + json_decref(root); + return ret; +} + +static int +process_path(const char *path, struct app_stats *stats) +{ + struct stat path_stat; + DIR *directory; + struct dirent *entry; + int ret = 0; + + if (stat(path, &path_stat) != 0) + return -errno; + if (!S_ISDIR(path_stat.st_mode)) + return process_file(path, stats); + + directory = opendir(path); + if (directory == NULL) + return -errno; + while ((entry = readdir(directory)) != NULL) { + char file_path[PATH_MAX]; + size_t name_length = strlen(entry->d_name); + + if (name_length < 6 || strcmp(entry->d_name + name_length - 5, ".json") != 0) + continue; + if (snprintf(file_path, sizeof(file_path), "%s/%s", path, entry->d_name) >= + (int)sizeof(file_path)) { + ret = -ENAMETOOLONG; + break; + } + ret = process_file(file_path, stats); + if (ret != 0) + break; + } + closedir(directory); + return ret; +} + +int +main(int argc, char **argv) +{ + struct app_stats stats = { 0 }; + const char *prgname = argv[0]; + int eal_args; + int ret; + + eal_args = rte_eal_init(argc, argv); + if (eal_args < 0) + rte_exit(EXIT_FAILURE, "Cannot initialize EAL\n"); + argc -= eal_args; + argv += eal_args; + + ret = parse_args(argc, argv); + if (ret != 0) { + usage(prgname); + ret = EXIT_FAILURE; + goto out_eal; + } + ret = app_init(); + if (ret != 0) { + printf("Cannot initialize cryptodev %u: %s\n", env.dev_id, rte_strerror(-ret)); + ret = EXIT_FAILURE; + goto out_eal; + } + + ret = process_path(env.vectors_path, &stats); + if (ret != 0) + printf("Vector processing failed: %s\n", rte_strerror(-ret)); + printf("Summary: passed=%" PRIu64 " failed=%" PRIu64 + " skipped_capability=%" PRIu64 " skipped_acceptable=%" PRIu64 + " skipped_unsupported=%" PRIu64 "\n", stats.passed, stats.failed, + stats.skipped_capability, stats.skipped_acceptable, stats.skipped_unsupported); + app_uninit(); + ret = ret == 0 && stats.failed == 0 ? EXIT_SUCCESS : EXIT_FAILURE; + +out_eal: + rte_eal_cleanup(); + return ret; +} diff --git a/app/wycheproof_validation/meson.build b/app/wycheproof_validation/meson.build new file mode 100644 index 0000000000..e032144bb4 --- /dev/null +++ b/app/wycheproof_validation/meson.build @@ -0,0 +1,20 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2026 + +# meson file, for building this application as part of a main DPDK build. + +if is_windows + build = false + reason = 'not supported on Windows' + subdir_done() +endif + +deps += ['cryptodev'] + +if not dpdk_conf.has('RTE_HAS_JANSSON') + build = false + message('Skipping wycheproof_validation: Jansson is required') +else + ext_deps += jansson_dep + sources = files('main.c') +endif diff --git a/doc/guides/rel_notes/release_26_11.rst b/doc/guides/rel_notes/release_26_11.rst index 8ca8379cc6..20304c6a5f 100644 --- a/doc/guides/rel_notes/release_26_11.rst +++ b/doc/guides/rel_notes/release_26_11.rst @@ -340,6 +340,12 @@ New Features Added ``dpdk-validate-bpf`` tool to pre-validate eBPF programs for compatibility with the ``lib/bpf`` execution context. +* **Added Wycheproof validation application.** + + Added a new application that validates a DPDK cryptodev PMD against + the Google Wycheproof JSON test vectors, covering AEAD, MAC, DSA, ECDH and + ECDSA algorithm families. + Removed Items ------------- diff --git a/doc/guides/sample_app_ug/crypto_validation.rst b/doc/guides/sample_app_ug/crypto_validation.rst index 67b9e2d351..a1a885cb6e 100644 --- a/doc/guides/sample_app_ug/crypto_validation.rst +++ b/doc/guides/sample_app_ug/crypto_validation.rst @@ -170,3 +170,53 @@ data files in one folder for crypto_aesni_gcm PMD, issue the command: --req-file /PATH/TO/REQUEST/FILE/FOLDER/ --rsp-file ./PATH/TO/RESPONSE/FILE/FOLDER/ --cryptodev-id 0 --path-is-folder + +Wycheproof Validation +--------------------- + +Overview +~~~~~~~~ + +This application validates a DPDK cryptodev implementation against the Google +Wycheproof JSON test vectors. + +The application reads one JSON file or a directory of JSON files at runtime and +checks the supported algorithm families against the selected PMD. It can be used +with a PMD that advertises AEAD, MAC, DSA, ECDH, or ECDSA support. + +Build +~~~~~ + +Build the application from the DPDK tree with Meson: + +.. code-block:: console + + meson setup build -Denable_apps=wycheproof_validation \ + -Denable_drivers=crypto/openssl + meson compile -C build + +Run +~~~ + +Run the application with an OpenSSL-backed cryptodev and a vector file: + +.. code-block:: console + + ./build/app/dpdk-wycheproof_validation --vdev crypto_openssl -- \ + --vectors ../wycheproof/testvectors_v1/aes_gcm_test.json \ + --cryptodev crypto_openssl --debug + +The program accepts a single JSON file or a directory of JSON files. Use +``--debug`` to print each failed or skipped vector with its reason. The +``--mbuf-dataroom`` option sets the mbuf data room size in bytes +(default 16384); vectors with messages larger than the data room minus the +mbuf headroom are skipped, so increase it to cover larger messages. + +Asymmetric coverage (DSA, ECDH, ECDSA) requires a PMD that advertises the +corresponding asymmetric xform capabilities. The ``crypto_openssl`` PMD used +above does not advertise the ECDSA or ECDH xforms, so those vectors are skipped; +select a PMD that advertises them to exercise the asymmetric families. + +The exit code is nonzero when a parsed and supported vector fails validation; +unsupported vectors, capability-skipped cases, and acceptable results are reported +in the summary without forcing a failure. -- 2.34.1
