X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_cryptodev.c;h=e71e73ae1f0433ed67c3e449ff976c958bed2627;hb=f5ed2ea0ce8303592d16a3aa3fa60a7c0c4c2d5f;hp=aa9eda5e55f772af9bd9a27b41e1b1f99a4eac32;hpb=5bf52c656e243666c70cc6203963cca71b9d476d;p=dpdk.git diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index aa9eda5e55..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; @@ -830,18 +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; /* 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", @@ -895,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++) { @@ -939,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 */ @@ -7116,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 @@ -7177,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) { @@ -7202,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 }; @@ -7230,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 */ @@ -7461,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 }; @@ -7719,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(); @@ -7733,514 +7737,651 @@ 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; + } -static int -test_AES_GCM_auth_encryption_test_case_aad_1(void) -{ - return test_authenticated_encryption(&gcm_test_case_aad_1); -} +on_err: + rte_crypto_op_free(ut_params->op); + ut_params->op = NULL; -static int -test_AES_GCM_auth_encryption_test_case_aad_2(void) -{ - return test_authenticated_encryption(&gcm_test_case_aad_2); + 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_fail_iv_corrupt(void) +test_docsis_proto_downlink(int i, struct docsis_test_data *d_td) { - struct aead_test_data tdata; - int res; + 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; - 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; -} + struct rte_security_ctx *ctx = (struct rte_security_ctx *) + rte_cryptodev_get_sec_ctx( + ts_params->valid_devs[0]); -static int -test_AES_GCM_auth_encryption_fail_out_data_corrupt(void) -{ - struct aead_test_data tdata; - int res; + /* 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; - 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; -} + 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; -static int -test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void) -{ - struct aead_test_data tdata; - int res; + sec_cap = rte_security_capability_get(ctx, &sec_cap_idx); + if (sec_cap == NULL) + return -ENOTSUP; - 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; -} + 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_auth_encryption_fail_aad_corrupt(void) -{ - struct aead_test_data tdata; - uint8_t aad[gcm_test_case_7.aad.len]; - int res; + if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED) + return -ENOTSUP; - 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; -} + /* 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_auth_encryption_fail_tag_corrupt(void) -{ - struct aead_test_data tdata; - int res; + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + d_td->plaintext.len); - 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; -} + memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len); -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; + /* Set session action type */ + ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; - int retval; - uint8_t *plaintext; - uint32_t i; + /* 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; - /* 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; + /* Setup DOCSIS session parameters */ + ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK; - /* Create AEAD session */ - retval = create_aead_session(ts_params->valid_devs[0], - tdata->algo, - RTE_CRYPTO_AEAD_OP_DECRYPT, - tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->auth_tag.len, - tdata->iv.len); - if (retval < 0) - return retval; + 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, + }; - /* alloc mbuf and set payload */ - if (tdata->aad.len > MBUF_SIZE) { - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); - /* Populate full size of add data */ - for (i = 32; i < MAX_AAD_LENGTH; i += 32) - memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); - } else - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + /* Create security session */ + ut_params->sec_session = rte_security_session_create(ctx, &sess_conf, + ts_params->session_priv_mpool); - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + 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; + } - /* Create AEAD operation */ - retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); - if (retval < 0) - return retval; + /* 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; + } - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + /* 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 (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) - process_cpu_aead_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"); + 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; + } - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing failed"); + 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; + } - if (ut_params->op->sym->m_dst) - plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, - uint8_t *); - else - plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, - uint8_t *, - ut_params->op->sym->cipher.data.offset); + /* Validate ciphertext */ + ciphertext = plaintext; - debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); + 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; + } - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - plaintext, - tdata->plaintext.data, - tdata->plaintext.len, - "Plaintext data not as expected"); +on_err: + rte_crypto_op_free(ut_params->op); + ut_params->op = NULL; - TEST_ASSERT_EQUAL(ut_params->op->status, - RTE_CRYPTO_OP_STATUS_SUCCESS, - "Authentication failed"); + if (ut_params->sec_session) + rte_security_session_destroy(ctx, ut_params->sec_session); + ut_params->sec_session = NULL; - return 0; + 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_authenticated_decryption_test_case_1(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_decryption(&gcm_test_case_1); + 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_authenticated_decryption_test_case_2(void) +test_AES_GCM_authenticated_encryption_test_case_1(void) { - return test_authenticated_decryption(&gcm_test_case_2); + return test_authenticated_encryption(&gcm_test_case_1); } static int -test_AES_GCM_authenticated_decryption_test_case_3(void) +test_AES_GCM_authenticated_encryption_test_case_2(void) { - return test_authenticated_decryption(&gcm_test_case_3); + return test_authenticated_encryption(&gcm_test_case_2); } static int -test_AES_GCM_authenticated_decryption_test_case_4(void) +test_AES_GCM_authenticated_encryption_test_case_3(void) { - return test_authenticated_decryption(&gcm_test_case_4); + return test_authenticated_encryption(&gcm_test_case_3); } static int -test_AES_GCM_authenticated_decryption_test_case_5(void) +test_AES_GCM_authenticated_encryption_test_case_4(void) { - return test_authenticated_decryption(&gcm_test_case_5); + return test_authenticated_encryption(&gcm_test_case_4); } static int -test_AES_GCM_authenticated_decryption_test_case_6(void) +test_AES_GCM_authenticated_encryption_test_case_5(void) { - return test_authenticated_decryption(&gcm_test_case_6); + return test_authenticated_encryption(&gcm_test_case_5); } static int -test_AES_GCM_authenticated_decryption_test_case_7(void) +test_AES_GCM_authenticated_encryption_test_case_6(void) { - return test_authenticated_decryption(&gcm_test_case_7); + return test_authenticated_encryption(&gcm_test_case_6); } static int -test_AES_GCM_authenticated_decryption_test_case_8(void) +test_AES_GCM_authenticated_encryption_test_case_7(void) { - return test_authenticated_decryption(&gcm_test_case_8); + return test_authenticated_encryption(&gcm_test_case_7); } static int -test_AES_GCM_J0_authenticated_decryption_test_case_1(void) +test_AES_GCM_authenticated_encryption_test_case_8(void) { - return test_authenticated_decryption(&gcm_J0_test_case_1); + return test_authenticated_encryption(&gcm_test_case_8); } static int -test_AES_GCM_auth_decryption_test_case_192_1(void) +test_AES_GCM_J0_authenticated_encryption_test_case_1(void) { - return test_authenticated_decryption(&gcm_test_case_192_1); + return test_authenticated_encryption(&gcm_J0_test_case_1); } static int -test_AES_GCM_auth_decryption_test_case_192_2(void) +test_AES_GCM_auth_encryption_test_case_192_1(void) { - return test_authenticated_decryption(&gcm_test_case_192_2); + return test_authenticated_encryption(&gcm_test_case_192_1); } static int -test_AES_GCM_auth_decryption_test_case_192_3(void) +test_AES_GCM_auth_encryption_test_case_192_2(void) { - return test_authenticated_decryption(&gcm_test_case_192_3); + return test_authenticated_encryption(&gcm_test_case_192_2); } static int -test_AES_GCM_auth_decryption_test_case_192_4(void) +test_AES_GCM_auth_encryption_test_case_192_3(void) { - return test_authenticated_decryption(&gcm_test_case_192_4); + return test_authenticated_encryption(&gcm_test_case_192_3); } static int -test_AES_GCM_auth_decryption_test_case_192_5(void) +test_AES_GCM_auth_encryption_test_case_192_4(void) { - return test_authenticated_decryption(&gcm_test_case_192_5); + return test_authenticated_encryption(&gcm_test_case_192_4); } static int -test_AES_GCM_auth_decryption_test_case_192_6(void) +test_AES_GCM_auth_encryption_test_case_192_5(void) { - return test_authenticated_decryption(&gcm_test_case_192_6); + return test_authenticated_encryption(&gcm_test_case_192_5); } static int -test_AES_GCM_auth_decryption_test_case_192_7(void) +test_AES_GCM_auth_encryption_test_case_192_6(void) { - return test_authenticated_decryption(&gcm_test_case_192_7); + return test_authenticated_encryption(&gcm_test_case_192_6); } static int -test_AES_GCM_auth_decryption_test_case_256_1(void) +test_AES_GCM_auth_encryption_test_case_192_7(void) { - return test_authenticated_decryption(&gcm_test_case_256_1); + return test_authenticated_encryption(&gcm_test_case_192_7); } static int -test_AES_GCM_auth_decryption_test_case_256_2(void) +test_AES_GCM_auth_encryption_test_case_256_1(void) { - return test_authenticated_decryption(&gcm_test_case_256_2); + return test_authenticated_encryption(&gcm_test_case_256_1); } static int -test_AES_GCM_auth_decryption_test_case_256_3(void) +test_AES_GCM_auth_encryption_test_case_256_2(void) { - return test_authenticated_decryption(&gcm_test_case_256_3); + return test_authenticated_encryption(&gcm_test_case_256_2); } static int -test_AES_GCM_auth_decryption_test_case_256_4(void) +test_AES_GCM_auth_encryption_test_case_256_3(void) { - return test_authenticated_decryption(&gcm_test_case_256_4); + return test_authenticated_encryption(&gcm_test_case_256_3); } static int -test_AES_GCM_auth_decryption_test_case_256_5(void) +test_AES_GCM_auth_encryption_test_case_256_4(void) { - return test_authenticated_decryption(&gcm_test_case_256_5); + return test_authenticated_encryption(&gcm_test_case_256_4); } static int -test_AES_GCM_auth_decryption_test_case_256_6(void) +test_AES_GCM_auth_encryption_test_case_256_5(void) { - return test_authenticated_decryption(&gcm_test_case_256_6); + return test_authenticated_encryption(&gcm_test_case_256_5); } static int -test_AES_GCM_auth_decryption_test_case_256_7(void) +test_AES_GCM_auth_encryption_test_case_256_6(void) { - return test_authenticated_decryption(&gcm_test_case_256_7); + return test_authenticated_encryption(&gcm_test_case_256_6); } static int -test_AES_GCM_auth_decryption_test_case_aad_1(void) +test_AES_GCM_auth_encryption_test_case_256_7(void) { - return test_authenticated_decryption(&gcm_test_case_aad_1); + return test_authenticated_encryption(&gcm_test_case_256_7); } static int -test_AES_GCM_auth_decryption_test_case_aad_2(void) +test_AES_GCM_auth_encryption_test_case_aad_1(void) { - return test_authenticated_decryption(&gcm_test_case_aad_2); + return test_authenticated_encryption(&gcm_test_case_aad_1); } static int -test_AES_GCM_auth_decryption_fail_iv_corrupt(void) +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_decryption(&tdata); + res = test_authenticated_encryption(&tdata); if (res == -ENOTSUP) return res; - TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); return TEST_SUCCESS; } static int -test_AES_GCM_auth_decryption_fail_in_data_corrupt(void) +test_AES_GCM_auth_encryption_fail_in_data_corrupt(void) { struct aead_test_data tdata; int res; @@ -8248,185 +8389,102 @@ test_AES_GCM_auth_decryption_fail_in_data_corrupt(void) 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_decryption(&tdata); + res = test_authenticated_encryption(&tdata); if (res == -ENOTSUP) return res; - TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); return TEST_SUCCESS; } static int -test_AES_GCM_auth_decryption_fail_out_data_corrupt(void) +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_decryption(&tdata); + res = test_authenticated_encryption(&tdata); if (res == -ENOTSUP) return res; - TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); return TEST_SUCCESS; } static int -test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void) +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_decryption(&tdata); + res = test_authenticated_encryption(&tdata); if (res == -ENOTSUP) return res; - TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); return TEST_SUCCESS; } static int -test_AES_GCM_auth_decryption_fail_aad_corrupt(void) +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_decryption(&tdata); + res = test_authenticated_encryption(&tdata); if (res == -ENOTSUP) return res; - TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); return TEST_SUCCESS; } static int -test_AES_GCM_auth_decryption_fail_tag_corrupt(void) +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_decryption(&tdata); + res = test_authenticated_encryption(&tdata); if (res == -ENOTSUP) return res; - TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed"); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); return TEST_SUCCESS; } static int -test_authenticated_encryption_oop(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 *ciphertext, *auth_tag; - uint16_t plaintext_pad_len; - - /* Verify the capabilities */ - struct rte_cryptodev_sym_capability_idx cap_idx; - cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; - cap_idx.algo.aead = tdata->algo; - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) - return -ENOTSUP; - - /* not supported with CPU crypto */ - if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) - return -ENOTSUP; - - /* Create AEAD session */ - retval = create_aead_session(ts_params->valid_devs[0], - tdata->algo, - RTE_CRYPTO_AEAD_OP_ENCRYPT, - tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->auth_tag.len, - tdata->iv.len); - if (retval < 0) - return retval; - - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - - /* clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); - memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->obuf)); - - /* Create AEAD operation */ - retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); - if (retval < 0) - return retval; - - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - - ut_params->op->sym->m_src = ut_params->ibuf; - ut_params->op->sym->m_dst = ut_params->obuf; - - /* Process crypto operation */ - 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"); - - plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); - - ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, - ut_params->op->sym->cipher.data.offset); - auth_tag = ciphertext + plaintext_pad_len; - - debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); - debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); - - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ciphertext, - tdata->ciphertext.data, - tdata->ciphertext.len, - "Ciphertext data not as expected"); - - TEST_ASSERT_BUFFERS_ARE_EQUAL( - auth_tag, - tdata->auth_tag.data, - tdata->auth_tag.len, - "Generated auth tag not as expected"); - - return 0; - -} - -static int -test_AES_GCM_authenticated_encryption_oop_test_case_1(void) -{ - return test_authenticated_encryption_oop(&gcm_test_case_5); -} - -static int -test_authenticated_decryption_oop(const struct aead_test_data *tdata) +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; - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) + capability = rte_cryptodev_sym_capability_get( + ts_params->valid_devs[0], &cap_idx); + if (capability == NULL) return -ENOTSUP; - - /* not supported with CPU crypto */ - if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + 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 */ @@ -8440,13 +8498,16 @@ test_authenticated_decryption_oop(const struct aead_test_data *tdata) return retval; /* alloc mbuf and set payload */ - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + if (tdata->aad.len > MBUF_SIZE) { + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); + /* Populate full size of add data */ + for (i = 32; i < MAX_AAD_LENGTH; i += 32) + memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); + } else + 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)); - memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->obuf)); /* Create AEAD operation */ retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); @@ -8456,17 +8517,25 @@ test_authenticated_decryption_oop(const struct aead_test_data *tdata) rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); ut_params->op->sym->m_src = ut_params->ibuf; - ut_params->op->sym->m_dst = ut_params->obuf; /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_aead_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"); TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, "crypto op processing failed"); - plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, - ut_params->op->sym->cipher.data.offset); + if (ut_params->op->sym->m_dst) + plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, + uint8_t *); + else + plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, + uint8_t *, + ut_params->op->sym->cipher.data.offset); debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); @@ -8480,1135 +8549,955 @@ test_authenticated_decryption_oop(const struct aead_test_data *tdata) TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, "Authentication failed"); + return 0; } static int -test_AES_GCM_authenticated_decryption_oop_test_case_1(void) +test_AES_GCM_authenticated_decryption_test_case_1(void) { - return test_authenticated_decryption_oop(&gcm_test_case_5); + return test_authenticated_decryption(&gcm_test_case_1); } static int -test_authenticated_encryption_sessionless( - const struct aead_test_data *tdata) +test_AES_GCM_authenticated_decryption_test_case_2(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - - int retval; - uint8_t *ciphertext, *auth_tag; - uint16_t plaintext_pad_len; - uint8_t key[tdata->key.len + 1]; - struct rte_cryptodev_info dev_info; - - 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_SYM_SESSIONLESS)) { - printf("Device doesn't support Sessionless ops.\n"); - return -ENOTSUP; - } - - /* not supported with CPU crypto */ - if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) - return -ENOTSUP; - - /* Verify the capabilities */ - struct rte_cryptodev_sym_capability_idx cap_idx; - cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; - cap_idx.algo.aead = tdata->algo; - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) - return -ENOTSUP; - - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - - /* clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); - - /* Create AEAD operation */ - retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); - if (retval < 0) - return retval; - - /* Create GCM xform */ - memcpy(key, tdata->key.data, tdata->key.len); - retval = create_aead_xform(ut_params->op, - tdata->algo, - RTE_CRYPTO_AEAD_OP_ENCRYPT, - key, tdata->key.len, - tdata->aad.len, tdata->auth_tag.len, - tdata->iv.len); - if (retval < 0) - return retval; - - ut_params->op->sym->m_src = ut_params->ibuf; - - TEST_ASSERT_EQUAL(ut_params->op->sess_type, - RTE_CRYPTO_OP_SESSIONLESS, - "crypto op session type not sessionless"); - - /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); - - TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op status not success"); - - plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); - - ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, - ut_params->op->sym->cipher.data.offset); - auth_tag = ciphertext + plaintext_pad_len; - - debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); - debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); - - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ciphertext, - tdata->ciphertext.data, - tdata->ciphertext.len, - "Ciphertext data not as expected"); - - TEST_ASSERT_BUFFERS_ARE_EQUAL( - auth_tag, - tdata->auth_tag.data, - tdata->auth_tag.len, - "Generated auth tag not as expected"); - - return 0; - + return test_authenticated_decryption(&gcm_test_case_2); } static int -test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void) +test_AES_GCM_authenticated_decryption_test_case_3(void) { - return test_authenticated_encryption_sessionless( - &gcm_test_case_5); + return test_authenticated_decryption(&gcm_test_case_3); } static int -test_authenticated_decryption_sessionless( - const struct aead_test_data *tdata) +test_AES_GCM_authenticated_decryption_test_case_4(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - - int retval; - uint8_t *plaintext; - uint8_t key[tdata->key.len + 1]; - struct rte_cryptodev_info dev_info; - - 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_SYM_SESSIONLESS)) { - printf("Device doesn't support Sessionless ops.\n"); - return -ENOTSUP; - } - - /* not supported with CPU crypto */ - if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) - return -ENOTSUP; - - /* Verify the capabilities */ - struct rte_cryptodev_sym_capability_idx cap_idx; - cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; - cap_idx.algo.aead = tdata->algo; - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) - return -ENOTSUP; - - /* alloc mbuf and set 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)); - - /* Create AEAD operation */ - retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); - if (retval < 0) - return retval; - - /* Create AEAD xform */ - memcpy(key, tdata->key.data, tdata->key.len); - retval = create_aead_xform(ut_params->op, - tdata->algo, - RTE_CRYPTO_AEAD_OP_DECRYPT, - key, tdata->key.len, - tdata->aad.len, tdata->auth_tag.len, - tdata->iv.len); - if (retval < 0) - return retval; - - ut_params->op->sym->m_src = ut_params->ibuf; - - TEST_ASSERT_EQUAL(ut_params->op->sess_type, - RTE_CRYPTO_OP_SESSIONLESS, - "crypto op session type not sessionless"); - - /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); - - TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op status not success"); - - plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, - ut_params->op->sym->cipher.data.offset); - - debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); - - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - plaintext, - tdata->plaintext.data, - tdata->plaintext.len, - "Plaintext data not as expected"); - - TEST_ASSERT_EQUAL(ut_params->op->status, - RTE_CRYPTO_OP_STATUS_SUCCESS, - "Authentication failed"); - return 0; + return test_authenticated_decryption(&gcm_test_case_4); } static int -test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void) +test_AES_GCM_authenticated_decryption_test_case_5(void) { - return test_authenticated_decryption_sessionless( - &gcm_test_case_5); + return test_authenticated_decryption(&gcm_test_case_5); } static int -test_AES_CCM_authenticated_encryption_test_case_128_1(void) +test_AES_GCM_authenticated_decryption_test_case_6(void) { - return test_authenticated_encryption(&ccm_test_case_128_1); + return test_authenticated_decryption(&gcm_test_case_6); } static int -test_AES_CCM_authenticated_encryption_test_case_128_2(void) +test_AES_GCM_authenticated_decryption_test_case_7(void) { - return test_authenticated_encryption(&ccm_test_case_128_2); + return test_authenticated_decryption(&gcm_test_case_7); } static int -test_AES_CCM_authenticated_encryption_test_case_128_3(void) +test_AES_GCM_authenticated_decryption_test_case_8(void) { - return test_authenticated_encryption(&ccm_test_case_128_3); + return test_authenticated_decryption(&gcm_test_case_8); } static int -test_AES_CCM_authenticated_decryption_test_case_128_1(void) +test_AES_GCM_J0_authenticated_decryption_test_case_1(void) { - return test_authenticated_decryption(&ccm_test_case_128_1); + return test_authenticated_decryption(&gcm_J0_test_case_1); } static int -test_AES_CCM_authenticated_decryption_test_case_128_2(void) +test_AES_GCM_auth_decryption_test_case_192_1(void) { - return test_authenticated_decryption(&ccm_test_case_128_2); + return test_authenticated_decryption(&gcm_test_case_192_1); } static int -test_AES_CCM_authenticated_decryption_test_case_128_3(void) +test_AES_GCM_auth_decryption_test_case_192_2(void) { - return test_authenticated_decryption(&ccm_test_case_128_3); + return test_authenticated_decryption(&gcm_test_case_192_2); } static int -test_AES_CCM_authenticated_encryption_test_case_192_1(void) +test_AES_GCM_auth_decryption_test_case_192_3(void) { - return test_authenticated_encryption(&ccm_test_case_192_1); + return test_authenticated_decryption(&gcm_test_case_192_3); } static int -test_AES_CCM_authenticated_encryption_test_case_192_2(void) +test_AES_GCM_auth_decryption_test_case_192_4(void) { - return test_authenticated_encryption(&ccm_test_case_192_2); + return test_authenticated_decryption(&gcm_test_case_192_4); } static int -test_AES_CCM_authenticated_encryption_test_case_192_3(void) +test_AES_GCM_auth_decryption_test_case_192_5(void) { - return test_authenticated_encryption(&ccm_test_case_192_3); + return test_authenticated_decryption(&gcm_test_case_192_5); } static int -test_AES_CCM_authenticated_decryption_test_case_192_1(void) +test_AES_GCM_auth_decryption_test_case_192_6(void) { - return test_authenticated_decryption(&ccm_test_case_192_1); + return test_authenticated_decryption(&gcm_test_case_192_6); } static int -test_AES_CCM_authenticated_decryption_test_case_192_2(void) +test_AES_GCM_auth_decryption_test_case_192_7(void) { - return test_authenticated_decryption(&ccm_test_case_192_2); + return test_authenticated_decryption(&gcm_test_case_192_7); } static int -test_AES_CCM_authenticated_decryption_test_case_192_3(void) +test_AES_GCM_auth_decryption_test_case_256_1(void) { - return test_authenticated_decryption(&ccm_test_case_192_3); + return test_authenticated_decryption(&gcm_test_case_256_1); } static int -test_AES_CCM_authenticated_encryption_test_case_256_1(void) +test_AES_GCM_auth_decryption_test_case_256_2(void) { - return test_authenticated_encryption(&ccm_test_case_256_1); + return test_authenticated_decryption(&gcm_test_case_256_2); } static int -test_AES_CCM_authenticated_encryption_test_case_256_2(void) +test_AES_GCM_auth_decryption_test_case_256_3(void) { - return test_authenticated_encryption(&ccm_test_case_256_2); + return test_authenticated_decryption(&gcm_test_case_256_3); } static int -test_AES_CCM_authenticated_encryption_test_case_256_3(void) +test_AES_GCM_auth_decryption_test_case_256_4(void) { - return test_authenticated_encryption(&ccm_test_case_256_3); + return test_authenticated_decryption(&gcm_test_case_256_4); } static int -test_AES_CCM_authenticated_decryption_test_case_256_1(void) +test_AES_GCM_auth_decryption_test_case_256_5(void) { - return test_authenticated_decryption(&ccm_test_case_256_1); + return test_authenticated_decryption(&gcm_test_case_256_5); } static int -test_AES_CCM_authenticated_decryption_test_case_256_2(void) +test_AES_GCM_auth_decryption_test_case_256_6(void) { - return test_authenticated_decryption(&ccm_test_case_256_2); + return test_authenticated_decryption(&gcm_test_case_256_6); } static int -test_AES_CCM_authenticated_decryption_test_case_256_3(void) +test_AES_GCM_auth_decryption_test_case_256_7(void) { - return test_authenticated_decryption(&ccm_test_case_256_3); + return test_authenticated_decryption(&gcm_test_case_256_7); } static int -test_stats(void) +test_AES_GCM_auth_decryption_test_case_aad_1(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; - - /* 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_SHA1_HMAC; - 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_AES_CBC; - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) - 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(); - test_AES_CBC_HMAC_SHA1_encrypt_digest(); - ut_teardown(); - TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], - &stats), - "rte_cryptodev_stats_get failed"); - TEST_ASSERT((stats.enqueued_count == 1), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.dequeued_count == 1), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.enqueue_err_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.dequeue_err_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); + return test_authenticated_decryption(&gcm_test_case_aad_1); +} - /* invalid device but should ignore and not reset device stats*/ - rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300); - TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], - &stats), - "rte_cryptodev_stats_get failed"); - TEST_ASSERT((stats.enqueued_count == 1), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); +static int +test_AES_GCM_auth_decryption_test_case_aad_2(void) +{ + return test_authenticated_decryption(&gcm_test_case_aad_2); +} - /* check that a valid reset clears stats */ - rte_cryptodev_stats_reset(ts_params->valid_devs[0]); - TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], - &stats), - "rte_cryptodev_stats_get failed"); - TEST_ASSERT((stats.enqueued_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.dequeued_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); +static int +test_AES_GCM_auth_decryption_fail_iv_corrupt(void) +{ + struct aead_test_data tdata; + int res; + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.iv.data[0] += 1; + res = test_authenticated_decryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); return TEST_SUCCESS; } -static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - enum rte_crypto_auth_operation op, - const struct HMAC_MD5_vector *test_case) +static int +test_AES_GCM_auth_decryption_fail_in_data_corrupt(void) { - uint8_t key[64]; - - memcpy(key, test_case->key.data, test_case->key.len); - - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = NULL; - ut_params->auth_xform.auth.op = op; - - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC; - - ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN; - ut_params->auth_xform.auth.key.length = test_case->key.len; - ut_params->auth_xform.auth.key.data = key; - - 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->auth_xform, - ts_params->session_priv_mpool); - - if (ut_params->sess == NULL) - return TEST_FAILED; - - 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)); + struct aead_test_data tdata; + int res; - return 0; + 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_decryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; } -static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params, - const struct HMAC_MD5_vector *test_case, - uint8_t **plaintext) +static int +test_AES_GCM_auth_decryption_fail_out_data_corrupt(void) { - uint16_t plaintext_pad_len; - - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + struct aead_test_data tdata; + int res; - plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, - 16); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.ciphertext.data[0] += 1; + res = test_authenticated_decryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; +} - *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - memcpy(*plaintext, test_case->plaintext.data, - test_case->plaintext.len); +static int +test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void) +{ + struct aead_test_data tdata; + int res; - sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( - ut_params->ibuf, MD5_DIGEST_LEN); - TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, - "no room to append digest"); - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( - ut_params->ibuf, plaintext_pad_len); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.aad.len += 1; + res = test_authenticated_decryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; +} - if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) { - rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data, - test_case->auth_tag.len); - } +static int +test_AES_GCM_auth_decryption_fail_aad_corrupt(void) +{ + struct aead_test_data tdata; + uint8_t aad[gcm_test_case_7.aad.len]; + int res; - sym_op->auth.data.offset = 0; - sym_op->auth.data.length = test_case->plaintext.len; + 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_decryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; +} - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - ut_params->op->sym->m_src = ut_params->ibuf; +static int +test_AES_GCM_auth_decryption_fail_tag_corrupt(void) +{ + struct aead_test_data tdata; + int res; - return 0; + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.auth_tag.data[0] += 1; + res = test_authenticated_decryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed"); + return TEST_SUCCESS; } static int -test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case) +test_authenticated_encryption_oop(const struct aead_test_data *tdata) { - uint16_t plaintext_pad_len; - uint8_t *plaintext, *auth_tag; - struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + int retval; + uint8_t *ciphertext, *auth_tag; + uint16_t plaintext_pad_len; + /* 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_MD5_HMAC; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; + cap_idx.algo.aead = tdata->algo; if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], &cap_idx) == NULL) return -ENOTSUP; - if (MD5_HMAC_create_session(ts_params, ut_params, - RTE_CRYPTO_AUTH_OP_GENERATE, test_case)) - return TEST_FAILED; + /* not supported with CPU crypto */ + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; - /* 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 AEAD session */ + retval = create_aead_session(ts_params->valid_devs[0], + tdata->algo, + RTE_CRYPTO_AEAD_OP_ENCRYPT, + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len, + tdata->iv.len); + if (retval < 0) + return retval; - plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, - 16); + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) - return TEST_FAILED; + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->obuf)); - 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"); + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); + if (retval < 0) + return retval; + + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + ut_params->op->sym->m_src = ut_params->ibuf; + ut_params->op->sym->m_dst = ut_params->obuf; + + /* Process crypto operation */ + 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; - } + plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); + + ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, + ut_params->op->sym->cipher.data.offset); + auth_tag = ciphertext + plaintext_pad_len; + + debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); + debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ciphertext, + tdata->ciphertext.data, + tdata->ciphertext.len, + "Ciphertext data not as expected"); TEST_ASSERT_BUFFERS_ARE_EQUAL( auth_tag, - test_case->auth_tag.data, - test_case->auth_tag.len, - "HMAC_MD5 generated tag not as expected"); + tdata->auth_tag.data, + tdata->auth_tag.len, + "Generated auth tag not as expected"); + + return 0; - return TEST_SUCCESS; } static int -test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case) +test_AES_GCM_authenticated_encryption_oop_test_case_1(void) { - uint8_t *plaintext; + return test_authenticated_encryption_oop(&gcm_test_case_5); +} +static int +test_authenticated_decryption_oop(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; + /* 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_MD5_HMAC; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; + cap_idx.algo.aead = tdata->algo; if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], &cap_idx) == NULL) return -ENOTSUP; - if (MD5_HMAC_create_session(ts_params, ut_params, - RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) { - return TEST_FAILED; - } + /* not supported with CPU crypto */ + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; - /* 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 AEAD session */ + retval = create_aead_session(ts_params->valid_devs[0], + tdata->algo, + RTE_CRYPTO_AEAD_OP_DECRYPT, + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len, + tdata->iv.len); + if (retval < 0) + return retval; - if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) - return TEST_FAILED; + /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - 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"); + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->obuf)); + + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); + if (retval < 0) + return retval; + + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + ut_params->op->sym->m_src = ut_params->ibuf; + ut_params->op->sym->m_dst = ut_params->obuf; + + /* Process crypto operation */ + 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, - "HMAC_MD5 crypto op processing failed"); + "crypto op processing failed"); - return TEST_SUCCESS; -} + plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, + ut_params->op->sym->cipher.data.offset); -static int -test_MD5_HMAC_generate_case_1(void) -{ - return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1); -} + debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); -static int -test_MD5_HMAC_verify_case_1(void) -{ - return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1); -} + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len, + "Plaintext data not as expected"); -static int -test_MD5_HMAC_generate_case_2(void) -{ - return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2); + TEST_ASSERT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, + "Authentication failed"); + return 0; } static int -test_MD5_HMAC_verify_case_2(void) +test_AES_GCM_authenticated_decryption_oop_test_case_1(void) { - return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2); + return test_authenticated_decryption_oop(&gcm_test_case_5); } static int -test_multi_session(void) +test_authenticated_encryption_sessionless( + 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 *ciphertext, *auth_tag; + uint16_t plaintext_pad_len; + uint8_t key[tdata->key.len + 1]; struct rte_cryptodev_info dev_info; - struct rte_cryptodev_sym_session **sessions; - uint16_t i; + 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_SYM_SESSIONLESS)) { + printf("Device doesn't support Sessionless ops.\n"); + return -ENOTSUP; + } + + /* not supported with CPU crypto */ + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; /* 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_SHA512_HMAC; - 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_AES_CBC; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; + cap_idx.algo.aead = tdata->algo; if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], &cap_idx) == NULL) return -ENOTSUP; - test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params, - aes_cbc_key, hmac_sha512_key); + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); + if (retval < 0) + return retval; - sessions = rte_malloc(NULL, - (sizeof(struct rte_cryptodev_sym_session *) * - MAX_NB_SESSIONS) + 1, 0); + /* Create GCM xform */ + memcpy(key, tdata->key.data, tdata->key.len); + retval = create_aead_xform(ut_params->op, + tdata->algo, + RTE_CRYPTO_AEAD_OP_ENCRYPT, + key, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len, + tdata->iv.len); + if (retval < 0) + return retval; - /* Create multiple crypto sessions*/ - for (i = 0; i < MAX_NB_SESSIONS; i++) { + ut_params->op->sym->m_src = ut_params->ibuf; - sessions[i] = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + TEST_ASSERT_EQUAL(ut_params->op->sess_type, + RTE_CRYPTO_OP_SESSIONLESS, + "crypto op session type not sessionless"); - rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - sessions[i], &ut_params->auth_xform, - ts_params->session_priv_mpool); - TEST_ASSERT_NOT_NULL(sessions[i], - "Session creation failed at session number %u", - i); + /* Process crypto operation */ + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); - /* Attempt to send a request on each session */ - TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform( - sessions[i], - ut_params, - ts_params, - catch_22_quote_2_512_bytes_AES_CBC_ciphertext, - catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, - aes_cbc_iv), - "Failed to perform decrypt on request number %u.", i); - /* free crypto operation structure */ - if (ut_params->op) - rte_crypto_op_free(ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - /* - * free mbuf - both obuf and ibuf are usually the same, - * so check if they point at the same address is necessary, - * to avoid freeing the mbuf twice. - */ - if (ut_params->obuf) { - rte_pktmbuf_free(ut_params->obuf); - if (ut_params->ibuf == ut_params->obuf) - ut_params->ibuf = 0; - ut_params->obuf = 0; - } - if (ut_params->ibuf) { - rte_pktmbuf_free(ut_params->ibuf); - ut_params->ibuf = 0; - } - } + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op status not success"); - /* Next session create should fail */ - rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - sessions[i], &ut_params->auth_xform, - ts_params->session_priv_mpool); - TEST_ASSERT_NULL(sessions[i], - "Session creation succeeded unexpectedly!"); + plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); - for (i = 0; i < MAX_NB_SESSIONS; i++) { - rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], - sessions[i]); - rte_cryptodev_sym_session_free(sessions[i]); - } + ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, + ut_params->op->sym->cipher.data.offset); + auth_tag = ciphertext + plaintext_pad_len; - rte_free(sessions); + debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); + debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); - return TEST_SUCCESS; -} + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ciphertext, + tdata->ciphertext.data, + tdata->ciphertext.len, + "Ciphertext data not as expected"); -struct multi_session_params { - struct crypto_unittest_params ut_params; - uint8_t *cipher_key; - uint8_t *hmac_key; - const uint8_t *cipher; - const uint8_t *digest; - uint8_t *iv; -}; + TEST_ASSERT_BUFFERS_ARE_EQUAL( + auth_tag, + tdata->auth_tag.data, + tdata->auth_tag.len, + "Generated auth tag not as expected"); -#define MB_SESSION_NUMBER 3 + return 0; + +} static int -test_multi_session_random_usage(void) +test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void) +{ + return test_authenticated_encryption_sessionless( + &gcm_test_case_5); +} + +static int +test_authenticated_decryption_sessionless( + 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; + uint8_t key[tdata->key.len + 1]; struct rte_cryptodev_info dev_info; - struct rte_cryptodev_sym_session **sessions; - uint32_t i, j; - struct multi_session_params ut_paramz[] = { - { - .cipher_key = ms_aes_cbc_key0, - .hmac_key = ms_hmac_key0, - .cipher = ms_aes_cbc_cipher0, - .digest = ms_hmac_digest0, - .iv = ms_aes_cbc_iv0 - }, - { - .cipher_key = ms_aes_cbc_key1, - .hmac_key = ms_hmac_key1, - .cipher = ms_aes_cbc_cipher1, - .digest = ms_hmac_digest1, - .iv = ms_aes_cbc_iv1 - }, - { - .cipher_key = ms_aes_cbc_key2, - .hmac_key = ms_hmac_key2, - .cipher = ms_aes_cbc_cipher2, - .digest = ms_hmac_digest2, - .iv = ms_aes_cbc_iv2 - }, + 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_SYM_SESSIONLESS)) { + printf("Device doesn't support Sessionless ops.\n"); + return -ENOTSUP; + } + + /* not supported with CPU crypto */ + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; /* 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_SHA512_HMAC; - 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_AES_CBC; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; + cap_idx.algo.aead = tdata->algo; if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], &cap_idx) == NULL) return -ENOTSUP; - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - - sessions = rte_malloc(NULL, - (sizeof(struct rte_cryptodev_sym_session *) - * MAX_NB_SESSIONS) + 1, 0); + /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - for (i = 0; i < MB_SESSION_NUMBER; i++) { - sessions[i] = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - rte_memcpy(&ut_paramz[i].ut_params, &unittest_params, - sizeof(struct crypto_unittest_params)); + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); + if (retval < 0) + return retval; - test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( - &ut_paramz[i].ut_params, - ut_paramz[i].cipher_key, ut_paramz[i].hmac_key); + /* Create AEAD xform */ + memcpy(key, tdata->key.data, tdata->key.len); + retval = create_aead_xform(ut_params->op, + tdata->algo, + RTE_CRYPTO_AEAD_OP_DECRYPT, + key, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len, + tdata->iv.len); + if (retval < 0) + return retval; - /* Create multiple crypto sessions*/ - rte_cryptodev_sym_session_init( - ts_params->valid_devs[0], - sessions[i], - &ut_paramz[i].ut_params.auth_xform, - ts_params->session_priv_mpool); + ut_params->op->sym->m_src = ut_params->ibuf; - TEST_ASSERT_NOT_NULL(sessions[i], - "Session creation failed at session number %u", - i); + TEST_ASSERT_EQUAL(ut_params->op->sess_type, + RTE_CRYPTO_OP_SESSIONLESS, + "crypto op session type not sessionless"); - } + /* Process crypto operation */ + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); - srand(time(NULL)); - for (i = 0; i < 40000; i++) { + TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - j = rand() % MB_SESSION_NUMBER; + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op status not success"); - TEST_ASSERT_SUCCESS( - test_AES_CBC_HMAC_SHA512_decrypt_perform( - sessions[j], - &ut_paramz[j].ut_params, - ts_params, ut_paramz[j].cipher, - ut_paramz[j].digest, - ut_paramz[j].iv), - "Failed to perform decrypt on request number %u.", i); + plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, + ut_params->op->sym->cipher.data.offset); - if (ut_paramz[j].ut_params.op) - rte_crypto_op_free(ut_paramz[j].ut_params.op); + debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); - /* - * free mbuf - both obuf and ibuf are usually the same, - * so check if they point at the same address is necessary, - * to avoid freeing the mbuf twice. - */ - if (ut_paramz[j].ut_params.obuf) { - rte_pktmbuf_free(ut_paramz[j].ut_params.obuf); - if (ut_paramz[j].ut_params.ibuf - == ut_paramz[j].ut_params.obuf) - ut_paramz[j].ut_params.ibuf = 0; - ut_paramz[j].ut_params.obuf = 0; - } - if (ut_paramz[j].ut_params.ibuf) { - rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf); - ut_paramz[j].ut_params.ibuf = 0; - } - } + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len, + "Plaintext data not as expected"); - for (i = 0; i < MB_SESSION_NUMBER; i++) { - rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], - sessions[i]); - rte_cryptodev_sym_session_free(sessions[i]); - } + TEST_ASSERT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, + "Authentication failed"); + return 0; +} - rte_free(sessions); +static int +test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void) +{ + return test_authenticated_decryption_sessionless( + &gcm_test_case_5); +} - return TEST_SUCCESS; +static int +test_AES_CCM_authenticated_encryption_test_case_128_1(void) +{ + return test_authenticated_encryption(&ccm_test_case_128_1); } static int -test_null_cipher_only_operation(void) +test_AES_CCM_authenticated_encryption_test_case_128_2(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + return test_authenticated_encryption(&ccm_test_case_128_2); +} - /* 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) - return -ENOTSUP; +static int +test_AES_CCM_authenticated_encryption_test_case_128_3(void) +{ + return test_authenticated_encryption(&ccm_test_case_128_3); +} - /* 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); +static int +test_AES_CCM_authenticated_decryption_test_case_128_1(void) +{ + return test_authenticated_decryption(&ccm_test_case_128_1); +} - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = NULL; +static int +test_AES_CCM_authenticated_decryption_test_case_128_2(void) +{ + return test_authenticated_decryption(&ccm_test_case_128_2); +} - ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; - ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; +static int +test_AES_CCM_authenticated_decryption_test_case_128_3(void) +{ + return test_authenticated_decryption(&ccm_test_case_128_3); +} - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); +static int +test_AES_CCM_authenticated_encryption_test_case_192_1(void) +{ + return test_authenticated_encryption(&ccm_test_case_192_1); +} - /* 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"); +static int +test_AES_CCM_authenticated_encryption_test_case_192_2(void) +{ + return test_authenticated_encryption(&ccm_test_case_192_2); +} - /* 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_CCM_authenticated_encryption_test_case_192_3(void) +{ + return test_authenticated_encryption(&ccm_test_case_192_3); +} - /* Set crypto operation data parameters */ - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); +static int +test_AES_CCM_authenticated_decryption_test_case_192_1(void) +{ + return test_authenticated_decryption(&ccm_test_case_192_1); +} - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; +static int +test_AES_CCM_authenticated_decryption_test_case_192_2(void) +{ + return test_authenticated_decryption(&ccm_test_case_192_2); +} - /* set crypto operation source mbuf */ - sym_op->m_src = ut_params->ibuf; +static int +test_AES_CCM_authenticated_decryption_test_case_192_3(void) +{ + return test_authenticated_decryption(&ccm_test_case_192_3); +} - sym_op->cipher.data.offset = 0; - sym_op->cipher.data.length = QUOTE_512_BYTES; +static int +test_AES_CCM_authenticated_encryption_test_case_256_1(void) +{ + return test_authenticated_encryption(&ccm_test_case_256_1); +} - /* 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"); +static int +test_AES_CCM_authenticated_encryption_test_case_256_2(void) +{ + return test_authenticated_encryption(&ccm_test_case_256_2); +} - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto operation processing failed"); +static int +test_AES_CCM_authenticated_encryption_test_case_256_3(void) +{ + return test_authenticated_encryption(&ccm_test_case_256_3); +} - /* 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"); +static int +test_AES_CCM_authenticated_decryption_test_case_256_1(void) +{ + return test_authenticated_decryption(&ccm_test_case_256_1); +} - return TEST_SUCCESS; +static int +test_AES_CCM_authenticated_decryption_test_case_256_2(void) +{ + return test_authenticated_decryption(&ccm_test_case_256_2); } -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_AES_CCM_authenticated_decryption_test_case_256_3(void) +{ + return test_authenticated_decryption(&ccm_test_case_256_3); +} + +static int +test_stats(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - uint8_t *digest; + struct rte_cryptodev_stats stats; + + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; /* 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; + cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC; + 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_AES_CBC; if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], &cap_idx) == NULL) 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); + if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats) + == -ENOTSUP) + return -ENOTSUP; - /* 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)); + 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"); + + /* Test expected values */ + ut_setup(); + test_AES_CBC_HMAC_SHA1_encrypt_digest(); + ut_teardown(); + TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], + &stats), + "rte_cryptodev_stats_get failed"); + TEST_ASSERT((stats.enqueued_count == 1), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.dequeued_count == 1), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.enqueue_err_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.dequeue_err_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + + /* invalid device but should ignore and not reset device stats*/ + rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300); + TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], + &stats), + "rte_cryptodev_stats_get failed"); + TEST_ASSERT((stats.enqueued_count == 1), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + + /* check that a valid reset clears stats */ + rte_cryptodev_stats_reset(ts_params->valid_devs[0]); + TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], + &stats), + "rte_cryptodev_stats_get failed"); + TEST_ASSERT((stats.enqueued_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.dequeued_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + + return TEST_SUCCESS; +} + +static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + enum rte_crypto_auth_operation op, + const struct HMAC_MD5_vector *test_case) +{ + uint8_t key[64]; + + memcpy(key, test_case->key.data, test_case->key.len); - /* Setup HMAC Parameters */ ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; ut_params->auth_xform.next = NULL; + ut_params->auth_xform.auth.op = op; - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; - ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC; + + ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN; + ut_params->auth_xform.auth.key.length = test_case->key.len; + ut_params->auth_xform.auth.key.data = key; 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->auth_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"); + if (ut_params->sess == NULL) + return TEST_FAILED; - /* Set crypto operation data parameters */ - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + 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)); + + return 0; +} + +static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params, + const struct HMAC_MD5_vector *test_case, + uint8_t **plaintext) +{ + uint16_t plaintext_pad_len; struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - sym_op->m_src = ut_params->ibuf; + plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, + 16); - 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); + *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(*plaintext, test_case->plaintext.data, + test_case->plaintext.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"); + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, MD5_DIGEST_LEN); + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append digest"); + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( + ut_params->ibuf, plaintext_pad_len); - 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"); + if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) { + rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data, + test_case->auth_tag.len); + } - return TEST_SUCCESS; -} + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = test_case->plaintext.len; + + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + ut_params->op->sym->m_src = ut_params->ibuf; + return 0; +} static int -test_null_cipher_auth_operation(void) +test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case) { + uint16_t plaintext_pad_len; + uint8_t *plaintext, *auth_tag; + 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) - 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_MD5_HMAC; if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], &cap_idx) == NULL) 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); + if (MD5_HMAC_create_session(ts_params, ut_params, + RTE_CRYPTO_AUTH_OP_GENERATE, test_case)) + return TEST_FAILED; - /* 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)); + /* 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"); - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = &ut_params->auth_xform; + plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, + 16); - ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; - ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) + return TEST_FAILED; - /* 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_NULL; - 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*/ - 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"); - - /* 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); - - 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); - - /* 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; + } - /* 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, + test_case->auth_tag.data, + test_case->auth_tag.len, + "HMAC_MD5 generated tag not as expected"); return TEST_SUCCESS; } static int -test_null_auth_cipher_operation(void) +test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case) { + uint8_t *plaintext; + 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) - 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_MD5_HMAC; 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); - - /* 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)); - - /* 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.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; - - /* Setup HMAC Parameters */ - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = &ut_params->cipher_xform; - - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; - 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*/ - 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"); + if (MD5_HMAC_create_session(ts_params, ut_params, + RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) { + return TEST_FAILED; + } /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, @@ -9616,287 +9505,521 @@ test_null_auth_cipher_operation(void) 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); - - 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); + if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) + return TEST_FAILED; - /* 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"); - - /* 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"); + "HMAC_MD5 crypto op processing failed"); return TEST_SUCCESS; } - static int -test_null_invalid_operation(void) +test_MD5_HMAC_generate_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_MD5_HMAC_generate(&HMAC_MD5_test_case_1); +} - return TEST_SUCCESS; +static int +test_MD5_HMAC_verify_case_1(void) +{ + return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1); } +static int +test_MD5_HMAC_generate_case_2(void) +{ + return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2); +} -#define NULL_BURST_LENGTH (32) +static int +test_MD5_HMAC_verify_case_2(void) +{ + return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2); +} static int -test_null_burst_operation(void) +test_multi_session(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - unsigned i, burst_len = NULL_BURST_LENGTH; + struct rte_cryptodev_info dev_info; + struct rte_cryptodev_sym_session **sessions; - struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL }; - struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL }; + uint16_t i; - /* 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_SHA512_HMAC; + 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_AES_CBC; + 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; + test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params, + aes_cbc_key, hmac_sha512_key); - 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; + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; - ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + sessions = rte_malloc(NULL, + (sizeof(struct rte_cryptodev_sym_session *) * + MAX_NB_SESSIONS) + 1, 0); - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + /* Create multiple crypto sessions*/ + for (i = 0; i < MAX_NB_SESSIONS; i++) { - /* 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"); + sessions[i] = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - 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"); + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + sessions[i], &ut_params->auth_xform, + ts_params->session_priv_mpool); + TEST_ASSERT_NOT_NULL(sessions[i], + "Session creation failed at session number %u", + i); - /* 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); - - TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf"); - - unsigned *data = (unsigned *)rte_pktmbuf_append(m, - sizeof(unsigned)); - *data = i; - - rte_crypto_op_attach_sym_session(burst[i], ut_params->sess); + /* Attempt to send a request on each session */ + TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform( + sessions[i], + ut_params, + ts_params, + catch_22_quote_2_512_bytes_AES_CBC_ciphertext, + catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, + aes_cbc_iv), + "Failed to perform decrypt on request number %u.", i); + /* free crypto operation structure */ + if (ut_params->op) + rte_crypto_op_free(ut_params->op); - burst[i]->sym->m_src = m; + /* + * free mbuf - both obuf and ibuf are usually the same, + * so check if they point at the same address is necessary, + * to avoid freeing the mbuf twice. + */ + if (ut_params->obuf) { + rte_pktmbuf_free(ut_params->obuf); + if (ut_params->ibuf == ut_params->obuf) + ut_params->ibuf = 0; + ut_params->obuf = 0; + } + if (ut_params->ibuf) { + rte_pktmbuf_free(ut_params->ibuf); + ut_params->ibuf = 0; + } } - /* Process crypto operation */ - TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0], - 0, burst, burst_len), - burst_len, - "Error enqueuing burst"); - - 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"); + /* Next session create should fail */ + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + sessions[i], &ut_params->auth_xform, + ts_params->session_priv_mpool); + TEST_ASSERT_NULL(sessions[i], + "Session creation succeeded unexpectedly!"); - rte_pktmbuf_free(burst[i]->sym->m_src); - rte_crypto_op_free(burst[i]); + for (i = 0; i < MAX_NB_SESSIONS; i++) { + rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], + sessions[i]); + rte_cryptodev_sym_session_free(sessions[i]); } + rte_free(sessions); + return TEST_SUCCESS; } -static void -generate_gmac_large_plaintext(uint8_t *data) -{ - uint16_t i; +struct multi_session_params { + struct crypto_unittest_params ut_params; + uint8_t *cipher_key; + uint8_t *hmac_key; + const uint8_t *cipher; + const uint8_t *digest; + uint8_t *iv; +}; - for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32) - memcpy(&data[i], &data[0], 32); -} +#define MB_SESSION_NUMBER 3 static int -create_gmac_operation(enum rte_crypto_auth_operation op, - const struct gmac_test_data *tdata) +test_multi_session_random_usage(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - struct rte_crypto_sym_op *sym_op; - - uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); - - /* 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 = ut_params->op->sym; + struct rte_cryptodev_info dev_info; + struct rte_cryptodev_sym_session **sessions; + uint32_t i, j; + struct multi_session_params ut_paramz[] = { - 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"); + { + .cipher_key = ms_aes_cbc_key0, + .hmac_key = ms_hmac_key0, + .cipher = ms_aes_cbc_cipher0, + .digest = ms_hmac_digest0, + .iv = ms_aes_cbc_iv0 + }, + { + .cipher_key = ms_aes_cbc_key1, + .hmac_key = ms_hmac_key1, + .cipher = ms_aes_cbc_cipher1, + .digest = ms_hmac_digest1, + .iv = ms_aes_cbc_iv1 + }, + { + .cipher_key = ms_aes_cbc_key2, + .hmac_key = ms_hmac_key2, + .cipher = ms_aes_cbc_cipher2, + .digest = ms_hmac_digest2, + .iv = ms_aes_cbc_iv2 + }, - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( - ut_params->ibuf, plaintext_pad_len); + }; - 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); - } + /* 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_SHA512_HMAC; + 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_AES_CBC; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; - uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, - uint8_t *, IV_OFFSET); + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); + sessions = rte_malloc(NULL, + (sizeof(struct rte_cryptodev_sym_session *) + * MAX_NB_SESSIONS) + 1, 0); - debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len); + for (i = 0; i < MB_SESSION_NUMBER; i++) { + sessions[i] = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - sym_op->cipher.data.length = 0; - sym_op->cipher.data.offset = 0; + rte_memcpy(&ut_paramz[i].ut_params, &unittest_params, + sizeof(struct crypto_unittest_params)); - sym_op->auth.data.offset = 0; - sym_op->auth.data.length = tdata->plaintext.len; + test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( + &ut_paramz[i].ut_params, + ut_paramz[i].cipher_key, ut_paramz[i].hmac_key); - return 0; -} + /* Create multiple crypto sessions*/ + rte_cryptodev_sym_session_init( + ts_params->valid_devs[0], + sessions[i], + &ut_paramz[i].ut_params.auth_xform, + ts_params->session_priv_mpool); -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]; + TEST_ASSERT_NOT_NULL(sessions[i], + "Session creation failed at session number %u", + i); - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + } - memcpy(auth_key, tdata->key.data, tdata->key.len); + srand(time(NULL)); + for (i = 0; i < 40000; i++) { - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = NULL; + j = rand() % MB_SESSION_NUMBER; - 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; + TEST_ASSERT_SUCCESS( + test_AES_CBC_HMAC_SHA512_decrypt_perform( + sessions[j], + &ut_paramz[j].ut_params, + ts_params, ut_paramz[j].cipher, + ut_paramz[j].digest, + ut_paramz[j].iv), + "Failed to perform decrypt on request number %u.", i); + if (ut_paramz[j].ut_params.op) + rte_crypto_op_free(ut_paramz[j].ut_params.op); - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + /* + * free mbuf - both obuf and ibuf are usually the same, + * so check if they point at the same address is necessary, + * to avoid freeing the mbuf twice. + */ + if (ut_paramz[j].ut_params.obuf) { + rte_pktmbuf_free(ut_paramz[j].ut_params.obuf); + if (ut_paramz[j].ut_params.ibuf + == ut_paramz[j].ut_params.obuf) + ut_paramz[j].ut_params.ibuf = 0; + ut_paramz[j].ut_params.obuf = 0; + } + if (ut_paramz[j].ut_params.ibuf) { + rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf); + ut_paramz[j].ut_params.ibuf = 0; + } + } - rte_cryptodev_sym_session_init(dev_id, ut_params->sess, - &ut_params->auth_xform, - ts_params->session_priv_mpool); + for (i = 0; i < MB_SESSION_NUMBER; i++) { + rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], + sessions[i]); + rte_cryptodev_sym_session_free(sessions[i]); + } - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + rte_free(sessions); - return 0; + 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_AES_GMAC_authentication(const struct gmac_test_data *tdata) +test_null_invalid_operation(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + int ret; - int retval; - - uint8_t *auth_tag, *plaintext; + /* 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_SUCCESS; +} + + +#define NULL_BURST_LENGTH (32) + +static int +test_null_burst_operation(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + 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; + + /* 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; + + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; + 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*/ + 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"); + + 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"); + + /* 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); + + TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf"); + + unsigned *data = (unsigned *)rte_pktmbuf_append(m, + sizeof(unsigned)); + *data = i; + + rte_crypto_op_attach_sym_session(burst[i], ut_params->sess); + + burst[i]->sym->m_src = m; + } + + /* Process crypto operation */ + TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0], + 0, burst, burst_len), + burst_len, + "Error enqueuing burst"); + + 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 +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; + struct rte_crypto_sym_op *sym_op; + + uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); + + /* 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 = ut_params->op->sym; + + 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"); + + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( + ut_params->ibuf, plaintext_pad_len); + + 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); + } + + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + + rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); + + debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len); + + sym_op->cipher.data.length = 0; + sym_op->cipher.data.offset = 0; + + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = tdata->plaintext.len; + + return 0; +} + +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]; + + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + memcpy(auth_key, tdata->key.data, tdata->key.len); + + 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.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->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_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; + + int retval; + + uint8_t *auth_tag, *plaintext; uint16_t plaintext_pad_len; TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, @@ -11556,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 */ @@ -11791,762 +11926,208 @@ static struct unit_test_suite cryptodev_testsuite = { test_device_configure_invalid_queue_pair_ids), 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), - - /** 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), @@ -12560,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), @@ -12575,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, @@ -12591,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, @@ -12616,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, @@ -12627,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, @@ -12674,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, @@ -12685,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, @@ -12924,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 */ } }; @@ -13245,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 @@ -13260,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