X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;ds=sidebyside;f=app%2Ftest%2Ftest_cryptodev.c;h=e71e73ae1f0433ed67c3e449ff976c958bed2627;hb=f5ed2ea0ce8303592d16a3aa3fa60a7c0c4c2d5f;hp=08a12af25ab6abfade8dd01060c2a4d355788616;hpb=33c9e904fb6d959da26b55c24a81ad6c8da3f57f;p=dpdk.git diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index 08a12af25a..e71e73ae1f 100644 --- a/app/test/test_cryptodev.c +++ b/app/test/test_cryptodev.c @@ -11,6 +11,7 @@ #include #include #include +#include #include #include @@ -42,6 +43,7 @@ #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 @@ -72,6 +74,9 @@ struct crypto_unittest_params { 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; @@ -767,27 +772,19 @@ test_device_configure_invalid_queue_pair_ids(void) 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), @@ -838,24 +835,14 @@ static int 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", @@ -909,36 +896,6 @@ test_queue_pair_descriptor_setup(void) 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++) { @@ -953,21 +910,6 @@ test_queue_pair_descriptor_setup(void) 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 */ @@ -7130,6 +7072,34 @@ test_authenticated_encryption(const struct aead_test_data *tdata) } #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 @@ -7191,7 +7161,9 @@ test_pdcp_proto(int i, int oop, 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) { @@ -7216,8 +7188,18 @@ test_pdcp_proto(int i, int oop, .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 }; @@ -7244,6 +7226,10 @@ test_pdcp_proto(int i, int oop, 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 */ @@ -7475,6 +7461,7 @@ test_pdcp_proto_SGL(int i, int oop, .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 }; @@ -7733,6 +7720,9 @@ test_PDCP_PROTO_all(void) 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(); @@ -7747,280 +7737,755 @@ test_PDCP_PROTO_all(void) 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], @@ -8813,8 +9278,6 @@ test_stats(void) { 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; @@ -8832,19 +9295,16 @@ test_stats(void) &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(); @@ -9315,105 +9775,86 @@ test_multi_session_random_usage(void) 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; @@ -9427,475 +9868,602 @@ test_null_auth_only_operation(void) /* 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"); @@ -9903,748 +10471,435 @@ static int create_gmac_session(uint8_t dev_id, } 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], @@ -10662,31 +10917,66 @@ test_authentication_verify_fail_when_data_corruption( } 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, @@ -10701,198 +10991,17 @@ test_authentication_verify_GMAC_fail_when_corruption( 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); @@ -11570,6 +11679,18 @@ auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void) &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 */ @@ -11799,768 +11920,214 @@ static struct unit_test_suite cryptodev_testsuite = { .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), @@ -12574,7 +12141,15 @@ static struct unit_test_suite cryptodev_octeontx_testsuite = { 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), @@ -12589,10 +12164,52 @@ static struct unit_test_suite cryptodev_octeontx_testsuite = { 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, @@ -12605,19 +12222,38 @@ static struct unit_test_suite cryptodev_octeontx_testsuite = { 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, @@ -12630,6 +12266,10 @@ static struct unit_test_suite cryptodev_octeontx_testsuite = { 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, @@ -12641,39 +12281,47 @@ static struct unit_test_suite cryptodev_octeontx_testsuite = { 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, @@ -12688,6 +12336,7 @@ static struct unit_test_suite cryptodev_octeontx_testsuite = { 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, @@ -12699,238 +12348,261 @@ static struct unit_test_suite cryptodev_octeontx_testsuite = { 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, @@ -12938,13 +12610,54 @@ static struct unit_test_suite cryptodev_octeontx2_testsuite = { 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 */ } }; @@ -13259,7 +12972,7 @@ test_cryptodev_octeontx(void) "testsuite.\n"); return TEST_FAILED; } - return unit_test_suite_runner(&cryptodev_octeontx_testsuite); + return unit_test_suite_runner(&cryptodev_testsuite); } static int @@ -13274,7 +12987,7 @@ test_cryptodev_octeontx2(void) "testsuite.\n"); return TEST_FAILED; } - return unit_test_suite_runner(&cryptodev_octeontx2_testsuite); + return unit_test_suite_runner(&cryptodev_testsuite); } static int