#include <rte_memcpy.h>
#include <rte_pause.h>
#include <rte_bus_vdev.h>
+#include <rte_ether.h>
#include <rte_crypto.h>
#include <rte_cryptodev.h>
#ifdef RTE_LIBRTE_SECURITY
#include "test_cryptodev_security_pdcp_test_vectors.h"
#include "test_cryptodev_security_pdcp_test_func.h"
+#include "test_cryptodev_security_docsis_test_vectors.h"
#endif
#define VDEV_ARGS_SIZE 100
struct rte_crypto_sym_xform cipher_xform;
struct rte_crypto_sym_xform auth_xform;
struct rte_crypto_sym_xform aead_xform;
+#ifdef RTE_LIBRTE_SECURITY
+ struct rte_security_docsis_xform docsis_xform;
+#endif
union {
struct rte_cryptodev_sym_session *sess;
struct crypto_testsuite_params *ts_params = &testsuite_params;
uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
- /* This test is for QAT and NITROX PMDs only */
- if (gbl_driver_id != rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)) &&
- gbl_driver_id != rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_NITROX_PMD)))
- return -ENOTSUP;
-
/* Stop the device in case it's started so it can be configured */
rte_cryptodev_stop(ts_params->valid_devs[0]);
- /* valid - one queue pairs */
- ts_params->conf.nb_queue_pairs = 1;
+ /* valid - max value queue pairs */
+ ts_params->conf.nb_queue_pairs = orig_nb_qps;
TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
&ts_params->conf),
"Failed to configure cryptodev: dev_id %u, qp_id %u",
ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
-
- /* valid - max value queue pairs */
- ts_params->conf.nb_queue_pairs = orig_nb_qps;
+ /* valid - one queue pairs */
+ ts_params->conf.nb_queue_pairs = 1;
TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
&ts_params->conf),
test_queue_pair_descriptor_setup(void)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct rte_cryptodev_info dev_info;
struct rte_cryptodev_qp_conf qp_conf = {
.nb_descriptors = MAX_NUM_OPS_INFLIGHT
};
-
uint16_t qp_id;
- /* This test is for QAT PMD only */
- if (gbl_driver_id != rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)))
- return -ENOTSUP;
-
/* Stop the device in case it's started so it can be configured */
rte_cryptodev_stop(ts_params->valid_devs[0]);
-
- rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
-
TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
&ts_params->conf),
"Failed to configure cryptodev %u",
ts_params->valid_devs[0]);
}
- /* invalid number of descriptors - max supported + 2 */
- qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
-
- for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
- TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
- ts_params->valid_devs[0], qp_id, &qp_conf,
- rte_cryptodev_socket_id(
- ts_params->valid_devs[0])),
- "Unexpectedly passed test for "
- "rte_cryptodev_queue_pair_setup:"
- "num_inflights %u on qp %u on cryptodev %u",
- qp_conf.nb_descriptors, qp_id,
- ts_params->valid_devs[0]);
- }
-
- /* invalid number of descriptors - max value of parameter */
- qp_conf.nb_descriptors = UINT32_MAX-1;
-
- for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
- TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
- ts_params->valid_devs[0], qp_id, &qp_conf,
- rte_cryptodev_socket_id(
- ts_params->valid_devs[0])),
- "Unexpectedly passed test for "
- "rte_cryptodev_queue_pair_setup:"
- "num_inflights %u on qp %u on cryptodev %u",
- qp_conf.nb_descriptors, qp_id,
- ts_params->valid_devs[0]);
- }
-
qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
ts_params->valid_devs[0]);
}
- /* invalid number of descriptors - max supported + 1 */
- qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
-
- for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
- TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
- ts_params->valid_devs[0], qp_id, &qp_conf,
- rte_cryptodev_socket_id(
- ts_params->valid_devs[0])),
- "Unexpectedly passed test for "
- "rte_cryptodev_queue_pair_setup:"
- "num_inflights %u on qp %u on cryptodev %u",
- qp_conf.nb_descriptors, qp_id,
- ts_params->valid_devs[0]);
- }
-
/* test invalid queue pair id */
qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
}
#ifdef RTE_LIBRTE_SECURITY
+static int
+security_proto_supported(enum rte_security_session_protocol proto)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+
+ const struct rte_security_capability *capabilities;
+ const struct rte_security_capability *capability;
+ uint16_t i = 0;
+
+ struct rte_security_ctx *ctx = (struct rte_security_ctx *)
+ rte_cryptodev_get_sec_ctx(
+ ts_params->valid_devs[0]);
+
+
+ capabilities = rte_security_capabilities_get(ctx);
+
+ if (capabilities == NULL)
+ return -ENOTSUP;
+
+ while ((capability = &capabilities[i++])->action !=
+ RTE_SECURITY_ACTION_TYPE_NONE) {
+ if (capability->protocol == proto)
+ return 0;
+ }
+
+ return -ENOTSUP;
+}
+
/* Basic algorithm run function for async inplace mode.
* Creates a session from input parameters and runs one operation
* on input_vec. Checks the output of the crypto operation against
ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
ut_params->cipher_xform.cipher.key.length =
pdcp_test_params[i].cipher_key_len;
- ut_params->cipher_xform.cipher.iv.length = 0;
+ ut_params->cipher_xform.cipher.iv.length =
+ pdcp_test_packet_direction[i] ? 4 : 0;
+ ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
/* Setup HMAC Parameters if ICV header is required */
if (pdcp_test_params[i].auth_alg != 0) {
.domain = pdcp_test_params[i].domain,
.pkt_dir = pdcp_test_packet_direction[i],
.sn_size = pdcp_test_data_sn_size[i],
- .hfn = pdcp_test_hfn[i],
+ .hfn = pdcp_test_packet_direction[i] ?
+ 0 : pdcp_test_hfn[i],
+ /**
+ * hfn can be set as pdcp_test_hfn[i]
+ * if hfn_ovrd is not set. Here, PDCP
+ * packet direction is just used to
+ * run half of the cases with session
+ * HFN and other half with per packet
+ * HFN.
+ */
.hfn_threshold = pdcp_test_hfn_threshold[i],
+ .hfn_ovrd = pdcp_test_packet_direction[i] ? 1 : 0,
} },
.crypto_xform = &ut_params->cipher_xform
};
goto on_err;
}
+ uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
+ uint32_t *, IV_OFFSET);
+ *per_pkt_hfn = pdcp_test_packet_direction[i] ? pdcp_test_hfn[i] : 0;
+
rte_security_attach_session(ut_params->op, ut_params->sec_session);
/* set crypto operation source mbuf */
.sn_size = pdcp_test_data_sn_size[i],
.hfn = pdcp_test_hfn[i],
.hfn_threshold = pdcp_test_hfn_threshold[i],
+ .hfn_ovrd = 0,
} },
.crypto_xform = &ut_params->cipher_xform
};
if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
return -ENOTSUP;
+ if (security_proto_supported(RTE_SECURITY_PROTOCOL_PDCP) < 0)
+ return -ENOTSUP;
+
status = test_PDCP_PROTO_cplane_encap_all();
status += test_PDCP_PROTO_cplane_decap_all();
status += test_PDCP_PROTO_uplane_encap_all();
else
return TEST_SUCCESS;
}
-#endif
static int
-test_AES_GCM_authenticated_encryption_test_case_1(void)
+test_docsis_proto_uplink(int i, struct docsis_test_data *d_td)
{
- return test_authenticated_encryption(&gcm_test_case_1);
-}
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct crypto_unittest_params *ut_params = &unittest_params;
+ uint8_t *plaintext, *ciphertext;
+ uint8_t *iv_ptr;
+ int32_t cipher_len, crc_len;
+ uint32_t crc_data_len;
+ int ret = TEST_SUCCESS;
-static int
-test_AES_GCM_authenticated_encryption_test_case_2(void)
-{
- return test_authenticated_encryption(&gcm_test_case_2);
-}
+ struct rte_security_ctx *ctx = (struct rte_security_ctx *)
+ rte_cryptodev_get_sec_ctx(
+ ts_params->valid_devs[0]);
-static int
-test_AES_GCM_authenticated_encryption_test_case_3(void)
-{
- return test_authenticated_encryption(&gcm_test_case_3);
-}
+ /* Verify the capabilities */
+ struct rte_security_capability_idx sec_cap_idx;
+ const struct rte_security_capability *sec_cap;
+ const struct rte_cryptodev_capabilities *crypto_cap;
+ const struct rte_cryptodev_symmetric_capability *sym_cap;
+ int j = 0;
-static int
-test_AES_GCM_authenticated_encryption_test_case_4(void)
-{
- return test_authenticated_encryption(&gcm_test_case_4);
-}
+ sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
+ sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
+ sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
-static int
-test_AES_GCM_authenticated_encryption_test_case_5(void)
-{
- return test_authenticated_encryption(&gcm_test_case_5);
-}
+ sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
+ if (sec_cap == NULL)
+ return -ENOTSUP;
-static int
-test_AES_GCM_authenticated_encryption_test_case_6(void)
-{
- return test_authenticated_encryption(&gcm_test_case_6);
-}
+ while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
+ RTE_CRYPTO_OP_TYPE_UNDEFINED) {
+ if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
+ crypto_cap->sym.xform_type ==
+ RTE_CRYPTO_SYM_XFORM_CIPHER &&
+ crypto_cap->sym.cipher.algo ==
+ RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
+ sym_cap = &crypto_cap->sym;
+ if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
+ d_td->key.len,
+ d_td->iv.len) == 0)
+ break;
+ }
+ }
-static int
-test_AES_GCM_authenticated_encryption_test_case_7(void)
-{
- return test_authenticated_encryption(&gcm_test_case_7);
-}
+ if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
+ return -ENOTSUP;
-static int
-test_AES_GCM_authenticated_encryption_test_case_8(void)
-{
- return test_authenticated_encryption(&gcm_test_case_8);
-}
+ /* Setup source mbuf payload */
+ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+ rte_pktmbuf_tailroom(ut_params->ibuf));
-static int
-test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
-{
- return test_authenticated_encryption(&gcm_J0_test_case_1);
-}
+ ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+ d_td->ciphertext.len);
-static int
-test_AES_GCM_auth_encryption_test_case_192_1(void)
-{
- return test_authenticated_encryption(&gcm_test_case_192_1);
-}
+ memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
-static int
-test_AES_GCM_auth_encryption_test_case_192_2(void)
-{
- return test_authenticated_encryption(&gcm_test_case_192_2);
-}
+ /* Set session action type */
+ ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
-static int
-test_AES_GCM_auth_encryption_test_case_192_3(void)
-{
- return test_authenticated_encryption(&gcm_test_case_192_3);
-}
+ /* Setup cipher session parameters */
+ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+ ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
+ ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
+ ut_params->cipher_xform.cipher.key.data = d_td->key.data;
+ ut_params->cipher_xform.cipher.key.length = d_td->key.len;
+ ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
+ ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+ ut_params->cipher_xform.next = NULL;
-static int
-test_AES_GCM_auth_encryption_test_case_192_4(void)
-{
- return test_authenticated_encryption(&gcm_test_case_192_4);
-}
+ /* Setup DOCSIS session parameters */
+ ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
-static int
-test_AES_GCM_auth_encryption_test_case_192_5(void)
-{
- return test_authenticated_encryption(&gcm_test_case_192_5);
-}
+ struct rte_security_session_conf sess_conf = {
+ .action_type = ut_params->type,
+ .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
+ .docsis = ut_params->docsis_xform,
+ .crypto_xform = &ut_params->cipher_xform,
+ };
-static int
-test_AES_GCM_auth_encryption_test_case_192_6(void)
-{
- return test_authenticated_encryption(&gcm_test_case_192_6);
-}
+ /* Create security session */
+ ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
+ ts_params->session_priv_mpool);
-static int
-test_AES_GCM_auth_encryption_test_case_192_7(void)
-{
- return test_authenticated_encryption(&gcm_test_case_192_7);
-}
+ if (!ut_params->sec_session) {
+ printf("TestCase %s(%d) line %d: %s\n",
+ __func__, i, __LINE__, "failed to allocate session");
+ ret = TEST_FAILED;
+ goto on_err;
+ }
-static int
-test_AES_GCM_auth_encryption_test_case_256_1(void)
-{
- return test_authenticated_encryption(&gcm_test_case_256_1);
-}
+ /* Generate crypto op data structure */
+ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+ RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+ if (!ut_params->op) {
+ printf("TestCase %s(%d) line %d: %s\n",
+ __func__, i, __LINE__,
+ "failed to allocate symmetric crypto operation");
+ ret = TEST_FAILED;
+ goto on_err;
+ }
-static int
-test_AES_GCM_auth_encryption_test_case_256_2(void)
-{
- return test_authenticated_encryption(&gcm_test_case_256_2);
-}
+ /* Setup CRC operation parameters */
+ crc_len = d_td->ciphertext.no_crc == false ?
+ (d_td->ciphertext.len -
+ d_td->ciphertext.crc_offset -
+ RTE_ETHER_CRC_LEN) :
+ 0;
+ crc_len = crc_len > 0 ? crc_len : 0;
+ crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
+ ut_params->op->sym->auth.data.length = crc_len;
+ ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
+
+ /* Setup cipher operation parameters */
+ cipher_len = d_td->ciphertext.no_cipher == false ?
+ (d_td->ciphertext.len -
+ d_td->ciphertext.cipher_offset) :
+ 0;
+ cipher_len = cipher_len > 0 ? cipher_len : 0;
+ ut_params->op->sym->cipher.data.length = cipher_len;
+ ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
+
+ /* Setup cipher IV */
+ iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
+ rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
+
+ /* Attach session to operation */
+ rte_security_attach_session(ut_params->op, ut_params->sec_session);
-static int
-test_AES_GCM_auth_encryption_test_case_256_3(void)
-{
- return test_authenticated_encryption(&gcm_test_case_256_3);
-}
+ /* Set crypto operation mbufs */
+ ut_params->op->sym->m_src = ut_params->ibuf;
+ ut_params->op->sym->m_dst = NULL;
-static int
-test_AES_GCM_auth_encryption_test_case_256_4(void)
-{
- return test_authenticated_encryption(&gcm_test_case_256_4);
-}
+ /* Process crypto operation */
+ if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
+ NULL) {
+ printf("TestCase %s(%d) line %d: %s\n",
+ __func__, i, __LINE__,
+ "failed to process security crypto op");
+ ret = TEST_FAILED;
+ goto on_err;
+ }
-static int
-test_AES_GCM_auth_encryption_test_case_256_5(void)
-{
- return test_authenticated_encryption(&gcm_test_case_256_5);
-}
+ if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
+ printf("TestCase %s(%d) line %d: %s\n",
+ __func__, i, __LINE__, "crypto op processing failed");
+ ret = TEST_FAILED;
+ goto on_err;
+ }
-static int
-test_AES_GCM_auth_encryption_test_case_256_6(void)
-{
- return test_authenticated_encryption(&gcm_test_case_256_6);
-}
+ /* Validate plaintext */
+ plaintext = ciphertext;
-static int
-test_AES_GCM_auth_encryption_test_case_256_7(void)
-{
- return test_authenticated_encryption(&gcm_test_case_256_7);
+ if (memcmp(plaintext, d_td->plaintext.data,
+ d_td->plaintext.len - crc_data_len)) {
+ printf("TestCase %s(%d) line %d: %s\n",
+ __func__, i, __LINE__, "plaintext not as expected\n");
+ rte_hexdump(stdout, "expected", d_td->plaintext.data,
+ d_td->plaintext.len);
+ rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
+ ret = TEST_FAILED;
+ goto on_err;
+ }
+
+on_err:
+ rte_crypto_op_free(ut_params->op);
+ ut_params->op = NULL;
+
+ if (ut_params->sec_session)
+ rte_security_session_destroy(ctx, ut_params->sec_session);
+ ut_params->sec_session = NULL;
+
+ rte_pktmbuf_free(ut_params->ibuf);
+ ut_params->ibuf = NULL;
+
+ return ret;
}
static int
-test_AES_GCM_auth_encryption_test_case_aad_1(void)
+test_docsis_proto_downlink(int i, struct docsis_test_data *d_td)
{
- return test_authenticated_encryption(&gcm_test_case_aad_1);
-}
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct crypto_unittest_params *ut_params = &unittest_params;
+ uint8_t *plaintext, *ciphertext;
+ uint8_t *iv_ptr;
+ int32_t cipher_len, crc_len;
+ int ret = TEST_SUCCESS;
+
+ struct rte_security_ctx *ctx = (struct rte_security_ctx *)
+ rte_cryptodev_get_sec_ctx(
+ ts_params->valid_devs[0]);
+
+ /* Verify the capabilities */
+ struct rte_security_capability_idx sec_cap_idx;
+ const struct rte_security_capability *sec_cap;
+ const struct rte_cryptodev_capabilities *crypto_cap;
+ const struct rte_cryptodev_symmetric_capability *sym_cap;
+ int j = 0;
+
+ sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
+ sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
+ sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
+
+ sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
+ if (sec_cap == NULL)
+ return -ENOTSUP;
+
+ while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
+ RTE_CRYPTO_OP_TYPE_UNDEFINED) {
+ if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
+ crypto_cap->sym.xform_type ==
+ RTE_CRYPTO_SYM_XFORM_CIPHER &&
+ crypto_cap->sym.cipher.algo ==
+ RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
+ sym_cap = &crypto_cap->sym;
+ if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
+ d_td->key.len,
+ d_td->iv.len) == 0)
+ break;
+ }
+ }
+
+ if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
+ return -ENOTSUP;
+
+ /* Setup source mbuf payload */
+ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+ rte_pktmbuf_tailroom(ut_params->ibuf));
+
+ plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+ d_td->plaintext.len);
+
+ memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
+
+ /* Set session action type */
+ ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
+
+ /* Setup cipher session parameters */
+ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+ ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
+ ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
+ ut_params->cipher_xform.cipher.key.data = d_td->key.data;
+ ut_params->cipher_xform.cipher.key.length = d_td->key.len;
+ ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
+ ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+ ut_params->cipher_xform.next = NULL;
+
+ /* Setup DOCSIS session parameters */
+ ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
+
+ struct rte_security_session_conf sess_conf = {
+ .action_type = ut_params->type,
+ .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
+ .docsis = ut_params->docsis_xform,
+ .crypto_xform = &ut_params->cipher_xform,
+ };
+
+ /* Create security session */
+ ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
+ ts_params->session_priv_mpool);
+
+ if (!ut_params->sec_session) {
+ printf("TestCase %s(%d) line %d: %s\n",
+ __func__, i, __LINE__, "failed to allocate session");
+ ret = TEST_FAILED;
+ goto on_err;
+ }
+
+ /* Generate crypto op data structure */
+ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+ RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+ if (!ut_params->op) {
+ printf("TestCase %s(%d) line %d: %s\n",
+ __func__, i, __LINE__,
+ "failed to allocate security crypto operation");
+ ret = TEST_FAILED;
+ goto on_err;
+ }
+
+ /* Setup CRC operation parameters */
+ crc_len = d_td->plaintext.no_crc == false ?
+ (d_td->plaintext.len -
+ d_td->plaintext.crc_offset -
+ RTE_ETHER_CRC_LEN) :
+ 0;
+ crc_len = crc_len > 0 ? crc_len : 0;
+ ut_params->op->sym->auth.data.length = crc_len;
+ ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
+
+ /* Setup cipher operation parameters */
+ cipher_len = d_td->plaintext.no_cipher == false ?
+ (d_td->plaintext.len -
+ d_td->plaintext.cipher_offset) :
+ 0;
+ cipher_len = cipher_len > 0 ? cipher_len : 0;
+ ut_params->op->sym->cipher.data.length = cipher_len;
+ ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
+
+ /* Setup cipher IV */
+ iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
+ rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
+
+ /* Attach session to operation */
+ rte_security_attach_session(ut_params->op, ut_params->sec_session);
+
+ /* Set crypto operation mbufs */
+ ut_params->op->sym->m_src = ut_params->ibuf;
+ ut_params->op->sym->m_dst = NULL;
+
+ /* Process crypto operation */
+ if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
+ NULL) {
+ printf("TestCase %s(%d) line %d: %s\n",
+ __func__, i, __LINE__,
+ "failed to process security crypto op");
+ ret = TEST_FAILED;
+ goto on_err;
+ }
+
+ if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
+ printf("TestCase %s(%d) line %d: %s\n",
+ __func__, i, __LINE__, "crypto op processing failed");
+ ret = TEST_FAILED;
+ goto on_err;
+ }
+
+ /* Validate ciphertext */
+ ciphertext = plaintext;
+
+ if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
+ printf("TestCase %s(%d) line %d: %s\n",
+ __func__, i, __LINE__, "ciphertext not as expected\n");
+ rte_hexdump(stdout, "expected", d_td->ciphertext.data,
+ d_td->ciphertext.len);
+ rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
+ ret = TEST_FAILED;
+ goto on_err;
+ }
+
+on_err:
+ rte_crypto_op_free(ut_params->op);
+ ut_params->op = NULL;
+
+ if (ut_params->sec_session)
+ rte_security_session_destroy(ctx, ut_params->sec_session);
+ ut_params->sec_session = NULL;
+
+ rte_pktmbuf_free(ut_params->ibuf);
+ ut_params->ibuf = NULL;
+
+ return ret;
+}
+
+#define TEST_DOCSIS_COUNT(func) do { \
+ int ret = func; \
+ if (ret == TEST_SUCCESS) { \
+ printf("\t%2d)", n++); \
+ printf("+++++ PASSED:" #func"\n"); \
+ p++; \
+ } else if (ret == -ENOTSUP) { \
+ printf("\t%2d)", n++); \
+ printf("~~~~~ UNSUPP:" #func"\n"); \
+ u++; \
+ } else { \
+ printf("\t%2d)", n++); \
+ printf("----- FAILED:" #func"\n"); \
+ f++; \
+ } \
+} while (0)
+
+static int
+test_DOCSIS_PROTO_uplink_all(void)
+{
+ int p = 0, u = 0, f = 0, n = 0;
+
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(3, &docsis_test_case_3));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(4, &docsis_test_case_4));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(5, &docsis_test_case_5));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(6, &docsis_test_case_6));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(7, &docsis_test_case_7));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(8, &docsis_test_case_8));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(9, &docsis_test_case_9));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(10, &docsis_test_case_10));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(11, &docsis_test_case_11));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(12, &docsis_test_case_12));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(13, &docsis_test_case_13));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(14, &docsis_test_case_14));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(15, &docsis_test_case_15));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(16, &docsis_test_case_16));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(17, &docsis_test_case_17));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(18, &docsis_test_case_18));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(19, &docsis_test_case_19));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(20, &docsis_test_case_20));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(21, &docsis_test_case_21));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(22, &docsis_test_case_22));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(23, &docsis_test_case_23));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(24, &docsis_test_case_24));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(25, &docsis_test_case_25));
+ TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
+
+ if (f)
+ printf("## %s: %d passed out of %d (%d unsupported)\n",
+ __func__, p, n, u);
+
+ return f;
+};
static int
-test_AES_GCM_auth_encryption_test_case_aad_2(void)
+test_DOCSIS_PROTO_downlink_all(void)
+{
+ int p = 0, u = 0, f = 0, n = 0;
+
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(3, &docsis_test_case_3));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(4, &docsis_test_case_4));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(5, &docsis_test_case_5));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(6, &docsis_test_case_6));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(7, &docsis_test_case_7));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(8, &docsis_test_case_8));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(9, &docsis_test_case_9));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(10, &docsis_test_case_10));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(11, &docsis_test_case_11));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(12, &docsis_test_case_12));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(13, &docsis_test_case_13));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(14, &docsis_test_case_14));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(15, &docsis_test_case_15));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(16, &docsis_test_case_16));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(17, &docsis_test_case_17));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(18, &docsis_test_case_18));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(19, &docsis_test_case_19));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(20, &docsis_test_case_20));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(21, &docsis_test_case_21));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(22, &docsis_test_case_22));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(23, &docsis_test_case_23));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(24, &docsis_test_case_24));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(25, &docsis_test_case_25));
+ TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
+
+ if (f)
+ printf("## %s: %d passed out of %d (%d unsupported)\n",
+ __func__, p, n, u);
+
+ return f;
+};
+
+static int
+test_DOCSIS_PROTO_all(void)
{
- return test_authenticated_encryption(&gcm_test_case_aad_2);
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct rte_cryptodev_info dev_info;
+ int status;
+
+ rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+ uint64_t feat_flags = dev_info.feature_flags;
+
+ if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
+ return -ENOTSUP;
+
+ if (security_proto_supported(RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
+ return -ENOTSUP;
+
+ status = test_DOCSIS_PROTO_uplink_all();
+ status += test_DOCSIS_PROTO_downlink_all();
+
+ if (status)
+ return TEST_FAILED;
+ else
+ return TEST_SUCCESS;
}
+#endif
static int
-test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
+test_AES_GCM_authenticated_encryption_test_case_1(void)
{
- struct aead_test_data tdata;
- int res;
+ return test_authenticated_encryption(&gcm_test_case_1);
+}
- RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
- memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
- tdata.iv.data[0] += 1;
- res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
- return res;
- TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
- return TEST_SUCCESS;
+static int
+test_AES_GCM_authenticated_encryption_test_case_2(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_2);
}
static int
-test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
+test_AES_GCM_authenticated_encryption_test_case_3(void)
{
- struct aead_test_data tdata;
- int res;
+ return test_authenticated_encryption(&gcm_test_case_3);
+}
- RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
- memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
- tdata.plaintext.data[0] += 1;
- res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
- return res;
- TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
- return TEST_SUCCESS;
+static int
+test_AES_GCM_authenticated_encryption_test_case_4(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_4);
}
static int
-test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
+test_AES_GCM_authenticated_encryption_test_case_5(void)
{
- struct aead_test_data tdata;
- int res;
+ return test_authenticated_encryption(&gcm_test_case_5);
+}
- RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
- memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
- tdata.ciphertext.data[0] += 1;
- res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
- return res;
- TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
- return TEST_SUCCESS;
+static int
+test_AES_GCM_authenticated_encryption_test_case_6(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_6);
}
static int
-test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
+test_AES_GCM_authenticated_encryption_test_case_7(void)
{
- struct aead_test_data tdata;
- int res;
+ return test_authenticated_encryption(&gcm_test_case_7);
+}
- RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
- memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
- tdata.aad.len += 1;
- res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
- return res;
- TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
- return TEST_SUCCESS;
+static int
+test_AES_GCM_authenticated_encryption_test_case_8(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_8);
}
static int
-test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
+test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
{
- struct aead_test_data tdata;
- uint8_t aad[gcm_test_case_7.aad.len];
- int res;
+ return test_authenticated_encryption(&gcm_J0_test_case_1);
+}
- RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
- memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
- memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
- aad[0] += 1;
- tdata.aad.data = aad;
- res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
- return res;
- TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
- return TEST_SUCCESS;
+static int
+test_AES_GCM_auth_encryption_test_case_192_1(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_192_1);
}
static int
-test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
+test_AES_GCM_auth_encryption_test_case_192_2(void)
{
- struct aead_test_data tdata;
- int res;
+ return test_authenticated_encryption(&gcm_test_case_192_2);
+}
- RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
- memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
- tdata.auth_tag.data[0] += 1;
- res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
- return res;
- TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
- return TEST_SUCCESS;
+static int
+test_AES_GCM_auth_encryption_test_case_192_3(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_192_3);
}
static int
-test_authenticated_decryption(const struct aead_test_data *tdata)
+test_AES_GCM_auth_encryption_test_case_192_4(void)
{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct crypto_unittest_params *ut_params = &unittest_params;
+ return test_authenticated_encryption(&gcm_test_case_192_4);
+}
- int retval;
- uint8_t *plaintext;
- uint32_t i;
+static int
+test_AES_GCM_auth_encryption_test_case_192_5(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_192_5);
+}
- /* Verify the capabilities */
- struct rte_cryptodev_sym_capability_idx cap_idx;
- const struct rte_cryptodev_symmetric_capability *capability;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
- cap_idx.algo.aead = tdata->algo;
- capability = rte_cryptodev_sym_capability_get(
- ts_params->valid_devs[0], &cap_idx);
- if (capability == NULL)
- return -ENOTSUP;
- if (rte_cryptodev_sym_capability_check_aead(
- capability, tdata->key.len, tdata->auth_tag.len,
- tdata->aad.len, tdata->iv.len))
- return -ENOTSUP;
+static int
+test_AES_GCM_auth_encryption_test_case_192_6(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_192_6);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_192_7(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_192_7);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_256_1(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_256_1);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_256_2(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_256_2);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_256_3(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_256_3);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_256_4(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_256_4);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_256_5(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_256_5);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_256_6(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_256_6);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_256_7(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_256_7);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_aad_1(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_aad_1);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_aad_2(void)
+{
+ return test_authenticated_encryption(&gcm_test_case_aad_2);
+}
+
+static int
+test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
+{
+ struct aead_test_data tdata;
+ int res;
+
+ RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+ memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+ tdata.iv.data[0] += 1;
+ res = test_authenticated_encryption(&tdata);
+ if (res == -ENOTSUP)
+ return res;
+ TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
+ return TEST_SUCCESS;
+}
+
+static int
+test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
+{
+ struct aead_test_data tdata;
+ int res;
+
+ RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+ memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+ tdata.plaintext.data[0] += 1;
+ res = test_authenticated_encryption(&tdata);
+ if (res == -ENOTSUP)
+ return res;
+ TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
+ return TEST_SUCCESS;
+}
+
+static int
+test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
+{
+ struct aead_test_data tdata;
+ int res;
+
+ RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+ memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+ tdata.ciphertext.data[0] += 1;
+ res = test_authenticated_encryption(&tdata);
+ if (res == -ENOTSUP)
+ return res;
+ TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
+ return TEST_SUCCESS;
+}
+
+static int
+test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
+{
+ struct aead_test_data tdata;
+ int res;
+
+ RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+ memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+ tdata.aad.len += 1;
+ res = test_authenticated_encryption(&tdata);
+ if (res == -ENOTSUP)
+ return res;
+ TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
+ return TEST_SUCCESS;
+}
+
+static int
+test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
+{
+ struct aead_test_data tdata;
+ uint8_t aad[gcm_test_case_7.aad.len];
+ int res;
+
+ RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+ memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+ memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
+ aad[0] += 1;
+ tdata.aad.data = aad;
+ res = test_authenticated_encryption(&tdata);
+ if (res == -ENOTSUP)
+ return res;
+ TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
+ return TEST_SUCCESS;
+}
+
+static int
+test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
+{
+ struct aead_test_data tdata;
+ int res;
+
+ RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+ memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+ tdata.auth_tag.data[0] += 1;
+ res = test_authenticated_encryption(&tdata);
+ if (res == -ENOTSUP)
+ return res;
+ TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
+ return TEST_SUCCESS;
+}
+
+static int
+test_authenticated_decryption(const struct aead_test_data *tdata)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct crypto_unittest_params *ut_params = &unittest_params;
+
+ int retval;
+ uint8_t *plaintext;
+ uint32_t i;
+
+ /* Verify the capabilities */
+ struct rte_cryptodev_sym_capability_idx cap_idx;
+ const struct rte_cryptodev_symmetric_capability *capability;
+ cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
+ cap_idx.algo.aead = tdata->algo;
+ capability = rte_cryptodev_sym_capability_get(
+ ts_params->valid_devs[0], &cap_idx);
+ if (capability == NULL)
+ return -ENOTSUP;
+ if (rte_cryptodev_sym_capability_check_aead(
+ capability, tdata->key.len, tdata->auth_tag.len,
+ tdata->aad.len, tdata->iv.len))
+ return -ENOTSUP;
/* Create AEAD session */
retval = create_aead_session(ts_params->valid_devs[0],
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct rte_cryptodev_stats stats;
- struct rte_cryptodev *dev;
- cryptodev_stats_get_t temp_pfn;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
return -ENOTSUP;
&cap_idx) == NULL)
return -ENOTSUP;
+ if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
+ == -ENOTSUP)
+ return -ENOTSUP;
+
rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
&stats) == -ENODEV),
"rte_cryptodev_stats_get invalid dev failed");
TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
"rte_cryptodev_stats_get invalid Param failed");
- dev = &rte_cryptodevs[ts_params->valid_devs[0]];
- temp_pfn = dev->dev_ops->stats_get;
- dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
- TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
- == -ENOTSUP),
- "rte_cryptodev_stats_get invalid Param failed");
- dev->dev_ops->stats_get = temp_pfn;
/* Test expected values */
ut_setup();
return TEST_SUCCESS;
}
+uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
+ 0xab, 0xab, 0xab, 0xab,
+ 0xab, 0xab, 0xab, 0xab,
+ 0xab, 0xab, 0xab, 0xab};
+
static int
-test_null_cipher_only_operation(void)
+test_null_invalid_operation(void)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
+ int ret;
- /* Verify the capabilities */
- struct rte_cryptodev_sym_capability_idx cap_idx;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
+ /* This test is for NULL PMD only */
+ if (gbl_driver_id != rte_cryptodev_driver_id_get(
+ RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
return -ENOTSUP;
- /* Generate test mbuf data and space for digest */
- ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
- catch_22_quote, QUOTE_512_BYTES, 0);
-
/* Setup Cipher Parameters */
ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
ut_params->cipher_xform.next = NULL;
- ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
+ ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
ut_params->sess = rte_cryptodev_sym_session_create(
ts_params->session_mpool);
/* Create Crypto session*/
- rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
- ut_params->sess,
- &ut_params->cipher_xform,
- ts_params->session_priv_mpool);
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+ ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+ ut_params->sess, &ut_params->cipher_xform,
+ ts_params->session_priv_mpool);
+ TEST_ASSERT(ret < 0,
+ "Session creation succeeded unexpectedly");
- /* Generate Crypto op data structure */
- ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(ut_params->op,
- "Failed to allocate symmetric crypto operation struct");
- /* Set crypto operation data parameters */
- rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+ /* Setup HMAC Parameters */
+ ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+ ut_params->auth_xform.next = NULL;
- struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+ ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
+ ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
- /* set crypto operation source mbuf */
- sym_op->m_src = ut_params->ibuf;
+ ut_params->sess = rte_cryptodev_sym_session_create(
+ ts_params->session_mpool);
- sym_op->cipher.data.offset = 0;
- sym_op->cipher.data.length = QUOTE_512_BYTES;
+ /* Create Crypto session*/
+ ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+ ut_params->sess, &ut_params->auth_xform,
+ ts_params->session_priv_mpool);
+ TEST_ASSERT(ret < 0,
+ "Session creation succeeded unexpectedly");
- /* Process crypto operation */
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
- ut_params->op);
- TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
+ return TEST_SUCCESS;
+}
- TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
- "crypto operation processing failed");
- /* Validate obuf */
- TEST_ASSERT_BUFFERS_ARE_EQUAL(
- rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
- catch_22_quote,
- QUOTE_512_BYTES,
- "Ciphertext data not as expected");
+#define NULL_BURST_LENGTH (32)
- return TEST_SUCCESS;
-}
-uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
- 0xab, 0xab, 0xab, 0xab,
- 0xab, 0xab, 0xab, 0xab,
- 0xab, 0xab, 0xab, 0xab};
static int
-test_null_auth_only_operation(void)
+test_null_burst_operation(void)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
- uint8_t *digest;
- /* Verify the capabilities */
- struct rte_cryptodev_sym_capability_idx cap_idx;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
+ unsigned i, burst_len = NULL_BURST_LENGTH;
+
+ struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
+ struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
+
+ /* This test is for NULL PMD only */
+ if (gbl_driver_id != rte_cryptodev_driver_id_get(
+ RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
return -ENOTSUP;
- /* Generate test mbuf data and space for digest */
- ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
- catch_22_quote, QUOTE_512_BYTES, 0);
+ /* Setup Cipher Parameters */
+ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+ ut_params->cipher_xform.next = &ut_params->auth_xform;
- /* create a pointer for digest, but don't expect anything to be written
- * here in a NULL auth algo so no mbuf append done.
- */
- digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
- QUOTE_512_BYTES);
- /* prefill the memory pointed to by digest */
- memcpy(digest, orig_data, sizeof(orig_data));
+ ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
+ ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
/* Setup HMAC Parameters */
ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
/* Create Crypto session*/
rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
- ut_params->sess, &ut_params->auth_xform,
+ ut_params->sess, &ut_params->cipher_xform,
ts_params->session_priv_mpool);
TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
- /* Generate Crypto op data structure */
- ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(ut_params->op,
- "Failed to allocate symmetric crypto operation struct");
+ TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
+ RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
+ burst_len, "failed to generate burst of crypto ops");
- /* Set crypto operation data parameters */
- rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+ /* Generate an operation for each mbuf in burst */
+ for (i = 0; i < burst_len; i++) {
+ struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
- struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+ TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
- sym_op->m_src = ut_params->ibuf;
+ unsigned *data = (unsigned *)rte_pktmbuf_append(m,
+ sizeof(unsigned));
+ *data = i;
- sym_op->auth.data.offset = 0;
- sym_op->auth.data.length = QUOTE_512_BYTES;
- sym_op->auth.digest.data = digest;
- sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
- QUOTE_512_BYTES);
+ rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
+
+ burst[i]->sym->m_src = m;
+ }
/* Process crypto operation */
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
- ut_params->op);
- TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
+ TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
+ 0, burst, burst_len),
+ burst_len,
+ "Error enqueuing burst");
- TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
- "crypto operation processing failed");
- /* Make sure memory pointed to by digest hasn't been overwritten */
- TEST_ASSERT_BUFFERS_ARE_EQUAL(
- orig_data,
- digest,
- sizeof(orig_data),
- "Memory at digest ptr overwritten unexpectedly");
+ TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
+ 0, burst_dequeued, burst_len),
+ burst_len,
+ "Error dequeuing burst");
+
+
+ for (i = 0; i < burst_len; i++) {
+ TEST_ASSERT_EQUAL(
+ *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
+ *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
+ uint32_t *),
+ "data not as expected");
+
+ rte_pktmbuf_free(burst[i]->sym->m_src);
+ rte_crypto_op_free(burst[i]);
+ }
return TEST_SUCCESS;
}
+static void
+generate_gmac_large_plaintext(uint8_t *data)
+{
+ uint16_t i;
+
+ for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
+ memcpy(&data[i], &data[0], 32);
+}
static int
-test_null_cipher_auth_operation(void)
+create_gmac_operation(enum rte_crypto_auth_operation op,
+ const struct gmac_test_data *tdata)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
- uint8_t *digest;
+ struct rte_crypto_sym_op *sym_op;
- /* Verify the capabilities */
- struct rte_cryptodev_sym_capability_idx cap_idx;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
+ uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
- /* Generate test mbuf data and space for digest */
- ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
- catch_22_quote, QUOTE_512_BYTES, 0);
+ /* Generate Crypto op data structure */
+ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+ RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+ TEST_ASSERT_NOT_NULL(ut_params->op,
+ "Failed to allocate symmetric crypto operation struct");
- /* create a pointer for digest, but don't expect anything to be written
- * here in a NULL auth algo so no mbuf append done.
- */
- digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
- QUOTE_512_BYTES);
- /* prefill the memory pointed to by digest */
- memcpy(digest, orig_data, sizeof(orig_data));
+ sym_op = ut_params->op->sym;
- /* Setup Cipher Parameters */
- ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- ut_params->cipher_xform.next = &ut_params->auth_xform;
+ sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+ ut_params->ibuf, tdata->gmac_tag.len);
+ TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+ "no room to append digest");
- ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
- ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
+ sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+ ut_params->ibuf, plaintext_pad_len);
- /* Setup HMAC Parameters */
- ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- ut_params->auth_xform.next = NULL;
+ if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
+ rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
+ tdata->gmac_tag.len);
+ debug_hexdump(stdout, "digest:",
+ sym_op->auth.digest.data,
+ tdata->gmac_tag.len);
+ }
- ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
- ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
+ uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *, IV_OFFSET);
- ut_params->sess = rte_cryptodev_sym_session_create(
- ts_params->session_mpool);
+ rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
- /* Create Crypto session*/
- rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
- ut_params->sess, &ut_params->cipher_xform,
- ts_params->session_priv_mpool);
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+ debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
- /* Generate Crypto op data structure */
- ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(ut_params->op,
- "Failed to allocate symmetric crypto operation struct");
+ sym_op->cipher.data.length = 0;
+ sym_op->cipher.data.offset = 0;
- /* Set crypto operation data parameters */
- rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+ sym_op->auth.data.offset = 0;
+ sym_op->auth.data.length = tdata->plaintext.len;
- struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+ return 0;
+}
- sym_op->m_src = ut_params->ibuf;
+static int create_gmac_session(uint8_t dev_id,
+ const struct gmac_test_data *tdata,
+ enum rte_crypto_auth_operation auth_op)
+{
+ uint8_t auth_key[tdata->key.len];
- sym_op->cipher.data.offset = 0;
- sym_op->cipher.data.length = QUOTE_512_BYTES;
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct crypto_unittest_params *ut_params = &unittest_params;
- sym_op->auth.data.offset = 0;
- sym_op->auth.data.length = QUOTE_512_BYTES;
- sym_op->auth.digest.data = digest;
- sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
- QUOTE_512_BYTES);
+ memcpy(auth_key, tdata->key.data, tdata->key.len);
- /* Process crypto operation */
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
- ut_params->op);
- TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
+ ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+ ut_params->auth_xform.next = NULL;
- TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
- "crypto operation processing failed");
+ ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
+ ut_params->auth_xform.auth.op = auth_op;
+ ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
+ ut_params->auth_xform.auth.key.length = tdata->key.len;
+ ut_params->auth_xform.auth.key.data = auth_key;
+ ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
+ ut_params->auth_xform.auth.iv.length = tdata->iv.len;
- /* Validate obuf */
- TEST_ASSERT_BUFFERS_ARE_EQUAL(
- rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
- catch_22_quote,
- QUOTE_512_BYTES,
- "Ciphertext data not as expected");
- /* Make sure memory pointed to by digest hasn't been overwritten */
- TEST_ASSERT_BUFFERS_ARE_EQUAL(
- orig_data,
- digest,
- sizeof(orig_data),
- "Memory at digest ptr overwritten unexpectedly");
- return TEST_SUCCESS;
+ ut_params->sess = rte_cryptodev_sym_session_create(
+ ts_params->session_mpool);
+
+ rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+ &ut_params->auth_xform,
+ ts_params->session_priv_mpool);
+
+ TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+
+ return 0;
}
static int
-test_null_auth_cipher_operation(void)
+test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
- uint8_t *digest;
+
+ int retval;
+
+ uint8_t *auth_tag, *plaintext;
+ uint16_t plaintext_pad_len;
+
+ TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
+ "No GMAC length in the source data");
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
+ cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
return -ENOTSUP;
- /* Generate test mbuf data */
- ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
- catch_22_quote, QUOTE_512_BYTES, 0);
+ retval = create_gmac_session(ts_params->valid_devs[0],
+ tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
- /* create a pointer for digest, but don't expect anything to be written
- * here in a NULL auth algo so no mbuf append done.
- */
- digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
- QUOTE_512_BYTES);
- /* prefill the memory pointed to by digest */
- memcpy(digest, orig_data, sizeof(orig_data));
+ if (retval < 0)
+ return retval;
- /* Setup Cipher Parameters */
- ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- ut_params->cipher_xform.next = NULL;
+ if (tdata->plaintext.len > MBUF_SIZE)
+ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
+ else
+ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+ TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+ "Failed to allocate input buffer in mempool");
- ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
- ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
+ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+ rte_pktmbuf_tailroom(ut_params->ibuf));
- /* Setup HMAC Parameters */
- ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- ut_params->auth_xform.next = &ut_params->cipher_xform;
+ plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
+ /*
+ * Runtime generate the large plain text instead of use hard code
+ * plain text vector. It is done to avoid create huge source file
+ * with the test vector.
+ */
+ if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
+ generate_gmac_large_plaintext(tdata->plaintext.data);
- ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
- ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
+ plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+ plaintext_pad_len);
+ TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
- ut_params->sess = rte_cryptodev_sym_session_create(
- ts_params->session_mpool);
+ memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
+ debug_hexdump(stdout, "plaintext:", plaintext,
+ tdata->plaintext.len);
- /* Create Crypto session*/
- rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
- ut_params->sess, &ut_params->cipher_xform,
- ts_params->session_priv_mpool);
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+ retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
+ tdata);
- /* Generate Crypto op data structure */
- ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(ut_params->op,
- "Failed to allocate symmetric crypto operation struct");
+ if (retval < 0)
+ return retval;
- /* Set crypto operation data parameters */
rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
- struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
-
- sym_op->m_src = ut_params->ibuf;
-
- sym_op->cipher.data.offset = 0;
- sym_op->cipher.data.length = QUOTE_512_BYTES;
-
- sym_op->auth.data.offset = 0;
- sym_op->auth.data.length = QUOTE_512_BYTES;
- sym_op->auth.digest.data = digest;
- sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
- QUOTE_512_BYTES);
+ ut_params->op->sym->m_src = ut_params->ibuf;
- /* Process crypto operation */
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ process_cpu_crypt_auth_op(ts_params->valid_devs[0],
ut_params->op);
- TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
+ else
+ TEST_ASSERT_NOT_NULL(
+ process_crypto_request(ts_params->valid_devs[0],
+ ut_params->op), "failed to process sym crypto op");
TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
- "crypto operation processing failed");
+ "crypto op processing failed");
+
+ if (ut_params->op->sym->m_dst) {
+ auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
+ uint8_t *, plaintext_pad_len);
+ } else {
+ auth_tag = plaintext + plaintext_pad_len;
+ }
+
+ debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
- /* Validate obuf */
- TEST_ASSERT_BUFFERS_ARE_EQUAL(
- rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
- catch_22_quote,
- QUOTE_512_BYTES,
- "Ciphertext data not as expected");
- /* Make sure memory pointed to by digest hasn't been overwritten */
TEST_ASSERT_BUFFERS_ARE_EQUAL(
- orig_data,
- digest,
- sizeof(orig_data),
- "Memory at digest ptr overwritten unexpectedly");
+ auth_tag,
+ tdata->gmac_tag.data,
+ tdata->gmac_tag.len,
+ "GMAC Generated auth tag not as expected");
- return TEST_SUCCESS;
+ return 0;
}
-
static int
-test_null_invalid_operation(void)
+test_AES_GMAC_authentication_test_case_1(void)
{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct crypto_unittest_params *ut_params = &unittest_params;
- int ret;
-
- /* This test is for NULL PMD only */
- if (gbl_driver_id != rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
- return -ENOTSUP;
-
- /* Setup Cipher Parameters */
- ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- ut_params->cipher_xform.next = NULL;
-
- ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
- ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
-
- ut_params->sess = rte_cryptodev_sym_session_create(
- ts_params->session_mpool);
-
- /* Create Crypto session*/
- ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
- ut_params->sess, &ut_params->cipher_xform,
- ts_params->session_priv_mpool);
- TEST_ASSERT(ret < 0,
- "Session creation succeeded unexpectedly");
-
-
- /* Setup HMAC Parameters */
- ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- ut_params->auth_xform.next = NULL;
-
- ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
- ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
-
- ut_params->sess = rte_cryptodev_sym_session_create(
- ts_params->session_mpool);
-
- /* Create Crypto session*/
- ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
- ut_params->sess, &ut_params->auth_xform,
- ts_params->session_priv_mpool);
- TEST_ASSERT(ret < 0,
- "Session creation succeeded unexpectedly");
+ return test_AES_GMAC_authentication(&gmac_test_case_1);
+}
- return TEST_SUCCESS;
+static int
+test_AES_GMAC_authentication_test_case_2(void)
+{
+ return test_AES_GMAC_authentication(&gmac_test_case_2);
}
+static int
+test_AES_GMAC_authentication_test_case_3(void)
+{
+ return test_AES_GMAC_authentication(&gmac_test_case_3);
+}
-#define NULL_BURST_LENGTH (32)
+static int
+test_AES_GMAC_authentication_test_case_4(void)
+{
+ return test_AES_GMAC_authentication(&gmac_test_case_4);
+}
static int
-test_null_burst_operation(void)
+test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
+ int retval;
+ uint32_t plaintext_pad_len;
+ uint8_t *plaintext;
- unsigned i, burst_len = NULL_BURST_LENGTH;
-
- struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
- struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
+ TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
+ "No GMAC length in the source data");
- /* This test is for NULL PMD only */
- if (gbl_driver_id != rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
+ /* Verify the capabilities */
+ struct rte_cryptodev_sym_capability_idx cap_idx;
+ cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+ cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
+ if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+ &cap_idx) == NULL)
return -ENOTSUP;
- /* Setup Cipher Parameters */
- ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- ut_params->cipher_xform.next = &ut_params->auth_xform;
-
- ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
- ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
-
- /* Setup HMAC Parameters */
- ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- ut_params->auth_xform.next = NULL;
+ retval = create_gmac_session(ts_params->valid_devs[0],
+ tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
- ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
- ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
+ if (retval < 0)
+ return retval;
- ut_params->sess = rte_cryptodev_sym_session_create(
- ts_params->session_mpool);
+ if (tdata->plaintext.len > MBUF_SIZE)
+ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
+ else
+ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+ TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+ "Failed to allocate input buffer in mempool");
- /* Create Crypto session*/
- rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
- ut_params->sess, &ut_params->cipher_xform,
- ts_params->session_priv_mpool);
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+ rte_pktmbuf_tailroom(ut_params->ibuf));
- TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
- burst_len, "failed to generate burst of crypto ops");
+ plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
- /* Generate an operation for each mbuf in burst */
- for (i = 0; i < burst_len; i++) {
- struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+ /*
+ * Runtime generate the large plain text instead of use hard code
+ * plain text vector. It is done to avoid create huge source file
+ * with the test vector.
+ */
+ if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
+ generate_gmac_large_plaintext(tdata->plaintext.data);
- TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
+ plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+ plaintext_pad_len);
+ TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
- unsigned *data = (unsigned *)rte_pktmbuf_append(m,
- sizeof(unsigned));
- *data = i;
+ memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
+ debug_hexdump(stdout, "plaintext:", plaintext,
+ tdata->plaintext.len);
- rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
+ retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
+ tdata);
- burst[i]->sym->m_src = m;
- }
+ if (retval < 0)
+ return retval;
- /* Process crypto operation */
- TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
- 0, burst, burst_len),
- burst_len,
- "Error enqueuing burst");
+ rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
- TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
- 0, burst_dequeued, burst_len),
- burst_len,
- "Error dequeuing burst");
+ ut_params->op->sym->m_src = ut_params->ibuf;
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+ ut_params->op);
+ else
+ TEST_ASSERT_NOT_NULL(
+ process_crypto_request(ts_params->valid_devs[0],
+ ut_params->op), "failed to process sym crypto op");
- for (i = 0; i < burst_len; i++) {
- TEST_ASSERT_EQUAL(
- *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
- *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
- uint32_t *),
- "data not as expected");
+ TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+ "crypto op processing failed");
- rte_pktmbuf_free(burst[i]->sym->m_src);
- rte_crypto_op_free(burst[i]);
- }
+ return 0;
- return TEST_SUCCESS;
}
-static void
-generate_gmac_large_plaintext(uint8_t *data)
+static int
+test_AES_GMAC_authentication_verify_test_case_1(void)
{
- uint16_t i;
-
- for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
- memcpy(&data[i], &data[0], 32);
+ return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
}
static int
-create_gmac_operation(enum rte_crypto_auth_operation op,
- const struct gmac_test_data *tdata)
+test_AES_GMAC_authentication_verify_test_case_2(void)
{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct crypto_unittest_params *ut_params = &unittest_params;
- struct rte_crypto_sym_op *sym_op;
+ return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
+}
- uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
+static int
+test_AES_GMAC_authentication_verify_test_case_3(void)
+{
+ return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
+}
- /* Generate Crypto op data structure */
- ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(ut_params->op,
- "Failed to allocate symmetric crypto operation struct");
+static int
+test_AES_GMAC_authentication_verify_test_case_4(void)
+{
+ return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
+}
- sym_op = ut_params->op->sym;
+struct test_crypto_vector {
+ enum rte_crypto_cipher_algorithm crypto_algo;
+ unsigned int cipher_offset;
+ unsigned int cipher_len;
- sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
- ut_params->ibuf, tdata->gmac_tag.len);
- TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
- "no room to append digest");
+ struct {
+ uint8_t data[64];
+ unsigned int len;
+ } cipher_key;
- sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
- ut_params->ibuf, plaintext_pad_len);
+ struct {
+ uint8_t data[64];
+ unsigned int len;
+ } iv;
- if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
- rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
- tdata->gmac_tag.len);
- debug_hexdump(stdout, "digest:",
- sym_op->auth.digest.data,
- tdata->gmac_tag.len);
- }
+ struct {
+ const uint8_t *data;
+ unsigned int len;
+ } plaintext;
- uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
- uint8_t *, IV_OFFSET);
+ struct {
+ const uint8_t *data;
+ unsigned int len;
+ } ciphertext;
- rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
+ enum rte_crypto_auth_algorithm auth_algo;
+ unsigned int auth_offset;
- debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
+ struct {
+ uint8_t data[128];
+ unsigned int len;
+ } auth_key;
- sym_op->cipher.data.length = 0;
- sym_op->cipher.data.offset = 0;
+ struct {
+ const uint8_t *data;
+ unsigned int len;
+ } aad;
- sym_op->auth.data.offset = 0;
- sym_op->auth.data.length = tdata->plaintext.len;
+ struct {
+ uint8_t data[128];
+ unsigned int len;
+ } digest;
+};
- return 0;
+static const struct test_crypto_vector
+hmac_sha1_test_crypto_vector = {
+ .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
+ .plaintext = {
+ .data = plaintext_hash,
+ .len = 512
+ },
+ .auth_key = {
+ .data = {
+ 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
+ 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
+ 0xDE, 0xF4, 0xDE, 0xAD
+ },
+ .len = 20
+ },
+ .digest = {
+ .data = {
+ 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
+ 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
+ 0x3F, 0x91, 0x64, 0x59
+ },
+ .len = 20
+ }
+};
+
+static const struct test_crypto_vector
+aes128_gmac_test_vector = {
+ .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
+ .plaintext = {
+ .data = plaintext_hash,
+ .len = 512
+ },
+ .iv = {
+ .data = {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B
+ },
+ .len = 12
+ },
+ .auth_key = {
+ .data = {
+ 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
+ 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
+ },
+ .len = 16
+ },
+ .digest = {
+ .data = {
+ 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
+ 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
+ },
+ .len = 16
+ }
+};
+
+static const struct test_crypto_vector
+aes128cbc_hmac_sha1_test_vector = {
+ .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
+ .cipher_offset = 0,
+ .cipher_len = 512,
+ .cipher_key = {
+ .data = {
+ 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
+ 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
+ },
+ .len = 16
+ },
+ .iv = {
+ .data = {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
+ },
+ .len = 16
+ },
+ .plaintext = {
+ .data = plaintext_hash,
+ .len = 512
+ },
+ .ciphertext = {
+ .data = ciphertext512_aes128cbc,
+ .len = 512
+ },
+ .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
+ .auth_offset = 0,
+ .auth_key = {
+ .data = {
+ 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
+ 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
+ 0xDE, 0xF4, 0xDE, 0xAD
+ },
+ .len = 20
+ },
+ .digest = {
+ .data = {
+ 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
+ 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
+ 0x18, 0x8C, 0x1D, 0x32
+ },
+ .len = 20
+ }
+};
+
+static const struct test_crypto_vector
+aes128cbc_hmac_sha1_aad_test_vector = {
+ .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
+ .cipher_offset = 12,
+ .cipher_len = 496,
+ .cipher_key = {
+ .data = {
+ 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
+ 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
+ },
+ .len = 16
+ },
+ .iv = {
+ .data = {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
+ },
+ .len = 16
+ },
+ .plaintext = {
+ .data = plaintext_hash,
+ .len = 512
+ },
+ .ciphertext = {
+ .data = ciphertext512_aes128cbc_aad,
+ .len = 512
+ },
+ .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
+ .auth_offset = 0,
+ .auth_key = {
+ .data = {
+ 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
+ 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
+ 0xDE, 0xF4, 0xDE, 0xAD
+ },
+ .len = 20
+ },
+ .digest = {
+ .data = {
+ 0x1F, 0x6A, 0xD2, 0x8B, 0x4B, 0xB3, 0xC0, 0x9E,
+ 0x86, 0x9B, 0x3A, 0xF2, 0x00, 0x5B, 0x4F, 0x08,
+ 0x62, 0x8D, 0x62, 0x65
+ },
+ .len = 20
+ }
+};
+
+static void
+data_corruption(uint8_t *data)
+{
+ data[0] += 1;
}
-static int create_gmac_session(uint8_t dev_id,
- const struct gmac_test_data *tdata,
- enum rte_crypto_auth_operation auth_op)
+static void
+tag_corruption(uint8_t *data, unsigned int tag_offset)
{
- uint8_t auth_key[tdata->key.len];
+ data[tag_offset] += 1;
+}
+static int
+create_auth_session(struct crypto_unittest_params *ut_params,
+ uint8_t dev_id,
+ const struct test_crypto_vector *reference,
+ enum rte_crypto_auth_operation auth_op)
+{
struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct crypto_unittest_params *ut_params = &unittest_params;
+ uint8_t auth_key[reference->auth_key.len + 1];
- memcpy(auth_key, tdata->key.data, tdata->key.len);
+ memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
+ /* Setup Authentication Parameters */
ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- ut_params->auth_xform.next = NULL;
-
- ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
ut_params->auth_xform.auth.op = auth_op;
- ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
- ut_params->auth_xform.auth.key.length = tdata->key.len;
+ ut_params->auth_xform.next = NULL;
+ ut_params->auth_xform.auth.algo = reference->auth_algo;
+ ut_params->auth_xform.auth.key.length = reference->auth_key.len;
ut_params->auth_xform.auth.key.data = auth_key;
- ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
- ut_params->auth_xform.auth.iv.length = tdata->iv.len;
-
+ ut_params->auth_xform.auth.digest_length = reference->digest.len;
+ /* Create Crypto session*/
ut_params->sess = rte_cryptodev_sym_session_create(
ts_params->session_mpool);
rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
- &ut_params->auth_xform,
- ts_params->session_priv_mpool);
+ &ut_params->auth_xform,
+ ts_params->session_priv_mpool);
TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
}
static int
-test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
+create_auth_cipher_session(struct crypto_unittest_params *ut_params,
+ uint8_t dev_id,
+ const struct test_crypto_vector *reference,
+ enum rte_crypto_auth_operation auth_op,
+ enum rte_crypto_cipher_operation cipher_op)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct crypto_unittest_params *ut_params = &unittest_params;
+ uint8_t cipher_key[reference->cipher_key.len + 1];
+ uint8_t auth_key[reference->auth_key.len + 1];
- int retval;
+ memcpy(cipher_key, reference->cipher_key.data,
+ reference->cipher_key.len);
+ memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
- uint8_t *auth_tag, *plaintext;
- uint16_t plaintext_pad_len;
+ /* Setup Authentication Parameters */
+ ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+ ut_params->auth_xform.auth.op = auth_op;
+ ut_params->auth_xform.auth.algo = reference->auth_algo;
+ ut_params->auth_xform.auth.key.length = reference->auth_key.len;
+ ut_params->auth_xform.auth.key.data = auth_key;
+ ut_params->auth_xform.auth.digest_length = reference->digest.len;
- TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
- "No GMAC length in the source data");
+ if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
+ ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
+ ut_params->auth_xform.auth.iv.length = reference->iv.len;
+ } else {
+ ut_params->auth_xform.next = &ut_params->cipher_xform;
- /* Verify the capabilities */
- struct rte_cryptodev_sym_capability_idx cap_idx;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
+ /* Setup Cipher Parameters */
+ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+ ut_params->cipher_xform.next = NULL;
+ ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
+ ut_params->cipher_xform.cipher.op = cipher_op;
+ ut_params->cipher_xform.cipher.key.data = cipher_key;
+ ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
+ ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+ ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
+ }
- retval = create_gmac_session(ts_params->valid_devs[0],
- tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
+ /* Create Crypto session*/
+ ut_params->sess = rte_cryptodev_sym_session_create(
+ ts_params->session_mpool);
- if (retval < 0)
- return retval;
+ rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+ &ut_params->auth_xform,
+ ts_params->session_priv_mpool);
- if (tdata->plaintext.len > MBUF_SIZE)
- ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
- else
- ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
- TEST_ASSERT_NOT_NULL(ut_params->ibuf,
- "Failed to allocate input buffer in mempool");
+ TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
- memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
- rte_pktmbuf_tailroom(ut_params->ibuf));
+ return 0;
+}
- plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
- /*
- * Runtime generate the large plain text instead of use hard code
- * plain text vector. It is done to avoid create huge source file
- * with the test vector.
- */
- if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
- generate_gmac_large_plaintext(tdata->plaintext.data);
+static int
+create_auth_operation(struct crypto_testsuite_params *ts_params,
+ struct crypto_unittest_params *ut_params,
+ const struct test_crypto_vector *reference,
+ unsigned int auth_generate)
+{
+ /* Generate Crypto op data structure */
+ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+ RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+ TEST_ASSERT_NOT_NULL(ut_params->op,
+ "Failed to allocate pktmbuf offload");
- plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
- plaintext_pad_len);
- TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
+ /* Set crypto operation data parameters */
+ rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
- memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
- debug_hexdump(stdout, "plaintext:", plaintext,
- tdata->plaintext.len);
+ struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
- retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
- tdata);
+ /* set crypto operation source mbuf */
+ sym_op->m_src = ut_params->ibuf;
- if (retval < 0)
- return retval;
+ /* digest */
+ sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+ ut_params->ibuf, reference->digest.len);
- rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+ TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+ "no room to append auth tag");
- ut_params->op->sym->m_src = ut_params->ibuf;
+ sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+ ut_params->ibuf, reference->plaintext.len);
- if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- process_cpu_crypt_auth_op(ts_params->valid_devs[0],
- ut_params->op);
+ if (auth_generate)
+ memset(sym_op->auth.digest.data, 0, reference->digest.len);
else
- TEST_ASSERT_NOT_NULL(
- process_crypto_request(ts_params->valid_devs[0],
- ut_params->op), "failed to process sym crypto op");
-
- TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
- "crypto op processing failed");
-
- if (ut_params->op->sym->m_dst) {
- auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
- uint8_t *, plaintext_pad_len);
- } else {
- auth_tag = plaintext + plaintext_pad_len;
- }
+ memcpy(sym_op->auth.digest.data,
+ reference->digest.data,
+ reference->digest.len);
- debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
+ debug_hexdump(stdout, "digest:",
+ sym_op->auth.digest.data,
+ reference->digest.len);
- TEST_ASSERT_BUFFERS_ARE_EQUAL(
- auth_tag,
- tdata->gmac_tag.data,
- tdata->gmac_tag.len,
- "GMAC Generated auth tag not as expected");
+ sym_op->auth.data.length = reference->plaintext.len;
+ sym_op->auth.data.offset = 0;
return 0;
}
static int
-test_AES_GMAC_authentication_test_case_1(void)
-{
- return test_AES_GMAC_authentication(&gmac_test_case_1);
-}
-
-static int
-test_AES_GMAC_authentication_test_case_2(void)
-{
- return test_AES_GMAC_authentication(&gmac_test_case_2);
-}
-
-static int
-test_AES_GMAC_authentication_test_case_3(void)
+create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
+ struct crypto_unittest_params *ut_params,
+ const struct test_crypto_vector *reference,
+ unsigned int auth_generate)
{
- return test_AES_GMAC_authentication(&gmac_test_case_3);
-}
+ /* Generate Crypto op data structure */
+ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+ RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+ TEST_ASSERT_NOT_NULL(ut_params->op,
+ "Failed to allocate pktmbuf offload");
-static int
-test_AES_GMAC_authentication_test_case_4(void)
-{
- return test_AES_GMAC_authentication(&gmac_test_case_4);
-}
+ /* Set crypto operation data parameters */
+ rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-static int
-test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct crypto_unittest_params *ut_params = &unittest_params;
- int retval;
- uint32_t plaintext_pad_len;
- uint8_t *plaintext;
+ struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
- TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
- "No GMAC length in the source data");
+ /* set crypto operation source mbuf */
+ sym_op->m_src = ut_params->ibuf;
- /* Verify the capabilities */
- struct rte_cryptodev_sym_capability_idx cap_idx;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
+ /* digest */
+ sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+ ut_params->ibuf, reference->digest.len);
- retval = create_gmac_session(ts_params->valid_devs[0],
- tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
+ TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+ "no room to append auth tag");
- if (retval < 0)
- return retval;
+ sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+ ut_params->ibuf, reference->ciphertext.len);
- if (tdata->plaintext.len > MBUF_SIZE)
- ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
+ if (auth_generate)
+ memset(sym_op->auth.digest.data, 0, reference->digest.len);
else
- ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
- TEST_ASSERT_NOT_NULL(ut_params->ibuf,
- "Failed to allocate input buffer in mempool");
-
- memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
- rte_pktmbuf_tailroom(ut_params->ibuf));
-
- plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
-
- /*
- * Runtime generate the large plain text instead of use hard code
- * plain text vector. It is done to avoid create huge source file
- * with the test vector.
- */
- if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
- generate_gmac_large_plaintext(tdata->plaintext.data);
+ memcpy(sym_op->auth.digest.data,
+ reference->digest.data,
+ reference->digest.len);
- plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
- plaintext_pad_len);
- TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
+ debug_hexdump(stdout, "digest:",
+ sym_op->auth.digest.data,
+ reference->digest.len);
- memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
- debug_hexdump(stdout, "plaintext:", plaintext,
- tdata->plaintext.len);
+ rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
+ reference->iv.data, reference->iv.len);
- retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
- tdata);
+ sym_op->cipher.data.length = 0;
+ sym_op->cipher.data.offset = 0;
- if (retval < 0)
- return retval;
+ sym_op->auth.data.length = reference->plaintext.len;
+ sym_op->auth.data.offset = 0;
- rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+ return 0;
+}
- ut_params->op->sym->m_src = ut_params->ibuf;
+static int
+create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
+ struct crypto_unittest_params *ut_params,
+ const struct test_crypto_vector *reference,
+ unsigned int auth_generate)
+{
+ /* Generate Crypto op data structure */
+ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+ RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+ TEST_ASSERT_NOT_NULL(ut_params->op,
+ "Failed to allocate pktmbuf offload");
- if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- process_cpu_crypt_auth_op(ts_params->valid_devs[0],
- ut_params->op);
+ /* Set crypto operation data parameters */
+ rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+
+ struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+
+ /* set crypto operation source mbuf */
+ sym_op->m_src = ut_params->ibuf;
+
+ /* digest */
+ sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+ ut_params->ibuf, reference->digest.len);
+
+ TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+ "no room to append auth tag");
+
+ sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+ ut_params->ibuf, reference->ciphertext.len);
+
+ if (auth_generate)
+ memset(sym_op->auth.digest.data, 0, reference->digest.len);
else
- TEST_ASSERT_NOT_NULL(
- process_crypto_request(ts_params->valid_devs[0],
- ut_params->op), "failed to process sym crypto op");
+ memcpy(sym_op->auth.digest.data,
+ reference->digest.data,
+ reference->digest.len);
- TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
- "crypto op processing failed");
+ debug_hexdump(stdout, "digest:",
+ sym_op->auth.digest.data,
+ reference->digest.len);
- return 0;
+ rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
+ reference->iv.data, reference->iv.len);
+ sym_op->cipher.data.length = reference->cipher_len;
+ sym_op->cipher.data.offset = reference->cipher_offset;
+
+ sym_op->auth.data.length = reference->plaintext.len;
+ sym_op->auth.data.offset = reference->auth_offset;
+
+ return 0;
}
static int
-test_AES_GMAC_authentication_verify_test_case_1(void)
+create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
+ struct crypto_unittest_params *ut_params,
+ const struct test_crypto_vector *reference)
{
- return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
+ return create_auth_operation(ts_params, ut_params, reference, 0);
}
static int
-test_AES_GMAC_authentication_verify_test_case_2(void)
+create_auth_verify_GMAC_operation(
+ struct crypto_testsuite_params *ts_params,
+ struct crypto_unittest_params *ut_params,
+ const struct test_crypto_vector *reference)
{
- return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
+ return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
}
static int
-test_AES_GMAC_authentication_verify_test_case_3(void)
+create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
+ struct crypto_unittest_params *ut_params,
+ const struct test_crypto_vector *reference)
{
- return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
+ return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
}
static int
-test_AES_GMAC_authentication_verify_test_case_4(void)
+test_authentication_verify_fail_when_data_corruption(
+ struct crypto_testsuite_params *ts_params,
+ struct crypto_unittest_params *ut_params,
+ const struct test_crypto_vector *reference,
+ unsigned int data_corrupted)
{
- return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
-}
+ int retval;
-struct test_crypto_vector {
- enum rte_crypto_cipher_algorithm crypto_algo;
- unsigned int cipher_offset;
- unsigned int cipher_len;
+ uint8_t *plaintext;
- struct {
- uint8_t data[64];
- unsigned int len;
- } cipher_key;
+ /* Verify the capabilities */
+ struct rte_cryptodev_sym_capability_idx cap_idx;
+ cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+ cap_idx.algo.auth = reference->auth_algo;
+ if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+ &cap_idx) == NULL)
+ return -ENOTSUP;
- struct {
- uint8_t data[64];
- unsigned int len;
- } iv;
+ /* Create session */
+ retval = create_auth_session(ut_params,
+ ts_params->valid_devs[0],
+ reference,
+ RTE_CRYPTO_AUTH_OP_VERIFY);
+ if (retval < 0)
+ return retval;
- struct {
- const uint8_t *data;
- unsigned int len;
- } plaintext;
+ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+ TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+ "Failed to allocate input buffer in mempool");
- struct {
- const uint8_t *data;
- unsigned int len;
- } ciphertext;
+ /* clear mbuf payload */
+ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+ rte_pktmbuf_tailroom(ut_params->ibuf));
- enum rte_crypto_auth_algorithm auth_algo;
- unsigned int auth_offset;
+ plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+ reference->plaintext.len);
+ TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
+ memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
- struct {
- uint8_t data[128];
- unsigned int len;
- } auth_key;
+ debug_hexdump(stdout, "plaintext:", plaintext,
+ reference->plaintext.len);
- struct {
- const uint8_t *data;
- unsigned int len;
- } aad;
+ /* Create operation */
+ retval = create_auth_verify_operation(ts_params, ut_params, reference);
- struct {
- uint8_t data[128];
- unsigned int len;
- } digest;
-};
+ if (retval < 0)
+ return retval;
-static const struct test_crypto_vector
-hmac_sha1_test_crypto_vector = {
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
- .plaintext = {
- .data = plaintext_hash,
- .len = 512
- },
- .auth_key = {
- .data = {
- 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
- 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
- 0xDE, 0xF4, 0xDE, 0xAD
- },
- .len = 20
- },
- .digest = {
- .data = {
- 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
- 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
- 0x3F, 0x91, 0x64, 0x59
- },
- .len = 20
- }
-};
+ if (data_corrupted)
+ data_corruption(plaintext);
+ else
+ tag_corruption(plaintext, reference->plaintext.len);
-static const struct test_crypto_vector
-aes128_gmac_test_vector = {
- .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
- .plaintext = {
- .data = plaintext_hash,
- .len = 512
- },
- .iv = {
- .data = {
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B
- },
- .len = 12
- },
- .auth_key = {
- .data = {
- 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
- 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
- },
- .len = 16
- },
- .digest = {
- .data = {
- 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
- 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
- },
- .len = 16
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
+ process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+ ut_params->op);
+ TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
+ RTE_CRYPTO_OP_STATUS_SUCCESS,
+ "authentication not failed");
+ } else {
+ ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+ ut_params->op);
+ TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
}
-};
-static const struct test_crypto_vector
-aes128cbc_hmac_sha1_test_vector = {
- .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .cipher_offset = 0,
- .cipher_len = 512,
- .cipher_key = {
- .data = {
- 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
- 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
- },
- .len = 16
- },
- .iv = {
- .data = {
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
- },
- .len = 16
- },
- .plaintext = {
- .data = plaintext_hash,
- .len = 512
- },
- .ciphertext = {
- .data = ciphertext512_aes128cbc,
- .len = 512
- },
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
- .auth_offset = 0,
- .auth_key = {
- .data = {
- 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
- 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
- 0xDE, 0xF4, 0xDE, 0xAD
- },
- .len = 20
- },
- .digest = {
- .data = {
- 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
- 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
- 0x18, 0x8C, 0x1D, 0x32
- },
- .len = 20
- }
-};
-
-static const struct test_crypto_vector
-aes128cbc_hmac_sha1_aad_test_vector = {
- .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
- .cipher_offset = 12,
- .cipher_len = 496,
- .cipher_key = {
- .data = {
- 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
- 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
- },
- .len = 16
- },
- .iv = {
- .data = {
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
- },
- .len = 16
- },
- .plaintext = {
- .data = plaintext_hash,
- .len = 512
- },
- .ciphertext = {
- .data = ciphertext512_aes128cbc_aad,
- .len = 512
- },
- .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
- .auth_offset = 0,
- .auth_key = {
- .data = {
- 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
- 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
- 0xDE, 0xF4, 0xDE, 0xAD
- },
- .len = 20
- },
- .digest = {
- .data = {
- 0x1F, 0x6A, 0xD2, 0x8B, 0x4B, 0xB3, 0xC0, 0x9E,
- 0x86, 0x9B, 0x3A, 0xF2, 0x00, 0x5B, 0x4F, 0x08,
- 0x62, 0x8D, 0x62, 0x65
- },
- .len = 20
- }
-};
-
-static void
-data_corruption(uint8_t *data)
-{
- data[0] += 1;
-}
-
-static void
-tag_corruption(uint8_t *data, unsigned int tag_offset)
-{
- data[tag_offset] += 1;
+ return 0;
}
static int
-create_auth_session(struct crypto_unittest_params *ut_params,
- uint8_t dev_id,
+test_authentication_verify_GMAC_fail_when_corruption(
+ struct crypto_testsuite_params *ts_params,
+ struct crypto_unittest_params *ut_params,
const struct test_crypto_vector *reference,
- enum rte_crypto_auth_operation auth_op)
+ unsigned int data_corrupted)
{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- uint8_t auth_key[reference->auth_key.len + 1];
+ int retval;
+ uint8_t *plaintext;
- memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
+ /* Verify the capabilities */
+ struct rte_cryptodev_sym_capability_idx cap_idx;
+ cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+ cap_idx.algo.auth = reference->auth_algo;
+ if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+ &cap_idx) == NULL)
+ return -ENOTSUP;
- /* Setup Authentication Parameters */
- ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- ut_params->auth_xform.auth.op = auth_op;
- ut_params->auth_xform.next = NULL;
- ut_params->auth_xform.auth.algo = reference->auth_algo;
- ut_params->auth_xform.auth.key.length = reference->auth_key.len;
- ut_params->auth_xform.auth.key.data = auth_key;
- ut_params->auth_xform.auth.digest_length = reference->digest.len;
+ /* Create session */
+ retval = create_auth_cipher_session(ut_params,
+ ts_params->valid_devs[0],
+ reference,
+ RTE_CRYPTO_AUTH_OP_VERIFY,
+ RTE_CRYPTO_CIPHER_OP_DECRYPT);
+ if (retval < 0)
+ return retval;
- /* Create Crypto session*/
- ut_params->sess = rte_cryptodev_sym_session_create(
- ts_params->session_mpool);
+ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+ TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+ "Failed to allocate input buffer in mempool");
- rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
- &ut_params->auth_xform,
- ts_params->session_priv_mpool);
+ /* clear mbuf payload */
+ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+ rte_pktmbuf_tailroom(ut_params->ibuf));
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+ plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+ reference->plaintext.len);
+ TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
+ memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
- return 0;
-}
+ debug_hexdump(stdout, "plaintext:", plaintext,
+ reference->plaintext.len);
-static int
-create_auth_cipher_session(struct crypto_unittest_params *ut_params,
- uint8_t dev_id,
- const struct test_crypto_vector *reference,
- enum rte_crypto_auth_operation auth_op,
- enum rte_crypto_cipher_operation cipher_op)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- uint8_t cipher_key[reference->cipher_key.len + 1];
- uint8_t auth_key[reference->auth_key.len + 1];
+ /* Create operation */
+ retval = create_auth_verify_GMAC_operation(ts_params,
+ ut_params,
+ reference);
- memcpy(cipher_key, reference->cipher_key.data,
- reference->cipher_key.len);
- memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
+ if (retval < 0)
+ return retval;
- /* Setup Authentication Parameters */
- ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- ut_params->auth_xform.auth.op = auth_op;
- ut_params->auth_xform.auth.algo = reference->auth_algo;
- ut_params->auth_xform.auth.key.length = reference->auth_key.len;
- ut_params->auth_xform.auth.key.data = auth_key;
- ut_params->auth_xform.auth.digest_length = reference->digest.len;
+ if (data_corrupted)
+ data_corruption(plaintext);
+ else
+ tag_corruption(plaintext, reference->aad.len);
- if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
- ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
- ut_params->auth_xform.auth.iv.length = reference->iv.len;
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
+ process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+ ut_params->op);
+ TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
+ RTE_CRYPTO_OP_STATUS_SUCCESS,
+ "authentication not failed");
} else {
- ut_params->auth_xform.next = &ut_params->cipher_xform;
-
- /* Setup Cipher Parameters */
- ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- ut_params->cipher_xform.next = NULL;
- ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
- ut_params->cipher_xform.cipher.op = cipher_op;
- ut_params->cipher_xform.cipher.key.data = cipher_key;
- ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
- ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
- ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
+ ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+ ut_params->op);
+ TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
}
- /* Create Crypto session*/
- ut_params->sess = rte_cryptodev_sym_session_create(
- ts_params->session_mpool);
-
- rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
- &ut_params->auth_xform,
- ts_params->session_priv_mpool);
-
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
-
return 0;
}
static int
-create_auth_operation(struct crypto_testsuite_params *ts_params,
+test_authenticated_decryption_fail_when_corruption(
+ struct crypto_testsuite_params *ts_params,
struct crypto_unittest_params *ut_params,
const struct test_crypto_vector *reference,
- unsigned int auth_generate)
+ unsigned int data_corrupted)
{
- /* Generate Crypto op data structure */
- ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(ut_params->op,
- "Failed to allocate pktmbuf offload");
-
- /* Set crypto operation data parameters */
- rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+ int retval;
- struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+ uint8_t *ciphertext;
- /* set crypto operation source mbuf */
- sym_op->m_src = ut_params->ibuf;
+ /* Verify the capabilities */
+ struct rte_cryptodev_sym_capability_idx cap_idx;
+ cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+ cap_idx.algo.auth = reference->auth_algo;
+ if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+ &cap_idx) == NULL)
+ return -ENOTSUP;
+ cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+ cap_idx.algo.cipher = reference->crypto_algo;
+ if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+ &cap_idx) == NULL)
+ return -ENOTSUP;
- /* digest */
- sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
- ut_params->ibuf, reference->digest.len);
+ /* Create session */
+ retval = create_auth_cipher_session(ut_params,
+ ts_params->valid_devs[0],
+ reference,
+ RTE_CRYPTO_AUTH_OP_VERIFY,
+ RTE_CRYPTO_CIPHER_OP_DECRYPT);
+ if (retval < 0)
+ return retval;
- TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
- "no room to append auth tag");
+ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+ TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+ "Failed to allocate input buffer in mempool");
- sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
- ut_params->ibuf, reference->plaintext.len);
+ /* clear mbuf payload */
+ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+ rte_pktmbuf_tailroom(ut_params->ibuf));
- if (auth_generate)
- memset(sym_op->auth.digest.data, 0, reference->digest.len);
- else
- memcpy(sym_op->auth.digest.data,
- reference->digest.data,
- reference->digest.len);
+ ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+ reference->ciphertext.len);
+ TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
+ memcpy(ciphertext, reference->ciphertext.data,
+ reference->ciphertext.len);
- debug_hexdump(stdout, "digest:",
- sym_op->auth.digest.data,
- reference->digest.len);
+ /* Create operation */
+ retval = create_cipher_auth_verify_operation(ts_params,
+ ut_params,
+ reference);
- sym_op->auth.data.length = reference->plaintext.len;
- sym_op->auth.data.offset = 0;
-
- return 0;
-}
-
-static int
-create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
- struct crypto_unittest_params *ut_params,
- const struct test_crypto_vector *reference,
- unsigned int auth_generate)
-{
- /* Generate Crypto op data structure */
- ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(ut_params->op,
- "Failed to allocate pktmbuf offload");
-
- /* Set crypto operation data parameters */
- rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
- struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
-
- /* set crypto operation source mbuf */
- sym_op->m_src = ut_params->ibuf;
-
- /* digest */
- sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
- ut_params->ibuf, reference->digest.len);
-
- TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
- "no room to append auth tag");
-
- sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
- ut_params->ibuf, reference->ciphertext.len);
-
- if (auth_generate)
- memset(sym_op->auth.digest.data, 0, reference->digest.len);
- else
- memcpy(sym_op->auth.digest.data,
- reference->digest.data,
- reference->digest.len);
-
- debug_hexdump(stdout, "digest:",
- sym_op->auth.digest.data,
- reference->digest.len);
-
- rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
- reference->iv.data, reference->iv.len);
-
- sym_op->cipher.data.length = 0;
- sym_op->cipher.data.offset = 0;
-
- sym_op->auth.data.length = reference->plaintext.len;
- sym_op->auth.data.offset = 0;
-
- return 0;
-}
-
-static int
-create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
- struct crypto_unittest_params *ut_params,
- const struct test_crypto_vector *reference,
- unsigned int auth_generate)
-{
- /* Generate Crypto op data structure */
- ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC);
- TEST_ASSERT_NOT_NULL(ut_params->op,
- "Failed to allocate pktmbuf offload");
-
- /* Set crypto operation data parameters */
- rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
- struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
-
- /* set crypto operation source mbuf */
- sym_op->m_src = ut_params->ibuf;
-
- /* digest */
- sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
- ut_params->ibuf, reference->digest.len);
-
- TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
- "no room to append auth tag");
-
- sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
- ut_params->ibuf, reference->ciphertext.len);
-
- if (auth_generate)
- memset(sym_op->auth.digest.data, 0, reference->digest.len);
- else
- memcpy(sym_op->auth.digest.data,
- reference->digest.data,
- reference->digest.len);
-
- debug_hexdump(stdout, "digest:",
- sym_op->auth.digest.data,
- reference->digest.len);
-
- rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
- reference->iv.data, reference->iv.len);
-
- sym_op->cipher.data.length = reference->cipher_len;
- sym_op->cipher.data.offset = reference->cipher_offset;
-
- sym_op->auth.data.length = reference->plaintext.len;
- sym_op->auth.data.offset = reference->auth_offset;
-
- return 0;
-}
-
-static int
-create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
- struct crypto_unittest_params *ut_params,
- const struct test_crypto_vector *reference)
-{
- return create_auth_operation(ts_params, ut_params, reference, 0);
-}
-
-static int
-create_auth_verify_GMAC_operation(
- struct crypto_testsuite_params *ts_params,
- struct crypto_unittest_params *ut_params,
- const struct test_crypto_vector *reference)
-{
- return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
-}
-
-static int
-create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
- struct crypto_unittest_params *ut_params,
- const struct test_crypto_vector *reference)
-{
- return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
-}
-
-static int
-test_authentication_verify_fail_when_data_corruption(
- struct crypto_testsuite_params *ts_params,
- struct crypto_unittest_params *ut_params,
- const struct test_crypto_vector *reference,
- unsigned int data_corrupted)
-{
- int retval;
-
- uint8_t *plaintext;
-
- /* Verify the capabilities */
- struct rte_cryptodev_sym_capability_idx cap_idx;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- cap_idx.algo.auth = reference->auth_algo;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
-
- /* Create session */
- retval = create_auth_session(ut_params,
- ts_params->valid_devs[0],
- reference,
- RTE_CRYPTO_AUTH_OP_VERIFY);
- if (retval < 0)
- return retval;
-
- ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
- TEST_ASSERT_NOT_NULL(ut_params->ibuf,
- "Failed to allocate input buffer in mempool");
-
- /* clear mbuf payload */
- memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
- rte_pktmbuf_tailroom(ut_params->ibuf));
-
- plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
- reference->plaintext.len);
- TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
- memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
-
- debug_hexdump(stdout, "plaintext:", plaintext,
- reference->plaintext.len);
-
- /* Create operation */
- retval = create_auth_verify_operation(ts_params, ut_params, reference);
-
- if (retval < 0)
- return retval;
+ if (retval < 0)
+ return retval;
if (data_corrupted)
- data_corruption(plaintext);
+ data_corruption(ciphertext);
else
- tag_corruption(plaintext, reference->plaintext.len);
+ tag_corruption(ciphertext, reference->ciphertext.len);
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
process_cpu_crypt_auth_op(ts_params->valid_devs[0],
}
static int
-test_authentication_verify_GMAC_fail_when_corruption(
+test_authenticated_encryt_with_esn(
struct crypto_testsuite_params *ts_params,
struct crypto_unittest_params *ut_params,
- const struct test_crypto_vector *reference,
- unsigned int data_corrupted)
+ const struct test_crypto_vector *reference)
{
int retval;
- uint8_t *plaintext;
+
+ uint8_t *authciphertext, *plaintext, *auth_tag;
+ uint16_t plaintext_pad_len;
+ uint8_t cipher_key[reference->cipher_key.len + 1];
+ uint8_t auth_key[reference->auth_key.len + 1];
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
cap_idx.algo.auth = reference->auth_algo;
+ if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+ &cap_idx) == NULL)
+ return -ENOTSUP;
+ cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+ cap_idx.algo.cipher = reference->crypto_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
return -ENOTSUP;
/* Create session */
- retval = create_auth_cipher_session(ut_params,
- ts_params->valid_devs[0],
- reference,
- RTE_CRYPTO_AUTH_OP_VERIFY,
- RTE_CRYPTO_CIPHER_OP_DECRYPT);
- if (retval < 0)
- return retval;
+ memcpy(cipher_key, reference->cipher_key.data,
+ reference->cipher_key.len);
+ memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
+
+ /* Setup Cipher Parameters */
+ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+ ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
+ ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
+ ut_params->cipher_xform.cipher.key.data = cipher_key;
+ ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
+ ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+ ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
+
+ ut_params->cipher_xform.next = &ut_params->auth_xform;
+
+ /* Setup Authentication Parameters */
+ ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+ ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
+ ut_params->auth_xform.auth.algo = reference->auth_algo;
+ ut_params->auth_xform.auth.key.length = reference->auth_key.len;
+ ut_params->auth_xform.auth.key.data = auth_key;
+ ut_params->auth_xform.auth.digest_length = reference->digest.len;
+ ut_params->auth_xform.next = NULL;
+
+ /* Create Crypto session*/
+ ut_params->sess = rte_cryptodev_sym_session_create(
+ ts_params->session_mpool);
+
+ rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+ ut_params->sess,
+ &ut_params->cipher_xform,
+ ts_params->session_priv_mpool);
+
+ TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
TEST_ASSERT_NOT_NULL(ut_params->ibuf,
TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
- debug_hexdump(stdout, "plaintext:", plaintext,
- reference->plaintext.len);
-
/* Create operation */
- retval = create_auth_verify_GMAC_operation(ts_params,
+ retval = create_cipher_auth_operation(ts_params,
ut_params,
- reference);
+ reference, 0);
if (retval < 0)
return retval;
- if (data_corrupted)
- data_corruption(plaintext);
- else
- tag_corruption(plaintext, reference->aad.len);
-
- if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
- process_cpu_crypt_auth_op(ts_params->valid_devs[0],
- ut_params->op);
- TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
- RTE_CRYPTO_OP_STATUS_SUCCESS,
- "authentication not failed");
- } else {
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
- ut_params->op);
- TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
- }
-
- return 0;
-}
-
-static int
-test_authenticated_decryption_fail_when_corruption(
- struct crypto_testsuite_params *ts_params,
- struct crypto_unittest_params *ut_params,
- const struct test_crypto_vector *reference,
- unsigned int data_corrupted)
-{
- int retval;
-
- uint8_t *ciphertext;
-
- /* Verify the capabilities */
- struct rte_cryptodev_sym_capability_idx cap_idx;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- cap_idx.algo.auth = reference->auth_algo;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- cap_idx.algo.cipher = reference->crypto_algo;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
-
- /* Create session */
- retval = create_auth_cipher_session(ut_params,
- ts_params->valid_devs[0],
- reference,
- RTE_CRYPTO_AUTH_OP_VERIFY,
- RTE_CRYPTO_CIPHER_OP_DECRYPT);
- if (retval < 0)
- return retval;
-
- ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
- TEST_ASSERT_NOT_NULL(ut_params->ibuf,
- "Failed to allocate input buffer in mempool");
-
- /* clear mbuf payload */
- memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
- rte_pktmbuf_tailroom(ut_params->ibuf));
-
- ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
- reference->ciphertext.len);
- TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
- memcpy(ciphertext, reference->ciphertext.data,
- reference->ciphertext.len);
-
- /* Create operation */
- retval = create_cipher_auth_verify_operation(ts_params,
- ut_params,
- reference);
-
- if (retval < 0)
- return retval;
-
- if (data_corrupted)
- data_corruption(ciphertext);
- else
- tag_corruption(ciphertext, reference->ciphertext.len);
-
- if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
- process_cpu_crypt_auth_op(ts_params->valid_devs[0],
- ut_params->op);
- TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
- RTE_CRYPTO_OP_STATUS_SUCCESS,
- "authentication not failed");
- } else {
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
- ut_params->op);
- TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
- }
-
- return 0;
-}
-
-static int
-test_authenticated_encryt_with_esn(
- struct crypto_testsuite_params *ts_params,
- struct crypto_unittest_params *ut_params,
- const struct test_crypto_vector *reference)
-{
- int retval;
-
- uint8_t *authciphertext, *plaintext, *auth_tag;
- uint16_t plaintext_pad_len;
- uint8_t cipher_key[reference->cipher_key.len + 1];
- uint8_t auth_key[reference->auth_key.len + 1];
-
- /* Verify the capabilities */
- struct rte_cryptodev_sym_capability_idx cap_idx;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- cap_idx.algo.auth = reference->auth_algo;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- cap_idx.algo.cipher = reference->crypto_algo;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
-
- /* Create session */
- memcpy(cipher_key, reference->cipher_key.data,
- reference->cipher_key.len);
- memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
-
- /* Setup Cipher Parameters */
- ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
- ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
- ut_params->cipher_xform.cipher.key.data = cipher_key;
- ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
- ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
- ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
-
- ut_params->cipher_xform.next = &ut_params->auth_xform;
-
- /* Setup Authentication Parameters */
- ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
- ut_params->auth_xform.auth.algo = reference->auth_algo;
- ut_params->auth_xform.auth.key.length = reference->auth_key.len;
- ut_params->auth_xform.auth.key.data = auth_key;
- ut_params->auth_xform.auth.digest_length = reference->digest.len;
- ut_params->auth_xform.next = NULL;
-
- /* Create Crypto session*/
- ut_params->sess = rte_cryptodev_sym_session_create(
- ts_params->session_mpool);
-
- rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
- ut_params->sess,
- &ut_params->cipher_xform,
- ts_params->session_priv_mpool);
-
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
-
- ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
- TEST_ASSERT_NOT_NULL(ut_params->ibuf,
- "Failed to allocate input buffer in mempool");
-
- /* clear mbuf payload */
- memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
- rte_pktmbuf_tailroom(ut_params->ibuf));
-
- plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
- reference->plaintext.len);
- TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
- memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
-
- /* Create operation */
- retval = create_cipher_auth_operation(ts_params,
- ut_params,
- reference, 0);
-
- if (retval < 0)
- return retval;
-
- if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- process_cpu_crypt_auth_op(ts_params->valid_devs[0],
- ut_params->op);
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+ ut_params->op);
else
ut_params->op = process_crypto_request(
ts_params->valid_devs[0], ut_params->op);
&aes128cbc_hmac_sha1_aad_test_vector);
}
+static int
+test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
+{
+ return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
+}
+
+static int
+test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
+{
+ return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
+}
+
#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
/* global AESNI slave IDs for the scheduler test */
.unit_test_cases = {
TEST_CASE_ST(ut_setup, ut_teardown,
test_device_configure_invalid_dev_id),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_device_configure_invalid_queue_pair_ids),
TEST_CASE_ST(ut_setup, ut_teardown,
test_queue_pair_descriptor_setup),
-
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_multi_session),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_multi_session_random_usage),
-
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_null_invalid_operation),
- TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
-
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
-
- /** AES CCM Authenticated Encryption 128 bits key */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_encryption_test_case_128_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_encryption_test_case_128_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_encryption_test_case_128_3),
-
- /** AES CCM Authenticated Decryption 128 bits key*/
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_decryption_test_case_128_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_decryption_test_case_128_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_decryption_test_case_128_3),
-
- /** AES CCM Authenticated Encryption 192 bits key */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_encryption_test_case_192_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_encryption_test_case_192_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_encryption_test_case_192_3),
-
- /** AES CCM Authenticated Decryption 192 bits key*/
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_decryption_test_case_192_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_decryption_test_case_192_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_decryption_test_case_192_3),
-
- /** AES CCM Authenticated Encryption 256 bits key */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_encryption_test_case_256_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_encryption_test_case_256_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_encryption_test_case_256_3),
+ test_device_configure_invalid_queue_pair_ids),
- /** AES CCM Authenticated Decryption 256 bits key*/
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_decryption_test_case_256_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_decryption_test_case_256_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_CCM_authenticated_decryption_test_case_256_3),
-
- /** AES GCM Authenticated Encryption */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_6),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_7),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_8),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_J0_authenticated_encryption_test_case_1),
-
- /** AES GCM Authenticated Decryption */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_6),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_7),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_8),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_J0_authenticated_decryption_test_case_1),
-
- /** AES GCM Authenticated Encryption 192 bits key */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_192_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_192_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_192_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_192_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_192_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_192_6),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_192_7),
-
- /** AES GCM Authenticated Decryption 192 bits key */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_192_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_192_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_192_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_192_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_192_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_192_6),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_192_7),
-
- /** AES GCM Authenticated Encryption 256 bits key */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_256_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_256_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_256_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_256_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_256_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_256_6),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_256_7),
-
- /** AES GCM Authenticated Decryption 256 bits key */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_256_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_256_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_256_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_256_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_256_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_256_6),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_256_7),
-
- /** AES GCM Authenticated Encryption big aad size */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_aad_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_test_case_aad_2),
-
- /** AES GCM Authenticated Decryption big aad size */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_aad_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_test_case_aad_2),
-
- /** Out of place tests */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_oop_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_oop_test_case_1),
-
- /** Session-less tests */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
-
- /** AES GMAC Authentication */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_verify_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_verify_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_verify_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_verify_test_case_4),
-
- /** SNOW 3G encrypt only (UEA2) */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_5),
-
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_1_oop),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_1_oop_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_1_offset_oop),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_1_oop),
-
- /** SNOW 3G generate auth, then encrypt (UEA2) */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_test_case_2_oop),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_part_digest_enc),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_part_digest_enc_oop),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_test_case_3_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_test_case_3_oop_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_part_digest_enc_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
-
- /** SNOW 3G decrypt (UEA2), then verify auth */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_verify_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_verify_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_verify_test_case_2_oop),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_verify_part_digest_enc),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_verify_part_digest_enc_oop),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_verify_test_case_3_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
-
- /** SNOW 3G decrypt only (UEA2) */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_with_digest_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_generate_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_generate_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_generate_test_case_3),
- /* Tests with buffers which length is not byte-aligned */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_generate_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_generate_test_case_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_generate_test_case_6),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_verify_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_verify_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_verify_test_case_3),
- /* Tests with buffers which length is not byte-aligned */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_verify_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_verify_test_case_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_verify_test_case_6),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_cipher_auth_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_auth_cipher_with_digest_test_case_1),
-
- /** ZUC encrypt only (EEA3) */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_6_sgl),
-
- /** ZUC authenticate (EIA3) */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_6),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_7),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_8),
-
- /** ZUC alg-chain (EEA3/EIA3) */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_cipher_auth_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_cipher_auth_test_case_2),
-
- /** ZUC generate auth, then encrypt (EEA3) */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_auth_cipher_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_auth_cipher_test_case_1_oop),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_auth_cipher_test_case_1_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_auth_cipher_test_case_1_oop_sgl),
-
- /** ZUC decrypt (EEA3), then verify auth */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_auth_cipher_verify_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_auth_cipher_verify_test_case_1_oop),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_auth_cipher_verify_test_case_1_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
-
- /** HMAC_MD5 Authentication */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_MD5_HMAC_generate_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_MD5_HMAC_verify_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_MD5_HMAC_generate_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_MD5_HMAC_verify_case_2),
-
- /** KASUMI hash only (UIA1) */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_6),
-
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_verify_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_verify_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_verify_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_verify_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_verify_test_case_5),
-
- /** KASUMI encrypt only (UEA1) */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1_oop),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1_oop_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_5),
-
- /** KASUMI decrypt only (UEA1) */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_5),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_1_oop),
-
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_cipher_auth_test_case_1),
-
- /** KASUMI generate auth, then encrypt (F8) */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_auth_cipher_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_auth_cipher_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_auth_cipher_test_case_2_oop),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_auth_cipher_test_case_2_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_auth_cipher_test_case_2_oop_sgl),
-
- /** KASUMI decrypt (F8), then verify auth */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_auth_cipher_verify_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_auth_cipher_verify_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_auth_cipher_verify_test_case_2_oop),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_auth_cipher_verify_test_case_2_sgl),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
-
- /** ESN Testcase */
- TEST_CASE_ST(ut_setup, ut_teardown,
- auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
- TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
-
- /** Negative tests */
- TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_data_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_tag_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_fail_iv_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_fail_in_data_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_fail_out_data_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_fail_aad_corrupt),
+ test_multi_session),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_encryption_fail_tag_corrupt),
+ test_multi_session_random_usage),
+
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_fail_iv_corrupt),
+ test_null_invalid_operation),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
+
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
+
+ /** AES CCM Authenticated Encryption 128 bits key */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_fail_in_data_corrupt),
+ test_AES_CCM_authenticated_encryption_test_case_128_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_fail_out_data_corrupt),
+ test_AES_CCM_authenticated_encryption_test_case_128_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
+ test_AES_CCM_authenticated_encryption_test_case_128_3),
+
+ /** AES CCM Authenticated Decryption 128 bits key*/
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_fail_aad_corrupt),
+ test_AES_CCM_authenticated_decryption_test_case_128_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_auth_decryption_fail_tag_corrupt),
+ test_AES_CCM_authenticated_decryption_test_case_128_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_AES128_GMAC_fail_data_corrupt),
+ test_AES_CCM_authenticated_decryption_test_case_128_3),
+
+ /** AES CCM Authenticated Encryption 192 bits key */
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_AES128_GMAC_fail_tag_corrupt),
+ test_AES_CCM_authenticated_encryption_test_case_192_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
+ test_AES_CCM_authenticated_encryption_test_case_192_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
+ test_AES_CCM_authenticated_encryption_test_case_192_3),
- /** Mixed CIPHER + HASH algorithms */
- /** AUTH AES CMAC + CIPHER AES CTR */
+ /** AES CCM Authenticated Decryption 192 bits key*/
TEST_CASE_ST(ut_setup, ut_teardown,
- test_aes_cmac_aes_ctr_digest_enc_test_case_1),
+ test_AES_CCM_authenticated_decryption_test_case_192_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
+ test_AES_CCM_authenticated_decryption_test_case_192_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
+ test_AES_CCM_authenticated_decryption_test_case_192_3),
+
+ /** AES CCM Authenticated Encryption 256 bits key */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
+ test_AES_CCM_authenticated_encryption_test_case_256_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
+ test_AES_CCM_authenticated_encryption_test_case_256_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
+ test_AES_CCM_authenticated_encryption_test_case_256_3),
+
+ /** AES CCM Authenticated Decryption 256 bits key*/
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
+ test_AES_CCM_authenticated_decryption_test_case_256_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
+ test_AES_CCM_authenticated_decryption_test_case_256_2),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_CCM_authenticated_decryption_test_case_256_3),
- /** AUTH ZUC + CIPHER SNOW3G */
+ /** AES GCM Authenticated Encryption */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_zuc_cipher_snow_test_case_1),
+ test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_zuc_cipher_snow_test_case_1),
- /** AUTH AES CMAC + CIPHER SNOW3G */
+ test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_aes_cmac_cipher_snow_test_case_1),
+ test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_aes_cmac_cipher_snow_test_case_1),
- /** AUTH ZUC + CIPHER AES CTR */
+ test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_zuc_cipher_aes_ctr_test_case_1),
+ test_AES_GCM_authenticated_encryption_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
- /** AUTH SNOW3G + CIPHER AES CTR */
+ test_AES_GCM_authenticated_encryption_test_case_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_snow_cipher_aes_ctr_test_case_1),
+ test_AES_GCM_authenticated_encryption_test_case_3),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_snow_cipher_aes_ctr_test_case_1),
- /** AUTH SNOW3G + CIPHER ZUC */
+ test_AES_GCM_authenticated_encryption_test_case_4),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_snow_cipher_zuc_test_case_1),
+ test_AES_GCM_authenticated_encryption_test_case_5),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_snow_cipher_zuc_test_case_1),
- /** AUTH AES CMAC + CIPHER ZUC */
+ test_AES_GCM_authenticated_encryption_test_case_6),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_aes_cmac_cipher_zuc_test_case_1),
+ test_AES_GCM_authenticated_encryption_test_case_7),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
+ test_AES_GCM_authenticated_encryption_test_case_8),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_GCM_J0_authenticated_encryption_test_case_1),
- /** AUTH NULL + CIPHER SNOW3G */
+ /** AES GCM Authenticated Decryption */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_null_cipher_snow_test_case_1),
+ test_AES_GCM_authenticated_decryption_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_null_cipher_snow_test_case_1),
- /** AUTH NULL + CIPHER ZUC */
+ test_AES_GCM_authenticated_decryption_test_case_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_null_cipher_zuc_test_case_1),
+ test_AES_GCM_authenticated_decryption_test_case_3),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_null_cipher_zuc_test_case_1),
- /** AUTH SNOW3G + CIPHER NULL */
+ test_AES_GCM_authenticated_decryption_test_case_4),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_snow_cipher_null_test_case_1),
+ test_AES_GCM_authenticated_decryption_test_case_5),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_snow_cipher_null_test_case_1),
- /** AUTH ZUC + CIPHER NULL */
+ test_AES_GCM_authenticated_decryption_test_case_6),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_zuc_cipher_null_test_case_1),
+ test_AES_GCM_authenticated_decryption_test_case_7),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_zuc_cipher_null_test_case_1),
- /** AUTH NULL + CIPHER AES CTR */
+ test_AES_GCM_authenticated_decryption_test_case_8),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_null_cipher_aes_ctr_test_case_1),
+ test_AES_GCM_J0_authenticated_decryption_test_case_1),
+
+ /** AES GCM Authenticated Encryption 192 bits key */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_null_cipher_aes_ctr_test_case_1),
- /** AUTH AES CMAC + CIPHER NULL */
+ test_AES_GCM_auth_encryption_test_case_192_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_auth_aes_cmac_cipher_null_test_case_1),
+ test_AES_GCM_auth_encryption_test_case_192_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_auth_aes_cmac_cipher_null_test_case_1),
-
-#ifdef RTE_LIBRTE_SECURITY
+ test_AES_GCM_auth_encryption_test_case_192_3),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_PDCP_PROTO_all),
-#endif
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_virtio_testsuite = {
- .suite_name = "Crypto VIRTIO Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
-
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_caam_jr_testsuite = {
- .suite_name = "Crypto CAAM JR Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
+ test_AES_GCM_auth_encryption_test_case_192_4),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_device_configure_invalid_dev_id),
+ test_AES_GCM_auth_encryption_test_case_192_5),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_multi_session),
-
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
-
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_armv8_testsuite = {
- .suite_name = "Crypto Device ARMv8 Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+ test_AES_GCM_auth_encryption_test_case_192_6),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_GCM_auth_encryption_test_case_192_7),
- /** Negative tests */
+ /** AES GCM Authenticated Decryption 192 bits key */
TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
+ test_AES_GCM_auth_decryption_test_case_192_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
-
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_mrvl_testsuite = {
- .suite_name = "Crypto Device Marvell Component Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
+ test_AES_GCM_auth_decryption_test_case_192_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_multi_session_random_usage),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
-
- /** Negative tests */
+ test_AES_GCM_auth_decryption_test_case_192_3),
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_data_corrupt),
+ test_AES_GCM_auth_decryption_test_case_192_4),
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_tag_corrupt),
+ test_AES_GCM_auth_decryption_test_case_192_5),
TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
+ test_AES_GCM_auth_decryption_test_case_192_6),
TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
-
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
+ test_AES_GCM_auth_decryption_test_case_192_7),
-static struct unit_test_suite cryptodev_ccp_testsuite = {
- .suite_name = "Crypto Device CCP Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
+ /** AES GCM Authenticated Encryption 256 bits key */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_multi_session_random_usage),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
-
- /** Negative tests */
+ test_AES_GCM_auth_encryption_test_case_256_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_data_corrupt),
+ test_AES_GCM_auth_encryption_test_case_256_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_tag_corrupt),
+ test_AES_GCM_auth_encryption_test_case_256_3),
TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
+ test_AES_GCM_auth_encryption_test_case_256_4),
TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
-
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_octeontx_testsuite = {
- .suite_name = "Crypto Device OCTEONTX Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+ test_AES_GCM_auth_encryption_test_case_256_5),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_GCM_auth_encryption_test_case_256_6),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_GCM_auth_encryption_test_case_256_7),
- /** AES GCM Authenticated Encryption */
+ /** AES GCM Authenticated Decryption 256 bits key */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_1),
+ test_AES_GCM_auth_decryption_test_case_256_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_2),
+ test_AES_GCM_auth_decryption_test_case_256_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_3),
+ test_AES_GCM_auth_decryption_test_case_256_3),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_4),
+ test_AES_GCM_auth_decryption_test_case_256_4),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_5),
+ test_AES_GCM_auth_decryption_test_case_256_5),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_6),
+ test_AES_GCM_auth_decryption_test_case_256_6),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_7),
+ test_AES_GCM_auth_decryption_test_case_256_7),
- /** AES GCM Authenticated Decryption */
+ /** AES GCM Authenticated Encryption big aad size */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_1),
+ test_AES_GCM_auth_encryption_test_case_aad_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_2),
+ test_AES_GCM_auth_encryption_test_case_aad_2),
+
+ /** AES GCM Authenticated Decryption big aad size */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_3),
+ test_AES_GCM_auth_decryption_test_case_aad_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_4),
+ test_AES_GCM_auth_decryption_test_case_aad_2),
+
+ /** Out of place tests */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_5),
+ test_AES_GCM_authenticated_encryption_oop_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_6),
+ test_AES_GCM_authenticated_decryption_oop_test_case_1),
+
+ /** Session-less tests */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_7),
+ test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
+
/** AES GMAC Authentication */
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_GMAC_authentication_test_case_1),
test_AES_GMAC_authentication_test_case_3),
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_GMAC_authentication_verify_test_case_3),
-
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_GMAC_authentication_test_case_4),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_GMAC_authentication_verify_test_case_4),
+ /** Chacha20-Poly1305 */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_chacha20_poly1305_encrypt_test_case_rfc8439),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_chacha20_poly1305_decrypt_test_case_rfc8439),
/** SNOW 3G encrypt only (UEA2) */
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_encryption_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_encryption_test_case_1_oop),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_encryption_test_case_1_oop_sgl),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_encryption_test_case_1_offset_oop),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_decryption_test_case_1_oop),
+
+ /** SNOW 3G generate auth, then encrypt (UEA2) */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_1_oop_sgl),
+ test_snow3g_auth_cipher_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_test_case_2),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_test_case_2_oop),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_part_digest_enc),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_part_digest_enc_oop),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_test_case_3_sgl),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_test_case_3_oop_sgl),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_part_digest_enc_sgl),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
+
+ /** SNOW 3G decrypt (UEA2), then verify auth */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_verify_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_verify_test_case_2),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_verify_test_case_2_oop),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_verify_part_digest_enc),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_verify_part_digest_enc_oop),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_verify_test_case_3_sgl),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
/** SNOW 3G decrypt only (UEA2) */
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_decryption_test_case_4),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_decryption_test_case_5),
-
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_decryption_with_digest_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_hash_generate_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_hash_generate_test_case_2),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_hash_generate_test_case_3),
+ /* Tests with buffers which length is not byte-aligned */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_hash_generate_test_case_4),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_hash_generate_test_case_5),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_hash_generate_test_case_6),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_hash_verify_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_hash_verify_test_case_2),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_hash_verify_test_case_3),
+ /* Tests with buffers which length is not byte-aligned */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_hash_verify_test_case_4),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_hash_verify_test_case_5),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_hash_verify_test_case_6),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_cipher_auth_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_snow3g_auth_cipher_with_digest_test_case_1),
/** ZUC encrypt only (EEA3) */
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_encryption_test_case_4),
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_encryption_test_case_5),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_encryption_test_case_6_sgl),
+
+ /** ZUC authenticate (EIA3) */
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_hash_generate_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_hash_generate_test_case_5),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_6_sgl),
-
- /** KASUMI encrypt only (UEA1) */
+ test_zuc_hash_generate_test_case_6),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1),
+ test_zuc_hash_generate_test_case_7),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_2),
+ test_zuc_hash_generate_test_case_8),
+
+ /** ZUC alg-chain (EEA3/EIA3) */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_3),
+ test_zuc_cipher_auth_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_4),
+ test_zuc_cipher_auth_test_case_2),
+
+ /** ZUC generate auth, then encrypt (EEA3) */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_5),
+ test_zuc_auth_cipher_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1_sgl),
+ test_zuc_auth_cipher_test_case_1_oop),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1_oop_sgl),
- /** KASUMI decrypt only (UEA1) */
+ test_zuc_auth_cipher_test_case_1_sgl),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_1),
+ test_zuc_auth_cipher_test_case_1_oop_sgl),
+
+ /** ZUC decrypt (EEA3), then verify auth */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_2),
+ test_zuc_auth_cipher_verify_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_3),
+ test_zuc_auth_cipher_verify_test_case_1_oop),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_4),
+ test_zuc_auth_cipher_verify_test_case_1_sgl),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_5),
+ test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
+ /** HMAC_MD5 Authentication */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1_oop),
+ test_MD5_HMAC_generate_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_1_oop),
+ test_MD5_HMAC_verify_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_MD5_HMAC_generate_case_2),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_MD5_HMAC_verify_case_2),
/** KASUMI hash only (UIA1) */
TEST_CASE_ST(ut_setup, ut_teardown,
test_kasumi_hash_generate_test_case_5),
TEST_CASE_ST(ut_setup, ut_teardown,
test_kasumi_hash_generate_test_case_6),
+
TEST_CASE_ST(ut_setup, ut_teardown,
test_kasumi_hash_verify_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
TEST_CASE_ST(ut_setup, ut_teardown,
test_kasumi_hash_verify_test_case_5),
- /** NULL tests */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_null_cipher_only_operation),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_null_auth_only_operation),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_null_cipher_auth_operation),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_null_auth_cipher_operation),
-
- /** Negative tests */
+ /** KASUMI encrypt only (UEA1) */
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_data_corrupt),
+ test_kasumi_encryption_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_tag_corrupt),
+ test_kasumi_encryption_test_case_1_sgl),
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_AES128_GMAC_fail_data_corrupt),
+ test_kasumi_encryption_test_case_1_oop),
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_AES128_GMAC_fail_tag_corrupt),
+ test_kasumi_encryption_test_case_1_oop_sgl),
TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
+ test_kasumi_encryption_test_case_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_nitrox_testsuite = {
- .suite_name = "Crypto NITROX Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
+ test_kasumi_encryption_test_case_3),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_device_configure_invalid_dev_id),
+ test_kasumi_encryption_test_case_4),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_device_configure_invalid_queue_pair_ids),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
-
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_octeontx2_testsuite = {
- .suite_name = "Crypto Device OCTEON TX2 Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+ test_kasumi_encryption_test_case_5),
- /** AES GCM Authenticated Encryption */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_1),
+ /** KASUMI decrypt only (UEA1) */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_2),
+ test_kasumi_decryption_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_3),
+ test_kasumi_decryption_test_case_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_4),
+ test_kasumi_decryption_test_case_3),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_5),
+ test_kasumi_decryption_test_case_4),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_6),
+ test_kasumi_decryption_test_case_5),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_encryption_test_case_7),
+ test_kasumi_decryption_test_case_1_oop),
- /** AES GCM Authenticated Decryption */
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_1),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_2),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_3),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_4),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_5),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_6),
+ test_kasumi_cipher_auth_test_case_1),
+
+ /** KASUMI generate auth, then encrypt (F8) */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GCM_authenticated_decryption_test_case_7),
- /** AES GMAC Authentication */
+ test_kasumi_auth_cipher_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_test_case_1),
+ test_kasumi_auth_cipher_test_case_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_verify_test_case_1),
+ test_kasumi_auth_cipher_test_case_2_oop),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_test_case_2),
+ test_kasumi_auth_cipher_test_case_2_sgl),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_verify_test_case_2),
+ test_kasumi_auth_cipher_test_case_2_oop_sgl),
+
+ /** KASUMI decrypt (F8), then verify auth */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_test_case_3),
+ test_kasumi_auth_cipher_verify_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_GMAC_authentication_verify_test_case_3),
-
- /** SNOW 3G encrypt only (UEA2) */
+ test_kasumi_auth_cipher_verify_test_case_2),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_1),
+ test_kasumi_auth_cipher_verify_test_case_2_oop),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_2),
+ test_kasumi_auth_cipher_verify_test_case_2_sgl),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_3),
+ test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
+
+ /** ESN Testcase */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_4),
+ auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_5),
+ auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
+ /** Negative tests */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_1_oop),
+ authentication_verify_HMAC_SHA1_fail_data_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_1_oop),
+ authentication_verify_HMAC_SHA1_fail_tag_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_encryption_test_case_1_oop_sgl),
-
- /** SNOW 3G decrypt only (UEA2) */
+ test_AES_GCM_auth_encryption_fail_iv_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_1),
+ test_AES_GCM_auth_encryption_fail_in_data_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_2),
+ test_AES_GCM_auth_encryption_fail_out_data_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_3),
+ test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_4),
+ test_AES_GCM_auth_encryption_fail_aad_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_decryption_test_case_5),
-
+ test_AES_GCM_auth_encryption_fail_tag_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_generate_test_case_1),
+ test_AES_GCM_auth_decryption_fail_iv_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_generate_test_case_2),
+ test_AES_GCM_auth_decryption_fail_in_data_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_generate_test_case_3),
+ test_AES_GCM_auth_decryption_fail_out_data_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_verify_test_case_1),
+ test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_verify_test_case_2),
+ test_AES_GCM_auth_decryption_fail_aad_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_snow3g_hash_verify_test_case_3),
-
- /** ZUC encrypt only (EEA3) */
+ test_AES_GCM_auth_decryption_fail_tag_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_1),
+ authentication_verify_AES128_GMAC_fail_data_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_2),
+ authentication_verify_AES128_GMAC_fail_tag_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_3),
+ auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_4),
+ auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
+
+ /** Mixed CIPHER + HASH algorithms */
+ /** AUTH AES CMAC + CIPHER AES CTR */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_5),
+ test_aes_cmac_aes_ctr_digest_enc_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_1),
+ test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_2),
+ test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_3),
+ test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_4),
+ test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_hash_generate_test_case_5),
+ test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_zuc_encryption_test_case_6_sgl),
+ test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
- /** KASUMI encrypt only (UEA1) */
+ /** AUTH ZUC + CIPHER SNOW3G */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1),
+ test_auth_zuc_cipher_snow_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_2),
+ test_verify_auth_zuc_cipher_snow_test_case_1),
+ /** AUTH AES CMAC + CIPHER SNOW3G */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_3),
+ test_auth_aes_cmac_cipher_snow_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_4),
+ test_verify_auth_aes_cmac_cipher_snow_test_case_1),
+ /** AUTH ZUC + CIPHER AES CTR */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_5),
+ test_auth_zuc_cipher_aes_ctr_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1_sgl),
+ test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
+ /** AUTH SNOW3G + CIPHER AES CTR */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1_oop_sgl),
- /** KASUMI decrypt only (UEA1) */
+ test_auth_snow_cipher_aes_ctr_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_1),
+ test_verify_auth_snow_cipher_aes_ctr_test_case_1),
+ /** AUTH SNOW3G + CIPHER ZUC */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_2),
+ test_auth_snow_cipher_zuc_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_3),
+ test_verify_auth_snow_cipher_zuc_test_case_1),
+ /** AUTH AES CMAC + CIPHER ZUC */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_4),
+ test_auth_aes_cmac_cipher_zuc_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_5),
+ test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
+ /** AUTH NULL + CIPHER SNOW3G */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_encryption_test_case_1_oop),
+ test_auth_null_cipher_snow_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_decryption_test_case_1_oop),
-
- /** KASUMI hash only (UIA1) */
+ test_verify_auth_null_cipher_snow_test_case_1),
+ /** AUTH NULL + CIPHER ZUC */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_1),
+ test_auth_null_cipher_zuc_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_2),
+ test_verify_auth_null_cipher_zuc_test_case_1),
+ /** AUTH SNOW3G + CIPHER NULL */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_3),
+ test_auth_snow_cipher_null_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_4),
+ test_verify_auth_snow_cipher_null_test_case_1),
+ /** AUTH ZUC + CIPHER NULL */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_5),
+ test_auth_zuc_cipher_null_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_generate_test_case_6),
+ test_verify_auth_zuc_cipher_null_test_case_1),
+ /** AUTH NULL + CIPHER AES CTR */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_verify_test_case_1),
+ test_auth_null_cipher_aes_ctr_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_verify_test_case_2),
+ test_verify_auth_null_cipher_aes_ctr_test_case_1),
+ /** AUTH AES CMAC + CIPHER NULL */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_verify_test_case_3),
+ test_auth_aes_cmac_cipher_null_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_verify_test_case_4),
+ test_verify_auth_aes_cmac_cipher_null_test_case_1),
+
+#ifdef RTE_LIBRTE_SECURITY
TEST_CASE_ST(ut_setup, ut_teardown,
- test_kasumi_hash_verify_test_case_5),
+ test_PDCP_PROTO_all),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_DOCSIS_PROTO_all),
+#endif
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
+
+static struct unit_test_suite cryptodev_virtio_testsuite = {
+ .suite_name = "Crypto VIRTIO Unit Test Suite",
+ .setup = testsuite_setup,
+ .teardown = testsuite_teardown,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
+
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
- /** NULL tests */
+static struct unit_test_suite cryptodev_caam_jr_testsuite = {
+ .suite_name = "Crypto CAAM JR Unit Test Suite",
+ .setup = testsuite_setup,
+ .teardown = testsuite_teardown,
+ .unit_test_cases = {
TEST_CASE_ST(ut_setup, ut_teardown,
- test_null_cipher_only_operation),
+ test_device_configure_invalid_dev_id),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_multi_session),
+
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
+
+static struct unit_test_suite cryptodev_armv8_testsuite = {
+ .suite_name = "Crypto Device ARMv8 Unit Test Suite",
+ .setup = testsuite_setup,
+ .teardown = testsuite_teardown,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+
+ /** Negative tests */
TEST_CASE_ST(ut_setup, ut_teardown,
- test_null_auth_only_operation),
+ auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_null_cipher_auth_operation),
+ auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
+
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
+
+static struct unit_test_suite cryptodev_mrvl_testsuite = {
+ .suite_name = "Crypto Device Marvell Component Test Suite",
+ .setup = testsuite_setup,
+ .teardown = testsuite_teardown,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_null_auth_cipher_operation),
+ test_multi_session_random_usage),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
/** Negative tests */
TEST_CASE_ST(ut_setup, ut_teardown,
TEST_CASE_ST(ut_setup, ut_teardown,
authentication_verify_HMAC_SHA1_fail_tag_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_AES128_GMAC_fail_data_corrupt),
+ auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_AES128_GMAC_fail_tag_corrupt),
+ auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
+
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
+
+static struct unit_test_suite cryptodev_ccp_testsuite = {
+ .suite_name = "Crypto Device CCP Unit Test Suite",
+ .setup = testsuite_setup,
+ .teardown = testsuite_teardown,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_multi_session_random_usage),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+
+ /** Negative tests */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ authentication_verify_HMAC_SHA1_fail_data_corrupt),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ authentication_verify_HMAC_SHA1_fail_tag_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
+
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
+
+static struct unit_test_suite cryptodev_nitrox_testsuite = {
+ .suite_name = "Crypto NITROX Unit Test Suite",
+ .setup = testsuite_setup,
+ .teardown = testsuite_teardown,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_device_configure_invalid_dev_id),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_device_configure_invalid_queue_pair_ids),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
+
TEST_CASES_END() /**< NULL terminate unit test array */
}
};
"testsuite.\n");
return TEST_FAILED;
}
- return unit_test_suite_runner(&cryptodev_octeontx_testsuite);
+ return unit_test_suite_runner(&cryptodev_testsuite);
}
static int
"testsuite.\n");
return TEST_FAILED;
}
- return unit_test_suite_runner(&cryptodev_octeontx2_testsuite);
+ return unit_test_suite_runner(&cryptodev_testsuite);
}
static int