X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_cryptodev.c;h=7b1ef5c8664d112cd306e49854f2746941a7a5f4;hb=3df951337441cc6b7bb99996e0acf185d4aa52c5;hp=089adf803eba98f4118dcac86418999a42577129;hpb=e2e60edbdbfcf991db14058bb1aa031da0705b7c;p=dpdk.git diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index 089adf803e..7b1ef5c866 100644 --- a/app/test/test_cryptodev.c +++ b/app/test/test_cryptodev.c @@ -1,5 +1,5 @@ /* SPDX-License-Identifier: BSD-3-Clause - * Copyright(c) 2015-2019 Intel Corporation + * Copyright(c) 2015-2020 Intel Corporation */ #include @@ -38,6 +38,7 @@ #include "test_cryptodev_zuc_test_vectors.h" #include "test_cryptodev_aead_test_vectors.h" #include "test_cryptodev_hmac_test_vectors.h" +#include "test_cryptodev_mixed_test_vectors.h" #ifdef RTE_LIBRTE_SECURITY #include "test_cryptodev_security_pdcp_test_vectors.h" #include "test_cryptodev_security_pdcp_test_func.h" @@ -51,6 +52,9 @@ static int gbl_driver_id; +static enum rte_security_session_action_type gbl_action_type = + RTE_SECURITY_ACTION_TYPE_NONE; + struct crypto_testsuite_params { struct rte_mempool *mbuf_pool; struct rte_mempool *large_mbuf_pool; @@ -71,9 +75,13 @@ struct crypto_unittest_params { union { struct rte_cryptodev_sym_session *sess; +#ifdef RTE_LIBRTE_SECURITY struct rte_security_session *sec_session; +#endif }; +#ifdef RTE_LIBRTE_SECURITY enum rte_security_session_action_type type; +#endif struct rte_crypto_op *op; struct rte_mbuf *obuf, *ibuf; @@ -134,11 +142,99 @@ ceil_byte_length(uint32_t num_bits) return (num_bits >> 3); } +static void +process_cpu_gmac_op(uint8_t dev_id, struct rte_crypto_op *op) +{ + int32_t n, st; + void *iv; + struct rte_crypto_sym_op *sop; + union rte_crypto_sym_ofs ofs; + struct rte_crypto_sgl sgl; + struct rte_crypto_sym_vec symvec; + struct rte_crypto_vec vec[UINT8_MAX]; + + sop = op->sym; + + n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset, + sop->auth.data.length, vec, RTE_DIM(vec)); + + if (n < 0 || n != sop->m_src->nb_segs) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + return; + } + + sgl.vec = vec; + sgl.num = n; + symvec.sgl = &sgl; + iv = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); + symvec.iv = &iv; + symvec.aad = NULL; + symvec.digest = (void **)&sop->auth.digest.data; + symvec.status = &st; + symvec.num = 1; + + ofs.raw = 0; + + n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs, + &symvec); + + if (n != 1) + op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED; + else + op->status = RTE_CRYPTO_OP_STATUS_SUCCESS; +} + + +static void +process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op) +{ + int32_t n, st; + void *iv; + struct rte_crypto_sym_op *sop; + union rte_crypto_sym_ofs ofs; + struct rte_crypto_sgl sgl; + struct rte_crypto_sym_vec symvec; + struct rte_crypto_vec vec[UINT8_MAX]; + + sop = op->sym; + + n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset, + sop->aead.data.length, vec, RTE_DIM(vec)); + + if (n < 0 || n != sop->m_src->nb_segs) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + return; + } + + sgl.vec = vec; + sgl.num = n; + symvec.sgl = &sgl; + iv = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); + symvec.iv = &iv; + symvec.aad = (void **)&sop->aead.aad.data; + symvec.digest = (void **)&sop->aead.digest.data; + symvec.status = &st; + symvec.num = 1; + + ofs.raw = 0; + + n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs, + &symvec); + + if (n != 1) + op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED; + else + op->status = RTE_CRYPTO_OP_STATUS_SUCCESS; +} + static struct rte_crypto_op * process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op) { + + RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO); + if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { - printf("Error sending packet for encryption"); + RTE_LOG(ERR, USER1, "Error sending packet for encryption\n"); return NULL; } @@ -147,6 +243,11 @@ process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op) while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0) rte_pause(); + if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { + RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status); + return NULL; + } + return op; } @@ -573,6 +674,7 @@ ut_teardown(void) struct rte_cryptodev_stats stats; /* free crypto session structure */ +#ifdef RTE_LIBRTE_SECURITY if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) { if (ut_params->sec_session) { rte_security_session_destroy(rte_cryptodev_get_sec_ctx @@ -580,7 +682,9 @@ ut_teardown(void) ut_params->sec_session); ut_params->sec_session = NULL; } - } else { + } else +#endif + { if (ut_params->sess) { rte_cryptodev_sym_session_clear( ts_params->valid_devs[0], @@ -661,6 +765,13 @@ test_device_configure_invalid_queue_pair_ids(void) struct crypto_testsuite_params *ts_params = &testsuite_params; uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs; + /* This test is for QAT and NITROX PMDs only */ + if (gbl_driver_id != rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)) && + gbl_driver_id != rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_NITROX_PMD))) + return -ENOTSUP; + /* Stop the device in case it's started so it can be configured */ rte_cryptodev_stop(ts_params->valid_devs[0]); @@ -732,6 +843,11 @@ test_queue_pair_descriptor_setup(void) uint16_t qp_id; + /* This test is for QAT PMD only */ + if (gbl_driver_id != rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD))) + return -ENOTSUP; + /* Stop the device in case it's started so it can be configured */ rte_cryptodev_stop(ts_params->valid_devs[0]); @@ -1340,6 +1456,19 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void) struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + /* 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; + /* 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); @@ -1583,7 +1712,7 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, } static int -test_AES_cipheronly_mb_all(void) +test_blockcipher(enum blockcipher_test_type test_type) { struct crypto_testsuite_params *ts_params = &testsuite_params; int status; @@ -1592,9 +1721,11 @@ test_AES_cipheronly_mb_all(void) ts_params->op_mpool, ts_params->session_mpool, ts_params->session_priv_mpool, ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); + gbl_driver_id, + test_type); + + if (status == -ENOTSUP) + return status; TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1602,889 +1733,153 @@ test_AES_cipheronly_mb_all(void) } static int -test_AES_docsis_mb_all(void) +test_AES_cipheronly_all(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)), - BLKCIPHER_AES_DOCSIS_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_blockcipher(BLKCIPHER_AES_CIPHERONLY_TYPE); } static int -test_AES_docsis_qat_all(void) +test_AES_docsis_all(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)), - BLKCIPHER_AES_DOCSIS_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE); } static int -test_DES_docsis_qat_all(void) +test_DES_docsis_all(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)), - BLKCIPHER_DES_DOCSIS_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE); } static int -test_authonly_mb_all(void) +test_DES_cipheronly_all(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)), - BLKCIPHER_AUTHONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_blockcipher(BLKCIPHER_DES_CIPHERONLY_TYPE); } static int -test_authonly_qat_all(void) +test_authonly_all(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)), - BLKCIPHER_AUTHONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_blockcipher(BLKCIPHER_AUTHONLY_TYPE); } static int -test_AES_chain_null_all(void) +test_AES_chain_all(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_NULL_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_blockcipher(BLKCIPHER_AES_CHAIN_TYPE); } static int -test_AES_cipheronly_null_all(void) +test_3DES_chain_all(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_NULL_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_blockcipher(BLKCIPHER_3DES_CHAIN_TYPE); } static int -test_authonly_null_all(void) +test_3DES_cipheronly_all(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_NULL_PMD)), - BLKCIPHER_AUTHONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_blockcipher(BLKCIPHER_3DES_CIPHERONLY_TYPE); } +/* ***** SNOW 3G Tests ***** */ static int -test_AES_chain_mb_all(void) +create_wireless_algo_hash_session(uint8_t dev_id, + const uint8_t *key, const uint8_t key_len, + const uint8_t iv_len, const uint8_t auth_len, + enum rte_crypto_auth_operation op, + enum rte_crypto_auth_algorithm algo) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + uint8_t hash_key[key_len]; int status; - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; -#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER + memcpy(hash_key, key, key_len); -static int -test_AES_cipheronly_scheduler_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + debug_hexdump(stdout, "key:", key, key_len); - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); + /* Setup Authentication Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + ut_params->auth_xform.auth.op = op; + ut_params->auth_xform.auth.algo = algo; + ut_params->auth_xform.auth.key.length = key_len; + ut_params->auth_xform.auth.key.data = hash_key; + ut_params->auth_xform.auth.digest_length = auth_len; + ut_params->auth_xform.auth.iv.offset = IV_OFFSET; + ut_params->auth_xform.auth.iv.length = iv_len; + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - return TEST_SUCCESS; + status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->auth_xform, + ts_params->session_priv_mpool); + TEST_ASSERT_EQUAL(status, 0, "session init failed"); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + return 0; } static int -test_AES_chain_scheduler_all(void) +create_wireless_algo_cipher_session(uint8_t dev_id, + enum rte_crypto_cipher_operation op, + enum rte_crypto_cipher_algorithm algo, + const uint8_t *key, const uint8_t key_len, + uint8_t iv_len) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + uint8_t cipher_key[key_len]; int status; + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); + memcpy(cipher_key, key, key_len); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; - return TEST_SUCCESS; + ut_params->cipher_xform.cipher.algo = algo; + ut_params->cipher_xform.cipher.op = op; + ut_params->cipher_xform.cipher.key.data = cipher_key; + ut_params->cipher_xform.cipher.key.length = key_len; + ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; + ut_params->cipher_xform.cipher.iv.length = iv_len; + + debug_hexdump(stdout, "key:", key, key_len); + + /* Create Crypto session */ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); + + status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->cipher_xform, + ts_params->session_priv_mpool); + TEST_ASSERT_EQUAL(status, 0, "session init failed"); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + return 0; } static int -test_authonly_scheduler_all(void) +create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len, + unsigned int cipher_len, + unsigned int cipher_offset) { struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + struct crypto_unittest_params *ut_params = &unittest_params; - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)), - BLKCIPHER_AUTHONLY_TYPE); + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate pktmbuf offload"); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - return TEST_SUCCESS; -} + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; -#endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */ - -static int -test_AES_chain_openssl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_cipheronly_openssl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_chain_ccp_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CCP_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_cipheronly_ccp_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CCP_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_chain_qat_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_cipheronly_qat_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_cipheronly_virtio_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_chain_caam_jr_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_cipheronly_caam_jr_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_authonly_caam_jr_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)), - BLKCIPHER_AUTHONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - - -static int -test_AES_chain_dpaa_sec_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_cipheronly_dpaa_sec_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_authonly_dpaa_sec_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)), - BLKCIPHER_AUTHONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_chain_dpaa2_sec_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_cipheronly_dpaa2_sec_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_authonly_dpaa2_sec_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)), - BLKCIPHER_AUTHONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_authonly_openssl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)), - BLKCIPHER_AUTHONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_authonly_ccp_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CCP_PMD)), - BLKCIPHER_AUTHONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_chain_armv8_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_chain_mrvl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_cipheronly_mrvl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_authonly_mrvl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)), - BLKCIPHER_AUTHONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_3DES_chain_mrvl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_3DES_cipheronly_mrvl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_chain_octeontx_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->session_mpool, - ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_cipheronly_octeontx_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->session_mpool, - ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_3DES_chain_octeontx_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->session_mpool, - ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_3DES_cipheronly_octeontx_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->session_mpool, - ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_authonly_octeontx_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->session_mpool, - ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)), - BLKCIPHER_AUTHONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -/* ***** SNOW 3G Tests ***** */ -static int -create_wireless_algo_hash_session(uint8_t dev_id, - const uint8_t *key, const uint8_t key_len, - const uint8_t iv_len, const uint8_t auth_len, - enum rte_crypto_auth_operation op, - enum rte_crypto_auth_algorithm algo) -{ - uint8_t hash_key[key_len]; - int status; - - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - - memcpy(hash_key, key, key_len); - - debug_hexdump(stdout, "key:", key, key_len); - - /* Setup Authentication Parameters */ - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = NULL; - - ut_params->auth_xform.auth.op = op; - ut_params->auth_xform.auth.algo = algo; - ut_params->auth_xform.auth.key.length = key_len; - ut_params->auth_xform.auth.key.data = hash_key; - ut_params->auth_xform.auth.digest_length = auth_len; - ut_params->auth_xform.auth.iv.offset = IV_OFFSET; - ut_params->auth_xform.auth.iv.length = iv_len; - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); - - status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, - &ut_params->auth_xform, - ts_params->session_priv_mpool); - TEST_ASSERT_EQUAL(status, 0, "session init failed"); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); - return 0; -} - -static int -create_wireless_algo_cipher_session(uint8_t dev_id, - enum rte_crypto_cipher_operation op, - enum rte_crypto_cipher_algorithm algo, - const uint8_t *key, const uint8_t key_len, - uint8_t iv_len) -{ - uint8_t cipher_key[key_len]; - int status; - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - - memcpy(cipher_key, key, key_len); - - /* 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 = algo; - ut_params->cipher_xform.cipher.op = op; - ut_params->cipher_xform.cipher.key.data = cipher_key; - ut_params->cipher_xform.cipher.key.length = key_len; - ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; - ut_params->cipher_xform.cipher.iv.length = iv_len; - - debug_hexdump(stdout, "key:", key, key_len); - - /* Create Crypto session */ - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); - - status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, - &ut_params->cipher_xform, - ts_params->session_priv_mpool); - TEST_ASSERT_EQUAL(status, 0, "session init failed"); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); - return 0; -} - -static int -create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len, - unsigned int cipher_len, - unsigned int cipher_offset) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate pktmbuf offload"); - - /* Set crypto operation data parameters */ - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - - /* set crypto operation source mbuf */ - sym_op->m_src = ut_params->ibuf; + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; /* iv */ rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), @@ -2574,13 +1969,15 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id, /* Create Crypto session*/ ut_params->sess = rte_cryptodev_sym_session_create( ts_params->session_mpool); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, &ut_params->cipher_xform, ts_params->session_priv_mpool); + if (status == -ENOTSUP) + return status; TEST_ASSERT_EQUAL(status, 0, "session init failed"); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; } @@ -2700,12 +2097,24 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id, /* Create Crypto session*/ ut_params->sess = rte_cryptodev_sym_session_create( ts_params->session_mpool); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + + if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) { + ut_params->auth_xform.next = NULL; + ut_params->cipher_xform.next = &ut_params->auth_xform; + status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->cipher_xform, + ts_params->session_priv_mpool); + + } else + status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->auth_xform, + ts_params->session_priv_mpool); + + if (status == -ENOTSUP) + return status; - status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, - &ut_params->auth_xform, - ts_params->session_priv_mpool); TEST_ASSERT_EQUAL(status, 0, "session init failed"); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; } @@ -2849,6 +2258,11 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + enum rte_crypto_cipher_algorithm cipher_algo = + ut_params->cipher_xform.cipher.algo; + enum rte_crypto_auth_algorithm auth_algo = + ut_params->auth_xform.auth.algo; + /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); @@ -2869,8 +2283,22 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, "no room to append auth tag"); ut_params->digest = sym_op->auth.digest.data; - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( - ut_params->ibuf, data_pad_len); + + if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) { + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( + ut_params->ibuf, data_pad_len); + } else { + struct rte_mbuf *m = ut_params->ibuf; + unsigned int offset = data_pad_len; + + while (offset > m->data_len && m->next != NULL) { + offset -= m->data_len; + m = m->next; + } + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( + m, offset); + } + if (op == RTE_CRYPTO_AUTH_OP_GENERATE) memset(sym_op->auth.digest.data, 0, auth_tag_len); else @@ -2887,26 +2315,47 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, iv_ptr += cipher_iv_len; rte_memcpy(iv_ptr, auth_iv, auth_iv_len); - sym_op->cipher.data.length = cipher_len; - sym_op->cipher.data.offset = cipher_offset; - sym_op->auth.data.length = auth_len; - sym_op->auth.data.offset = auth_offset; + if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 || + cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 || + cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) { + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = cipher_offset; + } else { + sym_op->cipher.data.length = cipher_len >> 3; + sym_op->cipher.data.offset = cipher_offset >> 3; + } + + if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 || + auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 || + auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) { + sym_op->auth.data.length = auth_len; + sym_op->auth.data.offset = auth_offset; + } else { + sym_op->auth.data.length = auth_len >> 3; + sym_op->auth.data.offset = auth_offset >> 3; + } return 0; } static int -create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len, +create_wireless_algo_auth_cipher_operation( + const uint8_t *auth_tag, unsigned int auth_tag_len, const uint8_t *cipher_iv, uint8_t cipher_iv_len, const uint8_t *auth_iv, uint8_t auth_iv_len, unsigned int data_pad_len, unsigned int cipher_len, unsigned int cipher_offset, unsigned int auth_len, unsigned int auth_offset, - uint8_t op_mode, uint8_t do_sgl) + uint8_t op_mode, uint8_t do_sgl, uint8_t verify) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + enum rte_crypto_cipher_algorithm cipher_algo = + ut_params->cipher_xform.cipher.algo; + enum rte_crypto_auth_algorithm auth_algo = + ut_params->auth_xform.auth.algo; + /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); @@ -2954,6 +2403,10 @@ create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len, } } + /* Copy digest for the verification */ + if (verify) + memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); + /* Copy cipher and auth IVs at the end of the crypto operation */ uint8_t *iv_ptr = rte_crypto_op_ctod_offset( ut_params->op, uint8_t *, IV_OFFSET); @@ -2962,11 +2415,25 @@ create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len, iv_ptr += cipher_iv_len; rte_memcpy(iv_ptr, auth_iv, auth_iv_len); - sym_op->cipher.data.length = cipher_len; - sym_op->cipher.data.offset = cipher_offset; + if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 || + cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 || + cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) { + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = cipher_offset; + } else { + sym_op->cipher.data.length = cipher_len >> 3; + sym_op->cipher.data.offset = cipher_offset >> 3; + } - sym_op->auth.data.length = auth_len; - sym_op->auth.data.offset = auth_offset; + if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 || + auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 || + auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) { + sym_op->auth.data.length = auth_len; + sym_op->auth.data.offset = auth_offset; + } else { + sym_op->auth.data.length = auth_len >> 3; + sym_op->auth.data.offset = auth_offset >> 3; + } return 0; } @@ -2982,6 +2449,20 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) unsigned plaintext_len; uint8_t *plaintext; + /* QAT PMD supports byte-aligned data only */ + if ((tdata->validAuthLenInBits.len % 8 != 0) && + (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)))) + 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_SNOW3G_UIA2; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create SNOW 3G session */ retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], tdata->key.data, tdata->key.len, @@ -3042,6 +2523,20 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) unsigned plaintext_len; uint8_t *plaintext; + /* QAT PMD supports byte-aligned data only */ + if ((tdata->validAuthLenInBits.len % 8 != 0) && + (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)))) + 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_SNOW3G_UIA2; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create SNOW 3G session */ retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], tdata->key.data, tdata->key.len, @@ -3102,6 +2597,14 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) unsigned plaintext_len; 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_KASUMI_F9; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create KASUMI session */ retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], tdata->key.data, tdata->key.len, @@ -3162,6 +2665,14 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) unsigned plaintext_len; 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_KASUMI_F9; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create KASUMI session */ retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], tdata->key.data, tdata->key.len, @@ -3361,6 +2872,14 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata) unsigned plaintext_pad_len; unsigned plaintext_len; + /* 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_KASUMI_F8; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create KASUMI session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], RTE_CRYPTO_CIPHER_OP_ENCRYPT, @@ -3433,6 +2952,14 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) struct rte_cryptodev_info dev_info; + /* 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_KASUMI_F8; + 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); uint64_t feat_flags = dev_info.feature_flags; @@ -3511,6 +3038,14 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata) unsigned plaintext_pad_len; unsigned plaintext_len; + /* 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_KASUMI_F8; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create KASUMI session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], RTE_CRYPTO_CIPHER_OP_ENCRYPT, @@ -3584,6 +3119,14 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata) struct rte_cryptodev_info dev_info; + /* 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_KASUMI_F8; + 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); uint64_t feat_flags = dev_info.feature_flags; @@ -3661,6 +3204,14 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata) unsigned ciphertext_pad_len; unsigned ciphertext_len; + /* 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_KASUMI_F8; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create KASUMI session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], RTE_CRYPTO_CIPHER_OP_DECRYPT, @@ -3730,6 +3281,14 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata) unsigned ciphertext_pad_len; unsigned ciphertext_len; + /* 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_KASUMI_F8; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create KASUMI session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], RTE_CRYPTO_CIPHER_OP_DECRYPT, @@ -3797,6 +3356,14 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata) unsigned plaintext_pad_len; unsigned plaintext_len; + /* 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_SNOW3G_UEA2; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create SNOW 3G session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], RTE_CRYPTO_CIPHER_OP_ENCRYPT, @@ -3863,6 +3430,14 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) unsigned plaintext_pad_len; unsigned plaintext_len; + /* 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_SNOW3G_UEA2; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create SNOW 3G session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], RTE_CRYPTO_CIPHER_OP_ENCRYPT, @@ -3938,6 +3513,14 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) struct rte_cryptodev_info dev_info; + /* 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_SNOW3G_UEA2; + 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); uint64_t feat_flags = dev_info.feature_flags; @@ -4039,6 +3622,19 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) uint8_t extra_offset = 4; uint8_t *expected_ciphertext_shifted; + /* QAT PMD supports byte-aligned data only */ + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD))) + return -ENOTSUP; + + /* 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_SNOW3G_UEA2; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create SNOW 3G session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], RTE_CRYPTO_CIPHER_OP_ENCRYPT, @@ -4130,6 +3726,14 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) unsigned ciphertext_pad_len; unsigned ciphertext_len; + /* 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_SNOW3G_UEA2; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create SNOW 3G session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], RTE_CRYPTO_CIPHER_OP_DECRYPT, @@ -4193,6 +3797,14 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) unsigned ciphertext_pad_len; unsigned ciphertext_len; + /* 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_SNOW3G_UEA2; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create SNOW 3G session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], RTE_CRYPTO_CIPHER_OP_DECRYPT, @@ -4353,6 +3965,19 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) unsigned plaintext_pad_len; unsigned plaintext_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_SNOW3G_UIA2; + 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_SNOW3G_UEA2; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create SNOW 3G session */ retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0], RTE_CRYPTO_CIPHER_OP_ENCRYPT, @@ -4440,6 +4065,19 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, struct rte_cryptodev_info dev_info; + /* 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_SNOW3G_UIA2; + 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_SNOW3G_UEA2; + 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); uint64_t feat_flags = dev_info.feature_flags; @@ -4502,7 +4140,7 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, /* Create SNOW 3G operation */ retval = create_wireless_algo_auth_cipher_operation( - tdata->digest.len, + tdata->digest.data, tdata->digest.len, tdata->cipher_iv.data, tdata->cipher_iv.len, tdata->auth_iv.data, tdata->auth_iv.len, (tdata->digest.offset_bytes == 0 ? @@ -4512,7 +4150,7 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, tdata->cipher.offset_bits, tdata->validAuthLenInBits.len, tdata->auth.offset_bits, - op_mode, 0); + op_mode, 0, verify); if (retval < 0) return retval; @@ -4604,6 +4242,19 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, struct rte_cryptodev_info dev_info; + /* 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_SNOW3G_UIA2; + 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_SNOW3G_UEA2; + 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); uint64_t feat_flags = dev_info.feature_flags; @@ -4678,7 +4329,7 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, /* Create SNOW 3G operation */ retval = create_wireless_algo_auth_cipher_operation( - tdata->digest.len, + tdata->digest.data, tdata->digest.len, tdata->cipher_iv.data, tdata->cipher_iv.len, tdata->auth_iv.data, tdata->auth_iv.len, (tdata->digest.offset_bytes == 0 ? @@ -4688,7 +4339,7 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, tdata->cipher.offset_bits, tdata->validAuthLenInBits.len, tdata->auth.offset_bits, - op_mode, 1); + op_mode, 1, verify); if (retval < 0) return retval; @@ -4784,6 +4435,19 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata, struct rte_cryptodev_info dev_info; + /* 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_KASUMI_F9; + 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_KASUMI_F8; + 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); uint64_t feat_flags = dev_info.feature_flags; @@ -4847,7 +4511,7 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata, /* Create KASUMI operation */ retval = create_wireless_algo_auth_cipher_operation( - tdata->digest.len, + tdata->digest.data, tdata->digest.len, tdata->cipher_iv.data, tdata->cipher_iv.len, NULL, 0, (tdata->digest.offset_bytes == 0 ? @@ -4857,7 +4521,7 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata, tdata->validCipherOffsetInBits.len, tdata->validAuthLenInBits.len, 0, - op_mode, 0); + op_mode, 0, verify); if (retval < 0) return retval; @@ -4950,6 +4614,19 @@ test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata, struct rte_cryptodev_info dev_info; + /* 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_KASUMI_F9; + 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_KASUMI_F8; + 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); uint64_t feat_flags = dev_info.feature_flags; @@ -5024,7 +4701,7 @@ test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata, /* Create KASUMI operation */ retval = create_wireless_algo_auth_cipher_operation( - tdata->digest.len, + tdata->digest.data, tdata->digest.len, tdata->cipher_iv.data, tdata->cipher_iv.len, NULL, 0, (tdata->digest.offset_bytes == 0 ? @@ -5034,7 +4711,7 @@ test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata, tdata->validCipherOffsetInBits.len, tdata->validAuthLenInBits.len, 0, - op_mode, 1); + op_mode, 1, verify); if (retval < 0) return retval; @@ -5125,6 +4802,19 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) unsigned plaintext_pad_len; unsigned plaintext_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_KASUMI_F9; + 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_KASUMI_F8; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create KASUMI session */ retval = create_wireless_algo_cipher_auth_session( ts_params->valid_devs[0], @@ -5379,6 +5069,12 @@ test_zuc_authentication(const struct wireless_test_data *tdata) struct rte_cryptodev_sym_capability_idx cap_idx; + /* QAT PMD supports byte-aligned data only */ + if ((tdata->validAuthLenInBits.len % 8 != 0) && + (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)))) + return -ENOTSUP; + /* Check if device supports ZUC EIA3 */ cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; @@ -5430,7 +5126,7 @@ test_zuc_authentication(const struct wireless_test_data *tdata) TEST_ASSERT_BUFFERS_ARE_EQUAL( ut_params->digest, tdata->digest.data, - DIGEST_BYTE_LENGTH_KASUMI_F9, + tdata->digest.len, "ZUC Generated auth tag not as expected"); return 0; @@ -5466,11 +5162,9 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata, uint64_t feat_flags = dev_info.feature_flags; - if (op_mode == OUT_OF_PLACE) { - if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { - printf("Device doesn't support digest encrypted.\n"); - return -ENOTSUP; - } + if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { + printf("Device doesn't support digest encrypted.\n"); + return -ENOTSUP; } /* Create ZUC session */ @@ -5525,7 +5219,7 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata, /* Create ZUC operation */ retval = create_wireless_algo_auth_cipher_operation( - tdata->digest.len, + tdata->digest.data, tdata->digest.len, tdata->cipher_iv.data, tdata->cipher_iv.len, tdata->auth_iv.data, tdata->auth_iv.len, (tdata->digest.offset_bytes == 0 ? @@ -5535,7 +5229,7 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata, tdata->validCipherOffsetInBits.len, tdata->validAuthLenInBits.len, 0, - op_mode, 0); + op_mode, 0, verify); if (retval < 0) return retval; @@ -5711,7 +5405,7 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, /* Create ZUC operation */ retval = create_wireless_algo_auth_cipher_operation( - tdata->digest.len, + tdata->digest.data, tdata->digest.len, tdata->cipher_iv.data, tdata->cipher_iv.len, NULL, 0, (tdata->digest.offset_bytes == 0 ? @@ -5721,7 +5415,7 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, tdata->validCipherOffsetInBits.len, tdata->validAuthLenInBits.len, 0, - op_mode, 1); + op_mode, 1, verify); if (retval < 0) return retval; @@ -6320,6 +6014,11 @@ test_zuc_hash_generate_test_case_6(void) static int test_zuc_hash_generate_test_case_7(void) { + /* This test is not for SW ZUC PMD */ + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) + return -ENOTSUP; + return test_zuc_authentication(&zuc_test_case_auth_2080b); } @@ -6344,6 +6043,11 @@ test_zuc_cipher_auth_test_case_2(void) static int test_zuc_auth_cipher_test_case_1(void) { + /* This test is not for SW ZUC PMD */ + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) + return -ENOTSUP; + return test_zuc_auth_cipher( &zuc_auth_cipher_test_case_1, IN_PLACE, 0); } @@ -6398,344 +6102,656 @@ test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void) } static int -test_3DES_chain_qat_all(void) +test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata) +{ + uint8_t dev_id = testsuite_params.valid_devs[0]; + + struct rte_cryptodev_sym_capability_idx cap_idx; + + /* Check if device supports particular cipher algorithm */ + cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + cap_idx.algo.cipher = tdata->cipher_algo; + if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL) + return -ENOTSUP; + + /* Check if device supports particular hash algorithm */ + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = tdata->auth_algo; + if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL) + return -ENOTSUP; + + return 0; +} + +static int +test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata, + uint8_t op_mode, uint8_t verify) { struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + struct crypto_unittest_params *ut_params = &unittest_params; + + int retval; + + uint8_t *plaintext = NULL, *ciphertext = NULL; + unsigned int plaintext_pad_len; + unsigned int plaintext_len; + unsigned int ciphertext_pad_len; + unsigned int ciphertext_len; + + struct rte_cryptodev_info dev_info; + struct rte_crypto_op *op; + + /* Check if device supports particular algorithms separately */ + if (test_mixed_check_if_unsupported(tdata)) + return -ENOTSUP; + + 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_DIGEST_ENCRYPTED)) { + printf("Device doesn't support digest encrypted.\n"); + return -ENOTSUP; + } + + /* Create the session */ + if (verify) + retval = create_wireless_algo_cipher_auth_session( + ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_DECRYPT, + RTE_CRYPTO_AUTH_OP_VERIFY, + tdata->auth_algo, + tdata->cipher_algo, + tdata->auth_key.data, tdata->auth_key.len, + tdata->auth_iv.len, tdata->digest_enc.len, + tdata->cipher_iv.len); + else + retval = create_wireless_algo_auth_cipher_session( + ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + tdata->auth_algo, + tdata->cipher_algo, + tdata->auth_key.data, tdata->auth_key.len, + tdata->auth_iv.len, tdata->digest_enc.len, + tdata->cipher_iv.len); + if (retval < 0) + return retval; + + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + if (op_mode == OUT_OF_PLACE) + 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)); + if (op_mode == OUT_OF_PLACE) + memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->obuf)); + + ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits); + plaintext_len = ceil_byte_length(tdata->plaintext.len_bits); + ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); + + if (verify) { + ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + ciphertext_pad_len); + memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); + if (op_mode == OUT_OF_PLACE) + rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); + debug_hexdump(stdout, "ciphertext:", ciphertext, + ciphertext_len); + } else { + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, plaintext_len); + if (op_mode == OUT_OF_PLACE) + rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); + debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); + } + + /* Create the operation */ + retval = create_wireless_algo_auth_cipher_operation( + tdata->digest_enc.data, tdata->digest_enc.len, + tdata->cipher_iv.data, tdata->cipher_iv.len, + tdata->auth_iv.data, tdata->auth_iv.len, + (tdata->digest_enc.offset == 0 ? + plaintext_pad_len + : tdata->digest_enc.offset), + tdata->validCipherLen.len_bits, + tdata->cipher.offset_bits, + tdata->validAuthLen.len_bits, + tdata->auth.offset_bits, + op_mode, 0, verify); + + if (retval < 0) + return retval; + + op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + + /* Check if the op failed because the device doesn't */ + /* support this particular combination of algorithms */ + if (op == NULL && ut_params->op->status == + RTE_CRYPTO_OP_STATUS_INVALID_SESSION) { + printf("Device doesn't support this mixed combination. " + "Test Skipped.\n"); + return -ENOTSUP; + } + ut_params->op = op; + + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + + ut_params->obuf = (op_mode == IN_PLACE ? + ut_params->op->sym->m_src : ut_params->op->sym->m_dst); + + if (verify) { + if (ut_params->obuf) + plaintext = rte_pktmbuf_mtod(ut_params->obuf, + uint8_t *); + else + plaintext = ciphertext + + (tdata->cipher.offset_bits >> 3); + + debug_hexdump(stdout, "plaintext:", plaintext, + tdata->plaintext.len_bits >> 3); + debug_hexdump(stdout, "plaintext expected:", + tdata->plaintext.data, + tdata->plaintext.len_bits >> 3); + } else { + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, + uint8_t *); + else + ciphertext = plaintext; + + debug_hexdump(stdout, "ciphertext:", ciphertext, + ciphertext_len); + debug_hexdump(stdout, "ciphertext expected:", + tdata->ciphertext.data, + tdata->ciphertext.len_bits >> 3); + + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + (tdata->digest_enc.offset == 0 ? + plaintext_pad_len : tdata->digest_enc.offset); + + debug_hexdump(stdout, "digest:", ut_params->digest, + tdata->digest_enc.len); + debug_hexdump(stdout, "digest expected:", + tdata->digest_enc.data, + tdata->digest_enc.len); + } + + /* Validate obuf */ + if (verify) { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len_bits >> 3, + "Plaintext data not as expected"); + } else { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + tdata->ciphertext.data, + tdata->validDataLen.len_bits, + "Ciphertext data not as expected"); - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ut_params->digest, + tdata->digest_enc.data, + DIGEST_BYTE_LENGTH_SNOW3G_UIA2, + "Generated auth tag not as expected"); + } - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); - return TEST_SUCCESS; + return 0; } static int -test_DES_cipheronly_qat_all(void) +test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata, + uint8_t op_mode, uint8_t verify) { struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + struct crypto_unittest_params *ut_params = &unittest_params; - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)), - BLKCIPHER_DES_CIPHERONLY_TYPE); + int retval; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + const uint8_t *plaintext = NULL; + const uint8_t *ciphertext = NULL; + const uint8_t *digest = NULL; + unsigned int plaintext_pad_len; + unsigned int plaintext_len; + unsigned int ciphertext_pad_len; + unsigned int ciphertext_len; + uint8_t buffer[10000]; + uint8_t digest_buffer[10000]; - return TEST_SUCCESS; -} + struct rte_cryptodev_info dev_info; + struct rte_crypto_op *op; -static int -test_DES_cipheronly_openssl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* Check if device supports particular algorithms */ + if (test_mixed_check_if_unsupported(tdata)) + return -ENOTSUP; - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)), - BLKCIPHER_DES_CIPHERONLY_TYPE); + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + uint64_t feat_flags = dev_info.feature_flags; - return TEST_SUCCESS; -} + if (op_mode == IN_PLACE) { + if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { + printf("Device doesn't support in-place scatter-gather " + "in both input and output mbufs.\n"); + return -ENOTSUP; + } + } else { + if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) { + printf("Device doesn't support out-of-place scatter-gather " + "in both input and output mbufs.\n"); + return -ENOTSUP; + } + if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { + printf("Device doesn't support digest encrypted.\n"); + return -ENOTSUP; + } + } -static int -test_DES_docsis_openssl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* Create the session */ + if (verify) + retval = create_wireless_algo_cipher_auth_session( + ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_DECRYPT, + RTE_CRYPTO_AUTH_OP_VERIFY, + tdata->auth_algo, + tdata->cipher_algo, + tdata->auth_key.data, tdata->auth_key.len, + tdata->auth_iv.len, tdata->digest_enc.len, + tdata->cipher_iv.len); + else + retval = create_wireless_algo_auth_cipher_session( + ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + tdata->auth_algo, + tdata->cipher_algo, + tdata->auth_key.data, tdata->auth_key.len, + tdata->auth_iv.len, tdata->digest_enc.len, + tdata->cipher_iv.len); + if (retval < 0) + return retval; - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)), - BLKCIPHER_DES_DOCSIS_TYPE); + ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits); + plaintext_len = ceil_byte_length(tdata->plaintext.len_bits); + ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, + ciphertext_pad_len, 15, 0); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); - return TEST_SUCCESS; -} + if (op_mode == OUT_OF_PLACE) { + ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, + plaintext_pad_len, 15, 0); + TEST_ASSERT_NOT_NULL(ut_params->obuf, + "Failed to allocate output buffer in mempool"); + } -static int -test_DES_cipheronly_mb_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + if (verify) { + pktmbuf_write(ut_params->ibuf, 0, ciphertext_len, + tdata->ciphertext.data); + ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, + ciphertext_len, buffer); + debug_hexdump(stdout, "ciphertext:", ciphertext, + ciphertext_len); + } else { + pktmbuf_write(ut_params->ibuf, 0, plaintext_len, + tdata->plaintext.data); + plaintext = rte_pktmbuf_read(ut_params->ibuf, 0, + plaintext_len, buffer); + debug_hexdump(stdout, "plaintext:", plaintext, + plaintext_len); + } + memset(buffer, 0, sizeof(buffer)); - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)), - BLKCIPHER_DES_CIPHERONLY_TYPE); + /* Create the operation */ + retval = create_wireless_algo_auth_cipher_operation( + tdata->digest_enc.data, tdata->digest_enc.len, + tdata->cipher_iv.data, tdata->cipher_iv.len, + tdata->auth_iv.data, tdata->auth_iv.len, + (tdata->digest_enc.offset == 0 ? + plaintext_pad_len + : tdata->digest_enc.offset), + tdata->validCipherLen.len_bits, + tdata->cipher.offset_bits, + tdata->validAuthLen.len_bits, + tdata->auth.offset_bits, + op_mode, 1, verify); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + if (retval < 0) + return retval; - return TEST_SUCCESS; -} -static int -test_3DES_cipheronly_mb_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); + /* Check if the op failed because the device doesn't */ + /* support this particular combination of algorithms */ + if (op == NULL && ut_params->op->status == + RTE_CRYPTO_OP_STATUS_INVALID_SESSION) { + printf("Device doesn't support this mixed combination. " + "Test Skipped.\n"); + return -ENOTSUP; + } - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + ut_params->op = op; - return TEST_SUCCESS; -} + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); -static int -test_DES_docsis_mb_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + ut_params->obuf = (op_mode == IN_PLACE ? + ut_params->op->sym->m_src : ut_params->op->sym->m_dst); - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)), - BLKCIPHER_DES_DOCSIS_TYPE); + if (verify) { + if (ut_params->obuf) + plaintext = rte_pktmbuf_read(ut_params->obuf, 0, + plaintext_len, buffer); + else + plaintext = rte_pktmbuf_read(ut_params->ibuf, 0, + plaintext_len, buffer); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + debug_hexdump(stdout, "plaintext:", plaintext, + (tdata->plaintext.len_bits >> 3) - + tdata->digest_enc.len); + debug_hexdump(stdout, "plaintext expected:", + tdata->plaintext.data, + (tdata->plaintext.len_bits >> 3) - + tdata->digest_enc.len); + } else { + if (ut_params->obuf) + ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, + ciphertext_len, buffer); + else + ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, + ciphertext_len, buffer); - return TEST_SUCCESS; -} + debug_hexdump(stdout, "ciphertext:", ciphertext, + ciphertext_len); + debug_hexdump(stdout, "ciphertext expected:", + tdata->ciphertext.data, + tdata->ciphertext.len_bits >> 3); -static int -test_3DES_chain_caam_jr_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + if (ut_params->obuf) + digest = rte_pktmbuf_read(ut_params->obuf, + (tdata->digest_enc.offset == 0 ? + plaintext_pad_len : + tdata->digest_enc.offset), + tdata->digest_enc.len, digest_buffer); + else + digest = rte_pktmbuf_read(ut_params->ibuf, + (tdata->digest_enc.offset == 0 ? + plaintext_pad_len : + tdata->digest_enc.offset), + tdata->digest_enc.len, digest_buffer); - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); + debug_hexdump(stdout, "digest:", digest, + tdata->digest_enc.len); + debug_hexdump(stdout, "digest expected:", + tdata->digest_enc.data, tdata->digest_enc.len); + } - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* Validate obuf */ + if (verify) { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len_bits >> 3, + "Plaintext data not as expected"); + } else { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + tdata->ciphertext.data, + tdata->validDataLen.len_bits, + "Ciphertext data not as expected"); + TEST_ASSERT_BUFFERS_ARE_EQUAL( + digest, + tdata->digest_enc.data, + tdata->digest_enc.len, + "Generated auth tag not as expected"); + } - return TEST_SUCCESS; + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + return 0; } +/** AUTH AES CMAC + CIPHER AES CTR */ + static int -test_3DES_cipheronly_caam_jr_all(void) +test_aes_cmac_aes_ctr_digest_enc_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0); } static int -test_3DES_chain_dpaa_sec_all(void) +test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); } static int -test_3DES_cipheronly_dpaa_sec_all(void) +test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + return test_mixed_auth_cipher_sgl( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0); +} - return TEST_SUCCESS; +static int +test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void) +{ + return test_mixed_auth_cipher_sgl( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); } static int -test_3DES_chain_dpaa2_sec_all(void) +test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1); +} - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); +static int +test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void) +{ + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); +} - TEST_ASSERT_EQUAL(status, 0, "Test failed"); +static int +test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void) +{ + return test_mixed_auth_cipher_sgl( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1); +} - return TEST_SUCCESS; +static int +test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void) +{ + return test_mixed_auth_cipher_sgl( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); } +/** MIXED AUTH + CIPHER */ + static int -test_3DES_cipheronly_dpaa2_sec_all(void) +test_auth_zuc_cipher_snow_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + return test_mixed_auth_cipher( + &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0); +} - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); +static int +test_verify_auth_zuc_cipher_snow_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1); +} - TEST_ASSERT_EQUAL(status, 0, "Test failed"); +static int +test_auth_aes_cmac_cipher_snow_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0); +} - return TEST_SUCCESS; +static int +test_verify_auth_aes_cmac_cipher_snow_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1); } static int -test_3DES_chain_ccp_all(void) +test_auth_zuc_cipher_aes_ctr_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + return test_mixed_auth_cipher( + &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); +} - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CCP_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); +static int +test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); +} - TEST_ASSERT_EQUAL(status, 0, "Test failed"); +static int +test_auth_snow_cipher_aes_ctr_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); +} - return TEST_SUCCESS; +static int +test_verify_auth_snow_cipher_aes_ctr_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); } static int -test_3DES_cipheronly_ccp_all(void) +test_auth_snow_cipher_zuc_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + return test_mixed_auth_cipher( + &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); +} - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CCP_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); +static int +test_verify_auth_snow_cipher_zuc_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); +} - TEST_ASSERT_EQUAL(status, 0, "Test failed"); +static int +test_auth_aes_cmac_cipher_zuc_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); +} - return TEST_SUCCESS; +static int +test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); } static int -test_3DES_cipheronly_qat_all(void) +test_auth_null_cipher_snow_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + return test_mixed_auth_cipher( + &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0); +} - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); +static int +test_verify_auth_null_cipher_snow_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1); +} - TEST_ASSERT_EQUAL(status, 0, "Test failed"); +static int +test_auth_null_cipher_zuc_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); +} - return TEST_SUCCESS; +static int +test_verify_auth_null_cipher_zuc_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); } static int -test_3DES_chain_openssl_all(void) +test_auth_snow_cipher_null_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + return test_mixed_auth_cipher( + &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0); +} - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); +static int +test_verify_auth_snow_cipher_null_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1); +} - TEST_ASSERT_EQUAL(status, 0, "Test failed"); +static int +test_auth_zuc_cipher_null_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0); +} - return TEST_SUCCESS; +static int +test_verify_auth_zuc_cipher_null_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1); } static int -test_3DES_cipheronly_openssl_all(void) +test_auth_null_cipher_aes_ctr_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + return test_mixed_auth_cipher( + &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); +} - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); +static int +test_verify_auth_null_cipher_aes_ctr_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); +} - TEST_ASSERT_EQUAL(status, 0, "Test failed"); +static int +test_auth_aes_cmac_cipher_null_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0); +} - return TEST_SUCCESS; +static int +test_verify_auth_aes_cmac_cipher_null_test_case_1(void) +{ + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1); } /* ***** AEAD algorithm Tests ***** */ @@ -6966,6 +6982,20 @@ test_authenticated_encryption(const struct aead_test_data *tdata) uint16_t plaintext_pad_len; uint32_t i; + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + const struct rte_cryptodev_symmetric_capability *capability; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; + cap_idx.algo.aead = tdata->algo; + capability = rte_cryptodev_sym_capability_get( + ts_params->valid_devs[0], &cap_idx); + if (capability == NULL) + return -ENOTSUP; + if (rte_cryptodev_sym_capability_check_aead( + capability, tdata->key.len, tdata->auth_tag.len, + tdata->aad.len, tdata->iv.len)) + return -ENOTSUP; + /* Create AEAD session */ retval = create_aead_session(ts_params->valid_devs[0], tdata->algo, @@ -6998,7 +7028,11 @@ test_authenticated_encryption(const struct aead_test_data *tdata) ut_params->op->sym->m_src = ut_params->ibuf; /* 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, @@ -7057,6 +7091,18 @@ test_pdcp_proto(int i, int oop, struct crypto_unittest_params *ut_params = &unittest_params; uint8_t *plaintext; int ret = TEST_SUCCESS; + struct rte_security_ctx *ctx = (struct rte_security_ctx *) + rte_cryptodev_get_sec_ctx( + ts_params->valid_devs[0]); + + /* Verify the capabilities */ + struct rte_security_capability_idx sec_cap_idx; + + sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; + sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP; + sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain; + if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL) + return -ENOTSUP; /* Generate test mbuf data */ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); @@ -7119,13 +7165,9 @@ test_pdcp_proto(int i, int oop, .crypto_xform = &ut_params->cipher_xform }; - struct rte_security_ctx *ctx = (struct rte_security_ctx *) - rte_cryptodev_get_sec_ctx( - ts_params->valid_devs[0]); - /* Create security session */ ut_params->sec_session = rte_security_session_create(ctx, - &sess_conf, ts_params->session_mpool); + &sess_conf, ts_params->session_priv_mpool); if (!ut_params->sec_session) { printf("TestCase %s()-%d line %d failed %s: ", @@ -7223,6 +7265,18 @@ test_pdcp_proto_SGL(int i, int oop, int to_trn_tbl[16]; int segs = 1; unsigned int trn_data = 0; + struct rte_security_ctx *ctx = (struct rte_security_ctx *) + rte_cryptodev_get_sec_ctx( + ts_params->valid_devs[0]); + + /* Verify the capabilities */ + struct rte_security_capability_idx sec_cap_idx; + + sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; + sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP; + sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain; + if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL) + return -ENOTSUP; if (fragsz > input_vec_len) fragsz = input_vec_len; @@ -7368,13 +7422,9 @@ test_pdcp_proto_SGL(int i, int oop, .crypto_xform = &ut_params->cipher_xform }; - struct rte_security_ctx *ctx = (struct rte_security_ctx *) - rte_cryptodev_get_sec_ctx( - ts_params->valid_devs[0]); - /* Create security session */ ut_params->sec_session = rte_security_session_create(ctx, - &sess_conf, ts_params->session_mpool); + &sess_conf, ts_params->session_priv_mpool); if (!ut_params->sec_session) { printf("TestCase %s()-%d line %d failed %s: ", @@ -7656,6 +7706,12 @@ test_AES_GCM_authenticated_encryption_test_case_7(void) return test_authenticated_encryption(&gcm_test_case_7); } +static int +test_AES_GCM_authenticated_encryption_test_case_8(void) +{ + return test_authenticated_encryption(&gcm_test_case_8); +} + static int test_AES_GCM_auth_encryption_test_case_192_1(void) { @@ -7752,6 +7808,105 @@ test_AES_GCM_auth_encryption_test_case_aad_2(void) return test_authenticated_encryption(&gcm_test_case_aad_2); } +static int +test_AES_GCM_auth_encryption_fail_iv_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.iv.data[0] += 1; + res = test_authenticated_encryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_encryption_fail_in_data_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.plaintext.data[0] += 1; + res = test_authenticated_encryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_encryption_fail_out_data_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.ciphertext.data[0] += 1; + res = test_authenticated_encryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.aad.len += 1; + res = test_authenticated_encryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_encryption_fail_aad_corrupt(void) +{ + struct aead_test_data tdata; + uint8_t aad[gcm_test_case_7.aad.len]; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len); + aad[0] += 1; + tdata.aad.data = aad; + res = test_authenticated_encryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_encryption_fail_tag_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.auth_tag.data[0] += 1; + res = test_authenticated_encryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + static int test_authenticated_decryption(const struct aead_test_data *tdata) { @@ -7762,6 +7917,20 @@ test_authenticated_decryption(const struct aead_test_data *tdata) uint8_t *plaintext; uint32_t i; + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + const struct rte_cryptodev_symmetric_capability *capability; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; + cap_idx.algo.aead = tdata->algo; + capability = rte_cryptodev_sym_capability_get( + ts_params->valid_devs[0], &cap_idx); + if (capability == NULL) + return -ENOTSUP; + if (rte_cryptodev_sym_capability_check_aead( + capability, tdata->key.len, tdata->auth_tag.len, + tdata->aad.len, tdata->iv.len)) + return -ENOTSUP; + /* Create AEAD session */ retval = create_aead_session(ts_params->valid_devs[0], tdata->algo, @@ -7794,7 +7963,11 @@ test_authenticated_decryption(const struct aead_test_data *tdata) ut_params->op->sym->m_src = ut_params->ibuf; /* 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, @@ -7820,6 +7993,7 @@ test_authenticated_decryption(const struct aead_test_data *tdata) TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, "Authentication failed"); + return 0; } @@ -7865,6 +8039,12 @@ test_AES_GCM_authenticated_decryption_test_case_7(void) return test_authenticated_decryption(&gcm_test_case_7); } +static int +test_AES_GCM_authenticated_decryption_test_case_8(void) +{ + return test_authenticated_decryption(&gcm_test_case_8); +} + static int test_AES_GCM_auth_decryption_test_case_192_1(void) { @@ -7961,6 +8141,100 @@ test_AES_GCM_auth_decryption_test_case_aad_2(void) return test_authenticated_decryption(&gcm_test_case_aad_2); } +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 +test_AES_GCM_auth_decryption_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_decryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_decryption_fail_out_data_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + 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; +} + +static int +test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + 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; +} + +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; + + 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; +} + +static int +test_AES_GCM_auth_decryption_fail_tag_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + 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_authenticated_encryption_oop(const struct aead_test_data *tdata) { @@ -7971,6 +8245,18 @@ test_authenticated_encryption_oop(const struct aead_test_data *tdata) 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, @@ -8048,6 +8334,18 @@ test_authenticated_decryption_oop(const struct aead_test_data *tdata) int retval; uint8_t *plaintext; + /* 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, @@ -8120,6 +8418,25 @@ test_authenticated_encryption_sessionless( uint16_t plaintext_pad_len; uint8_t key[tdata->key.len + 1]; + /* This test is for AESNI MB and AESNI GCM PMDs only */ + if ((gbl_driver_id != rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) && + (gbl_driver_id != rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)))) + 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 */ @@ -8201,6 +8518,25 @@ test_authenticated_decryption_sessionless( uint8_t *plaintext; uint8_t key[tdata->key.len + 1]; + /* This test is for AESNI MB and AESNI GCM PMDs only */ + if ((gbl_driver_id != rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) && + (gbl_driver_id != rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)))) + 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); @@ -8379,6 +8715,19 @@ test_stats(void) struct rte_cryptodev *dev; cryptodev_stats_get_t temp_pfn; + /* 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), @@ -8513,6 +8862,14 @@ test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case) struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + /* 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; + 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; @@ -8559,6 +8916,14 @@ test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case) struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + /* 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; + 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; @@ -8617,6 +8982,19 @@ test_multi_session(void) uint16_t i; + /* 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; + test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params, aes_cbc_key, hmac_sha512_key); @@ -8732,6 +9110,19 @@ test_multi_session_random_usage(void) }; + /* 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; + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); sessions = rte_malloc(NULL, @@ -8814,6 +9205,14 @@ test_null_cipher_only_operation(void) struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + /* 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; + /* 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); @@ -8880,6 +9279,14 @@ test_null_auth_only_operation(void) 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; + /* 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); @@ -8952,6 +9359,19 @@ test_null_cipher_auth_operation(void) 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; + 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); @@ -9040,6 +9460,19 @@ test_null_auth_cipher_operation(void) 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; + 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); @@ -9129,6 +9562,11 @@ test_null_invalid_operation(void) 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; @@ -9181,6 +9619,11 @@ test_null_burst_operation(void) 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; @@ -9357,6 +9800,14 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata) TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, "No GMAC length in the source data"); + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + retval = create_gmac_session(ts_params->valid_devs[0], tdata, RTE_CRYPTO_AUTH_OP_GENERATE); @@ -9400,7 +9851,11 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata) ut_params->op->sym->m_src = ut_params->ibuf; - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_gmac_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, @@ -9460,6 +9915,14 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata) TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, "No GMAC length in the source data"); + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + retval = create_gmac_session(ts_params->valid_devs[0], tdata, RTE_CRYPTO_AUTH_OP_VERIFY); @@ -9504,7 +9967,11 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata) ut_params->op->sym->m_src = ut_params->ibuf; - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_gmac_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, @@ -9540,6 +10007,8 @@ test_AES_GMAC_authentication_verify_test_case_4(void) struct test_crypto_vector { enum rte_crypto_cipher_algorithm crypto_algo; + unsigned int cipher_offset; + unsigned int cipher_len; struct { uint8_t data[64]; @@ -9562,6 +10031,7 @@ struct test_crypto_vector { } ciphertext; enum rte_crypto_auth_algorithm auth_algo; + unsigned int auth_offset; struct { uint8_t data[128]; @@ -9637,6 +10107,8 @@ aes128_gmac_test_vector = { static const struct test_crypto_vector aes128cbc_hmac_sha1_test_vector = { .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC, + .cipher_offset = 0, + .cipher_len = 512, .cipher_key = { .data = { 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, @@ -9660,6 +10132,7 @@ aes128cbc_hmac_sha1_test_vector = { .len = 512 }, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC, + .auth_offset = 0, .auth_key = { .data = { 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, @@ -9678,6 +10151,53 @@ aes128cbc_hmac_sha1_test_vector = { } }; +static const struct test_crypto_vector +aes128cbc_hmac_sha1_aad_test_vector = { + .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC, + .cipher_offset = 12, + .cipher_len = 496, + .cipher_key = { + .data = { + 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, + 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A + }, + .len = 16 + }, + .iv = { + .data = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F + }, + .len = 16 + }, + .plaintext = { + .data = plaintext_hash, + .len = 512 + }, + .ciphertext = { + .data = ciphertext512_aes128cbc_aad, + .len = 512 + }, + .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC, + .auth_offset = 0, + .auth_key = { + .data = { + 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, + 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, + 0xDE, 0xF4, 0xDE, 0xAD + }, + .len = 20 + }, + .digest = { + .data = { + 0x1F, 0x6A, 0xD2, 0x8B, 0x4B, 0xB3, 0xC0, 0x9E, + 0x86, 0x9B, 0x3A, 0xF2, 0x00, 0x5B, 0x4F, 0x08, + 0x62, 0x8D, 0x62, 0x65 + }, + .len = 20 + } +}; + static void data_corruption(uint8_t *data) { @@ -9920,11 +10440,11 @@ create_cipher_auth_operation(struct crypto_testsuite_params *ts_params, rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), reference->iv.data, reference->iv.len); - sym_op->cipher.data.length = reference->ciphertext.len; - sym_op->cipher.data.offset = 0; + sym_op->cipher.data.length = reference->cipher_len; + sym_op->cipher.data.offset = reference->cipher_offset; - sym_op->auth.data.length = reference->ciphertext.len; - sym_op->auth.data.offset = 0; + sym_op->auth.data.length = reference->plaintext.len; + sym_op->auth.data.offset = reference->auth_offset; return 0; } @@ -9965,6 +10485,14 @@ test_authentication_verify_fail_when_data_corruption( uint8_t *plaintext; + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = reference->auth_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create session */ retval = create_auth_session(ut_params, ts_params->valid_devs[0], @@ -9990,47 +10518,223 @@ test_authentication_verify_fail_when_data_corruption( reference->plaintext.len); /* Create operation */ - retval = create_auth_verify_operation(ts_params, ut_params, reference); + retval = create_auth_verify_operation(ts_params, ut_params, reference); + + if (retval < 0) + return retval; + + if (data_corrupted) + data_corruption(plaintext); + else + tag_corruption(plaintext, reference->plaintext.len); + + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + + TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); + + return 0; +} + +static int +test_authentication_verify_GMAC_fail_when_corruption( + struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference, + unsigned int data_corrupted) +{ + int retval; + uint8_t *plaintext; + + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = reference->auth_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + + /* Create session */ + retval = create_auth_cipher_session(ut_params, + ts_params->valid_devs[0], + reference, + RTE_CRYPTO_AUTH_OP_VERIFY, + RTE_CRYPTO_CIPHER_OP_DECRYPT); + if (retval < 0) + return retval; + + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); + + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + reference->plaintext.len); + TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); + memcpy(plaintext, reference->plaintext.data, reference->plaintext.len); + + debug_hexdump(stdout, "plaintext:", plaintext, + reference->plaintext.len); + + /* Create operation */ + retval = create_auth_verify_GMAC_operation(ts_params, + ut_params, + reference); + + if (retval < 0) + return retval; + + if (data_corrupted) + data_corruption(plaintext); + else + tag_corruption(plaintext, reference->aad.len); + + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) { + process_cpu_gmac_op(ts_params->valid_devs[0], ut_params->op); + TEST_ASSERT_NOT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, + "authentication not failed"); + } else { + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); + } + + return 0; +} + +static int +test_authenticated_decryption_fail_when_corruption( + struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference, + unsigned int data_corrupted) +{ + int retval; + + uint8_t *ciphertext; + + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = reference->auth_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + cap_idx.algo.cipher = reference->crypto_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + + /* Create session */ + retval = create_auth_cipher_session(ut_params, + ts_params->valid_devs[0], + reference, + RTE_CRYPTO_AUTH_OP_VERIFY, + RTE_CRYPTO_CIPHER_OP_DECRYPT); + if (retval < 0) + return retval; + + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); + + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + reference->ciphertext.len); + TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext"); + memcpy(ciphertext, reference->ciphertext.data, + reference->ciphertext.len); + + /* Create operation */ + retval = create_cipher_auth_verify_operation(ts_params, + ut_params, + reference); if (retval < 0) return retval; if (data_corrupted) - data_corruption(plaintext); + data_corruption(ciphertext); else - tag_corruption(plaintext, reference->plaintext.len); + tag_corruption(ciphertext, reference->ciphertext.len); ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - TEST_ASSERT_NOT_EQUAL(ut_params->op->status, - RTE_CRYPTO_OP_STATUS_SUCCESS, - "authentication not failed"); - ut_params->obuf = ut_params->op->sym->m_src; - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); return 0; } static int -test_authentication_verify_GMAC_fail_when_corruption( +test_authenticated_encryt_with_esn( struct crypto_testsuite_params *ts_params, struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference, - unsigned int data_corrupted) + const struct test_crypto_vector *reference) { int retval; - uint8_t *plaintext; + + uint8_t *authciphertext, *plaintext, *auth_tag; + uint16_t plaintext_pad_len; + uint8_t cipher_key[reference->cipher_key.len + 1]; + uint8_t auth_key[reference->auth_key.len + 1]; + + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = reference->auth_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + cap_idx.algo.cipher = reference->crypto_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; /* Create session */ - retval = create_auth_cipher_session(ut_params, - ts_params->valid_devs[0], - reference, - RTE_CRYPTO_AUTH_OP_VERIFY, - RTE_CRYPTO_CIPHER_OP_DECRYPT); - if (retval < 0) - return retval; + memcpy(cipher_key, reference->cipher_key.data, + reference->cipher_key.len); + memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); + + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.cipher.algo = reference->crypto_algo; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + ut_params->cipher_xform.cipher.key.data = cipher_key; + ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len; + ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; + ut_params->cipher_xform.cipher.iv.length = reference->iv.len; + + ut_params->cipher_xform.next = &ut_params->auth_xform; + + /* Setup Authentication Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + ut_params->auth_xform.auth.algo = reference->auth_algo; + ut_params->auth_xform.auth.key.length = reference->auth_key.len; + ut_params->auth_xform.auth.key.data = auth_key; + ut_params->auth_xform.auth.digest_length = reference->digest.len; + ut_params->auth_xform.next = NULL; + + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); + + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + ut_params->sess, + &ut_params->cipher_xform, + ts_params->session_priv_mpool); + + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); TEST_ASSERT_NOT_NULL(ut_params->ibuf, @@ -10045,54 +10749,107 @@ test_authentication_verify_GMAC_fail_when_corruption( TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); memcpy(plaintext, reference->plaintext.data, reference->plaintext.len); - debug_hexdump(stdout, "plaintext:", plaintext, - reference->plaintext.len); - /* Create operation */ - retval = create_auth_verify_GMAC_operation(ts_params, + retval = create_cipher_auth_operation(ts_params, ut_params, - reference); + reference, 0); if (retval < 0) return retval; - if (data_corrupted) - data_corruption(plaintext); - else - tag_corruption(plaintext, reference->aad.len); - ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - TEST_ASSERT_NOT_EQUAL(ut_params->op->status, - RTE_CRYPTO_OP_STATUS_SUCCESS, - "authentication not failed"); - ut_params->obuf = ut_params->op->sym->m_src; - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16); + + authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, + ut_params->op->sym->auth.data.offset); + auth_tag = authciphertext + plaintext_pad_len; + debug_hexdump(stdout, "ciphertext:", authciphertext, + reference->ciphertext.len); + debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len); + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + authciphertext, + reference->ciphertext.data, + reference->ciphertext.len, + "Ciphertext data not as expected"); + + TEST_ASSERT_BUFFERS_ARE_EQUAL( + auth_tag, + reference->digest.data, + reference->digest.len, + "Generated digest not as expected"); + + return TEST_SUCCESS; - return 0; } static int -test_authenticated_decryption_fail_when_corruption( +test_authenticated_decrypt_with_esn( struct crypto_testsuite_params *ts_params, struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference, - unsigned int data_corrupted) + const struct test_crypto_vector *reference) { int retval; uint8_t *ciphertext; + uint8_t cipher_key[reference->cipher_key.len + 1]; + uint8_t auth_key[reference->auth_key.len + 1]; + + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = reference->auth_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + cap_idx.algo.cipher = reference->crypto_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; /* Create session */ - retval = create_auth_cipher_session(ut_params, - ts_params->valid_devs[0], - reference, - RTE_CRYPTO_AUTH_OP_VERIFY, - RTE_CRYPTO_CIPHER_OP_DECRYPT); - if (retval < 0) - return retval; + memcpy(cipher_key, reference->cipher_key.data, + reference->cipher_key.len); + memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); + + /* Setup Authentication Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY; + ut_params->auth_xform.auth.algo = reference->auth_algo; + ut_params->auth_xform.auth.key.length = reference->auth_key.len; + ut_params->auth_xform.auth.key.data = auth_key; + ut_params->auth_xform.auth.digest_length = reference->digest.len; + ut_params->auth_xform.next = &ut_params->cipher_xform; + + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; + ut_params->cipher_xform.cipher.algo = reference->crypto_algo; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT; + ut_params->cipher_xform.cipher.key.data = cipher_key; + ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len; + ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; + ut_params->cipher_xform.cipher.iv.length = reference->iv.len; + + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); + + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + ut_params->sess, + &ut_params->auth_xform, + ts_params->session_priv_mpool); + + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); TEST_ASSERT_NOT_NULL(ut_params->ibuf, @@ -10116,18 +10873,13 @@ test_authenticated_decryption_fail_when_corruption( if (retval < 0) return retval; - if (data_corrupted) - data_corruption(ciphertext); - else - tag_corruption(ciphertext, reference->ciphertext.len); - ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - TEST_ASSERT_NOT_EQUAL(ut_params->op->status, + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "authentication not failed"); + "crypto op processing passed"); ut_params->obuf = ut_params->op->sym->m_src; TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); @@ -10146,6 +10898,7 @@ create_aead_operation_SGL(enum rte_crypto_aead_operation op, const unsigned int auth_tag_len = tdata->auth_tag.len; const unsigned int iv_len = tdata->iv.len; unsigned int aad_len = tdata->aad.len; + unsigned int aad_len_pad = 0; /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, @@ -10200,8 +10953,10 @@ create_aead_operation_SGL(enum rte_crypto_aead_operation op, rte_memcpy(iv_ptr, tdata->iv.data, iv_len); + aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16); + sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, aad_len); + ut_params->ibuf, aad_len_pad); TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data, "no room to prepend aad"); sym_op->aead.aad.phys_addr = rte_pktmbuf_iova( @@ -10216,7 +10971,7 @@ create_aead_operation_SGL(enum rte_crypto_aead_operation op, } sym_op->aead.data.length = tdata->plaintext.len; - sym_op->aead.data.offset = aad_len; + sym_op->aead.data.offset = aad_len_pad; return 0; } @@ -10236,6 +10991,45 @@ test_authenticated_encryption_SGL(const struct aead_test_data *tdata, int segs = 1; unsigned int trn_data = 0; uint8_t *plaintext, *ciphertext, *auth_tag; + struct rte_cryptodev_info dev_info; + + /* 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; + + /* OOP not supported with CPU crypto */ + if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; + + /* Detailed check for the particular SGL support flag */ + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + if (!oop) { + unsigned int sgl_in = fragsz < tdata->plaintext.len; + if (sgl_in && (!(dev_info.feature_flags & + RTE_CRYPTODEV_FF_IN_PLACE_SGL))) + return -ENOTSUP; + } else { + unsigned int sgl_in = fragsz < tdata->plaintext.len; + unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) < + tdata->plaintext.len; + if (sgl_in && !sgl_out) { + if (!(dev_info.feature_flags & + RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) + return -ENOTSUP; + } else if (!sgl_in && sgl_out) { + if (!(dev_info.feature_flags & + RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT)) + return -ENOTSUP; + } else if (sgl_in && sgl_out) { + if (!(dev_info.feature_flags & + RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) + return -ENOTSUP; + } + } if (fragsz > tdata->plaintext.len) fragsz = tdata->plaintext.len; @@ -10249,7 +11043,7 @@ test_authenticated_encryption_SGL(const struct aead_test_data *tdata, int ecx = 0; void *digest_mem = NULL; - uint32_t prepend_len = tdata->aad.len; + uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); if (tdata->plaintext.len % fragsz != 0) { if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO) @@ -10414,7 +11208,12 @@ test_authenticated_encryption_SGL(const struct aead_test_data *tdata, 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 (oop == IN_PLACE && + 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, @@ -10493,6 +11292,10 @@ test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void) static int test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void) { + /* This test is not for OPENSSL PMD */ + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) + return -ENOTSUP; return test_authenticated_encryption_SGL( &gcm_test_case_SGL_1, IN_PLACE, 1500, 0); @@ -10608,6 +11411,24 @@ auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void) &aes128cbc_hmac_sha1_test_vector); } +static int +auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void) +{ + return test_authenticated_encryt_with_esn( + &testsuite_params, + &unittest_params, + &aes128cbc_hmac_sha1_aad_test_vector); +} + +static int +auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void) +{ + return test_authenticated_decrypt_with_esn( + &testsuite_params, + &unittest_params, + &aes128cbc_hmac_sha1_aad_test_vector); +} + #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER /* global AESNI slave IDs for the scheduler test */ @@ -10795,45 +11616,33 @@ static struct unit_test_suite cryptodev_scheduler_testsuite = { /* Multi Core */ TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op), TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_scheduler_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_scheduler_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_scheduler_all), + 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(NULL, NULL, test_scheduler_detach_slave_op), /* Round Robin */ TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op), TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_scheduler_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_scheduler_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_scheduler_all), + 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(NULL, NULL, test_scheduler_detach_slave_op), /* Fail over */ TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op), TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_scheduler_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_scheduler_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_scheduler_all), + 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(NULL, NULL, test_scheduler_detach_slave_op), /* PKT SIZE */ TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op), TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_scheduler_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_scheduler_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_scheduler_all), + 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(NULL, NULL, test_scheduler_detach_slave_op), TEST_CASES_END() /**< NULL terminate unit test array */ @@ -10842,8 +11651,8 @@ static struct unit_test_suite cryptodev_scheduler_testsuite = { #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */ -static struct unit_test_suite cryptodev_qat_testsuite = { - .suite_name = "Crypto QAT Unit Test Suite", +static struct unit_test_suite cryptodev_testsuite = { + .suite_name = "Crypto Unit Test Suite", .setup = testsuite_setup, .teardown = testsuite_teardown, .unit_test_cases = { @@ -10853,22 +11662,24 @@ static struct unit_test_suite cryptodev_qat_testsuite = { test_device_configure_invalid_queue_pair_ids), TEST_CASE_ST(ut_setup, ut_teardown, test_queue_pair_descriptor_setup), - TEST_CASE_ST(ut_setup, ut_teardown, - test_multi_session), - TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_qat_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_qat_all), TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_cipheronly_qat_all), + test_multi_session), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_docsis_qat_all), + test_multi_session_random_usage), + TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_docsis_qat_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_qat_all), + 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 */ @@ -10887,6 +11698,38 @@ static struct unit_test_suite cryptodev_qat_testsuite = { 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), @@ -10894,6 +11737,8 @@ static struct unit_test_suite cryptodev_qat_testsuite = { 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, @@ -10908,6 +11753,8 @@ static struct unit_test_suite cryptodev_qat_testsuite = { 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), /** AES GCM Authenticated Decryption */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -10924,6 +11771,8 @@ static struct unit_test_suite cryptodev_qat_testsuite = { 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), /** AES GCM Authenticated Encryption 192 bits key */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -10973,6 +11822,46 @@ static struct unit_test_suite cryptodev_qat_testsuite = { 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), @@ -10986,6 +11875,10 @@ static struct unit_test_suite cryptodev_qat_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), /** SNOW 3G encrypt only (UEA2) */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -11001,6 +11894,10 @@ static struct unit_test_suite cryptodev_qat_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), @@ -11063,12 +11960,26 @@ static struct unit_test_suite cryptodev_qat_testsuite = { 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, @@ -11080,521 +11991,359 @@ static struct unit_test_suite cryptodev_qat_testsuite = { 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), - - /** ZUC authenticate (EIA3) */ - 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), - - /** NULL algo tests done in chain_all, - * cipheronly and authonly suites - */ - - /** KASUMI tests */ - 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), - - 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_3), - 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), - - /** 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, - authentication_verify_AES128_GMAC_fail_data_corrupt), - TEST_CASE_ST(ut_setup, ut_teardown, - authentication_verify_AES128_GMAC_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_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_virtio_all), - - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; - -static struct unit_test_suite cryptodev_aesni_mb_testsuite = { - .suite_name = "Crypto Device AESNI MB Unit Test Suite", - .setup = testsuite_setup, - .teardown = testsuite_teardown, - .unit_test_cases = { -#if IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0) - 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), - - /** 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), - - /** 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_zuc_encryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_5), + test_zuc_encryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_6), + test_zuc_encryption_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_7), + test_zuc_encryption_test_case_6_sgl), - /** AES GCM Authenticated Encryption 256 bits key */ + /** ZUC authenticate (EIA3) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_1), + test_zuc_hash_generate_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_2), + test_zuc_hash_generate_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_3), + test_zuc_hash_generate_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_4), + test_zuc_hash_generate_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_5), + test_zuc_hash_generate_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_6), + test_zuc_hash_generate_test_case_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_zuc_hash_generate_test_case_7), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_1), + test_zuc_hash_generate_test_case_8), + + /** ZUC alg-chain (EEA3/EIA3) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_2), + test_zuc_cipher_auth_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_3), + test_zuc_cipher_auth_test_case_2), + + /** ZUC generate auth, then encrypt (EEA3) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_4), + test_zuc_auth_cipher_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_5), + test_zuc_auth_cipher_test_case_1_oop), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_6), + test_zuc_auth_cipher_test_case_1_sgl), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_7), + test_zuc_auth_cipher_test_case_1_oop_sgl), - /** AES GCM Authenticated Encryption big aad size */ + /** ZUC decrypt (EEA3), then verify auth */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_aad_1), + test_zuc_auth_cipher_verify_test_case_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_zuc_auth_cipher_verify_test_case_1_oop), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_aad_1), + test_zuc_auth_cipher_verify_test_case_1_sgl), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_aad_2), + test_zuc_auth_cipher_verify_test_case_1_oop_sgl), - /** Session-less tests */ + /** HMAC_MD5 Authentication */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_sessionless_test_case_1), + test_MD5_HMAC_generate_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_sessionless_test_case_1), + 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), - /** AES GMAC Authentication */ + /** KASUMI hash only (UIA1) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_1), + test_kasumi_hash_generate_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_1), + test_kasumi_hash_generate_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_2), + test_kasumi_hash_generate_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_2), + test_kasumi_hash_generate_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_3), + test_kasumi_hash_generate_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_3), -#endif /* IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0) */ + test_kasumi_hash_generate_test_case_6), - TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all), TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_cipheronly_mb_all), + test_kasumi_hash_verify_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_docsis_mb_all), + test_kasumi_hash_verify_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_mb_all), + test_kasumi_hash_verify_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_1), + test_kasumi_hash_verify_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_1), + test_kasumi_hash_verify_test_case_5), + + /** KASUMI encrypt only (UEA1) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_2), + test_kasumi_encryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_2), + test_kasumi_encryption_test_case_1_sgl), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_3), + test_kasumi_encryption_test_case_1_oop), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_3), - - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; - -static struct unit_test_suite cryptodev_openssl_testsuite = { - .suite_name = "Crypto Device OPENSSL Unit Test Suite", - .setup = testsuite_setup, - .teardown = testsuite_teardown, - .unit_test_cases = { - TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session), + test_kasumi_encryption_test_case_1_oop_sgl), TEST_CASE_ST(ut_setup, ut_teardown, - test_multi_session_random_usage), + test_kasumi_encryption_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_openssl_all), + test_kasumi_encryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_openssl_all), + test_kasumi_encryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_openssl_all), + test_kasumi_encryption_test_case_5), + + /** KASUMI decrypt only (UEA1) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_openssl_all), + test_kasumi_decryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_cipheronly_openssl_all), + test_kasumi_decryption_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_docsis_openssl_all), + test_kasumi_decryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_openssl_all), - - /** AES GCM Authenticated Encryption */ + test_kasumi_decryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_1), + test_kasumi_decryption_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_2), + test_kasumi_decryption_test_case_1_oop), + TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_3), + test_kasumi_cipher_auth_test_case_1), + + /** KASUMI generate auth, then encrypt (F8) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_4), + test_kasumi_auth_cipher_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_5), + test_kasumi_auth_cipher_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_6), + test_kasumi_auth_cipher_test_case_2_oop), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_7), + test_kasumi_auth_cipher_test_case_2_sgl), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_auth_cipher_test_case_2_oop_sgl), - /** AES GCM Authenticated Decryption */ + /** KASUMI decrypt (F8), then verify auth */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_1), + test_kasumi_auth_cipher_verify_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_2), + test_kasumi_auth_cipher_verify_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_3), + test_kasumi_auth_cipher_verify_test_case_2_oop), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_4), + test_kasumi_auth_cipher_verify_test_case_2_sgl), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_5), + test_kasumi_auth_cipher_verify_test_case_2_oop_sgl), + + /** ESN Testcase */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_6), + auth_encrypt_AES128CBC_HMAC_SHA1_esn_check), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_7), - + auth_decrypt_AES128CBC_HMAC_SHA1_esn_check), - /** AES GCM Authenticated Encryption 192 bits key */ + /** Negative tests */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_1), + authentication_verify_HMAC_SHA1_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_2), + authentication_verify_HMAC_SHA1_fail_tag_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_3), + test_AES_GCM_auth_encryption_fail_iv_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_4), + test_AES_GCM_auth_encryption_fail_in_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_5), + test_AES_GCM_auth_encryption_fail_out_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_6), + test_AES_GCM_auth_encryption_fail_aad_len_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_7), - - /** AES GCM Authenticated Decryption 192 bits key */ + test_AES_GCM_auth_encryption_fail_aad_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_1), + test_AES_GCM_auth_encryption_fail_tag_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_2), + test_AES_GCM_auth_decryption_fail_iv_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_3), + test_AES_GCM_auth_decryption_fail_in_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_4), + test_AES_GCM_auth_decryption_fail_out_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_5), + test_AES_GCM_auth_decryption_fail_aad_len_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_6), + test_AES_GCM_auth_decryption_fail_aad_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_7), + test_AES_GCM_auth_decryption_fail_tag_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_AES128_GMAC_fail_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_AES128_GMAC_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), - /** AES GCM Authenticated Encryption 256 bits key */ + /** Mixed CIPHER + HASH algorithms */ + /** AUTH AES CMAC + CIPHER AES CTR */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_1), + test_aes_cmac_aes_ctr_digest_enc_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_2), + test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_3), + test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_4), + test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_5), + test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_6), + test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_7), + 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), - /** AES GCM Authenticated Decryption 256 bits key */ + /** AUTH ZUC + CIPHER SNOW3G */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_1), + test_auth_zuc_cipher_snow_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_2), + test_verify_auth_zuc_cipher_snow_test_case_1), + /** AUTH AES CMAC + CIPHER SNOW3G */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_3), + test_auth_aes_cmac_cipher_snow_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_4), + test_verify_auth_aes_cmac_cipher_snow_test_case_1), + /** AUTH ZUC + CIPHER AES CTR */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_5), + test_auth_zuc_cipher_aes_ctr_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_6), + test_verify_auth_zuc_cipher_aes_ctr_test_case_1), + /** AUTH SNOW3G + CIPHER AES CTR */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_7), - - /** AES GMAC Authentication */ + test_auth_snow_cipher_aes_ctr_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_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_AES_GMAC_authentication_verify_test_case_1), + test_auth_snow_cipher_zuc_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_2), + test_verify_auth_snow_cipher_zuc_test_case_1), + /** AUTH AES CMAC + CIPHER ZUC */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_2), + test_auth_aes_cmac_cipher_zuc_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_3), + test_verify_auth_aes_cmac_cipher_zuc_test_case_1), + + /** AUTH NULL + CIPHER SNOW3G */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_3), + test_auth_null_cipher_snow_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_4), + test_verify_auth_null_cipher_snow_test_case_1), + /** AUTH NULL + CIPHER ZUC */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_4), - - /** AES CCM Authenticated Encryption 128 bits key */ + test_auth_null_cipher_zuc_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_1), + test_verify_auth_null_cipher_zuc_test_case_1), + /** AUTH SNOW3G + CIPHER NULL */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_2), + test_auth_snow_cipher_null_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_3), - - /** AES CCM Authenticated Decryption 128 bits key*/ + test_verify_auth_snow_cipher_null_test_case_1), + /** AUTH ZUC + CIPHER NULL */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_1), + test_auth_zuc_cipher_null_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_2), + test_verify_auth_zuc_cipher_null_test_case_1), + /** AUTH NULL + CIPHER AES CTR */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_3), - - /** AES CCM Authenticated Encryption 192 bits key */ + test_auth_null_cipher_aes_ctr_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_192_1), + test_verify_auth_null_cipher_aes_ctr_test_case_1), + /** AUTH AES CMAC + CIPHER NULL */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_192_2), + test_auth_aes_cmac_cipher_null_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_192_3), + test_verify_auth_aes_cmac_cipher_null_test_case_1), - /** AES CCM Authenticated Decryption 192 bits key*/ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_192_1), + 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_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_192_2), + test_device_configure_invalid_dev_id), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_192_3), + 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 */ + } +}; - /** AES CCM Authenticated Encryption 256 bits key */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_256_1), +static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { + .suite_name = "Crypto DPAA_SEC Unit Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_256_2), + test_device_configure_invalid_dev_id), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_256_3), + test_multi_session), - /** AES CCM Authenticated Decryption 256 bits key*/ + 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), + +#ifdef RTE_LIBRTE_SECURITY TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_256_1), + test_PDCP_PROTO_cplane_encap_all), + TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_256_2), + test_PDCP_PROTO_cplane_decap_all), + TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_256_3), + test_PDCP_PROTO_uplane_encap_all), - /** Scatter-Gather */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg), + test_PDCP_PROTO_uplane_decap_all), - /** Negative tests */ TEST_CASE_ST(ut_setup, ut_teardown, - authentication_verify_HMAC_SHA1_fail_data_corrupt), + test_PDCP_PROTO_SGL_in_place_32B), TEST_CASE_ST(ut_setup, ut_teardown, - authentication_verify_HMAC_SHA1_fail_tag_corrupt), + test_PDCP_PROTO_SGL_oop_32B_128B), TEST_CASE_ST(ut_setup, ut_teardown, - authentication_verify_AES128_GMAC_fail_data_corrupt), + test_PDCP_PROTO_SGL_oop_32B_40B), TEST_CASE_ST(ut_setup, ut_teardown, - authentication_verify_AES128_GMAC_fail_tag_corrupt), + test_PDCP_PROTO_SGL_oop_128B_32B), +#endif + /** AES GCM Authenticated Encryption */ TEST_CASE_ST(ut_setup, ut_teardown, - auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), + test_AES_GCM_auth_encrypt_SGL_in_place_1500B), 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_aesni_gcm_testsuite = { - .suite_name = "Crypto Device AESNI GCM Unit Test Suite", - .setup = testsuite_setup, - .teardown = testsuite_teardown, - .unit_test_cases = { - /** AES GCM Authenticated Encryption */ + 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, @@ -11609,6 +12358,8 @@ static struct unit_test_suite cryptodev_aesni_gcm_testsuite = { 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), /** AES GCM Authenticated Decryption */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -11625,6 +12376,8 @@ static struct unit_test_suite cryptodev_aesni_gcm_testsuite = { 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), /** AES GCM Authenticated Encryption 192 bits key */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -11690,154 +12443,12 @@ static struct unit_test_suite cryptodev_aesni_gcm_testsuite = { 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), - - /** 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_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), - - /** Negative tests */ - TEST_CASE_ST(ut_setup, ut_teardown, - authentication_verify_AES128_GMAC_fail_data_corrupt), - TEST_CASE_ST(ut_setup, ut_teardown, - authentication_verify_AES128_GMAC_fail_tag_corrupt), - /** 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), - - /** Scatter-Gather */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg), - - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; - -static struct unit_test_suite cryptodev_sw_kasumi_testsuite = { - .suite_name = "Crypto Device SW KASUMI Unit Test Suite", - .setup = testsuite_setup, - .teardown = testsuite_teardown, - .unit_test_cases = { - /** 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_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_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_decryption_test_case_1_oop), - - /** 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), - 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), - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; -static struct unit_test_suite cryptodev_sw_snow3g_testsuite = { - .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite", - .setup = testsuite_setup, - .teardown = testsuite_teardown, - .unit_test_cases = { /** SNOW 3G encrypt only (UEA2) */ TEST_CASE_ST(ut_setup, ut_teardown, test_snow3g_encryption_test_case_1), @@ -11849,8 +12460,6 @@ static struct unit_test_suite cryptodev_sw_snow3g_testsuite = { 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_auth_cipher_with_digest_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, test_snow3g_encryption_test_case_1_oop), @@ -11859,9 +12468,6 @@ static struct unit_test_suite cryptodev_sw_snow3g_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_snow3g_decryption_test_case_1_oop), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_1_offset_oop), - /** SNOW 3G decrypt only (UEA2) */ TEST_CASE_ST(ut_setup, ut_teardown, test_snow3g_decryption_test_case_1), @@ -11873,86 +12479,20 @@ static struct unit_test_suite cryptodev_sw_snow3g_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), - - /** 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_snow3g_hash_generate_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_test_case_3_oop_sgl), + test_snow3g_hash_verify_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_part_digest_enc_sgl), + test_snow3g_hash_verify_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl), - - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; + test_snow3g_hash_verify_test_case_3), -static struct unit_test_suite cryptodev_sw_zuc_testsuite = { - .suite_name = "Crypto Device SW ZUC Unit Test Suite", - .setup = testsuite_setup, - .teardown = testsuite_teardown, - .unit_test_cases = { /** ZUC encrypt only (EEA3) */ TEST_CASE_ST(ut_setup, ut_teardown, test_zuc_encryption_test_case_1), @@ -11964,67 +12504,73 @@ static struct unit_test_suite cryptodev_sw_zuc_testsuite = { test_zuc_encryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, test_zuc_encryption_test_case_5), + + /** ZUC authenticate (EIA3) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_1), + test_zuc_hash_generate_test_case_6), TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_2), + test_zuc_hash_generate_test_case_7), TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_3), + test_zuc_hash_generate_test_case_8), + + /** Negative tests */ TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_4), + test_AES_GCM_auth_encryption_fail_iv_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_5), + test_AES_GCM_auth_encryption_fail_in_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_encryption_test_case_6_sgl), - 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_fail_out_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_device_configure_invalid_dev_id), + test_AES_GCM_auth_encryption_fail_aad_len_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_multi_session), - + test_AES_GCM_auth_encryption_fail_aad_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_fail_tag_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_iv_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_in_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_out_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_aad_len_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_aad_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_tag_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_HMAC_SHA1_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_caam_jr_all), + authentication_verify_HMAC_SHA1_fail_tag_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_caam_jr_all), + auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_caam_jr_all), + auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), + + /* ESN Testcase */ TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_caam_jr_all), + auth_encrypt_AES128CBC_HMAC_SHA1_esn_check), TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_caam_jr_all), + auth_decrypt_AES128CBC_HMAC_SHA1_esn_check), TEST_CASES_END() /**< NULL terminate unit test array */ } }; -static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { - .suite_name = "Crypto DPAA_SEC Unit Test Suite", +static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { + .suite_name = "Crypto DPAA2_SEC 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_multi_session), - - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_dpaa_sec_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_dpaa_sec_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_dpaa_sec_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_dpaa_sec_all), + test_device_configure_invalid_dev_id), TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_dpaa_sec_all), + 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), #ifdef RTE_LIBRTE_SECURITY TEST_CASE_ST(ut_setup, ut_teardown, @@ -12049,6 +12595,14 @@ static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { test_PDCP_PROTO_SGL_oop_128B_32B), #endif /** 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, @@ -12063,6 +12617,8 @@ static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { 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), /** AES GCM Authenticated Decryption */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -12079,6 +12635,40 @@ static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { 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), + + /** 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, @@ -12118,17 +12708,105 @@ static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_authenticated_decryption_oop_test_case_1), - /** Scatter-Gather */ + /** SNOW 3G encrypt only (UEA2) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_in_place_1500B), + test_snow3g_encryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B), + test_snow3g_encryption_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg), + test_snow3g_encryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B), + 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_decryption_test_case_1_oop), + + /** 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_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), + 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), + + /** 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), + + /** ZUC authenticate (EIA3) */ + 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), + + /** 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), /** Negative tests */ + 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_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_fail_tag_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_iv_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_in_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_out_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_aad_len_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_aad_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_tag_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, authentication_verify_HMAC_SHA1_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, @@ -12138,53 +12816,101 @@ static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), + /* 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), + TEST_CASES_END() /**< NULL terminate unit test array */ } }; -static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { - .suite_name = "Crypto DPAA2_SEC Unit Test Suite", +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_device_configure_invalid_dev_id), + auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_multi_session), + 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_AES_chain_dpaa2_sec_all), + test_multi_session_random_usage), + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all), + + /** Negative tests */ TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_dpaa2_sec_all), + authentication_verify_HMAC_SHA1_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_dpaa2_sec_all), + authentication_verify_HMAC_SHA1_fail_tag_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_dpaa2_sec_all), + auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_dpaa2_sec_all), + auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), -#ifdef RTE_LIBRTE_SECURITY - TEST_CASE_ST(ut_setup, ut_teardown, - test_PDCP_PROTO_cplane_encap_all), + 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_PDCP_PROTO_cplane_decap_all), + 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, - test_PDCP_PROTO_uplane_encap_all), - + authentication_verify_HMAC_SHA1_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_PDCP_PROTO_uplane_decap_all), + 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_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_CASE_ST(ut_setup, ut_teardown, - test_PDCP_PROTO_SGL_in_place_32B), - TEST_CASE_ST(ut_setup, ut_teardown, - test_PDCP_PROTO_SGL_oop_32B_128B), - TEST_CASE_ST(ut_setup, ut_teardown, - test_PDCP_PROTO_SGL_oop_32B_40B), - TEST_CASE_ST(ut_setup, ut_teardown, - test_PDCP_PROTO_SGL_oop_128B_32B), -#endif /** AES GCM Authenticated Encryption */ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_authenticated_encryption_test_case_1), @@ -12216,86 +12942,19 @@ static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { test_AES_GCM_authenticated_decryption_test_case_6), TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_authenticated_decryption_test_case_7), - - /** 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), - - /** Out of place tests */ + /** AES GMAC Authentication */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_oop_test_case_1), + test_AES_GMAC_authentication_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_oop_test_case_1), - - /** Scatter-Gather */ + test_AES_GMAC_authentication_verify_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_in_place_1500B), + test_AES_GMAC_authentication_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B), + test_AES_GMAC_authentication_verify_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg), + test_AES_GMAC_authentication_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B), + test_AES_GMAC_authentication_verify_test_case_3), /** SNOW 3G encrypt only (UEA2) */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -12352,147 +13011,127 @@ static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { test_zuc_encryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, test_zuc_encryption_test_case_5), - - /** ZUC authenticate (EIA3) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_6), + test_zuc_hash_generate_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_7), + test_zuc_hash_generate_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_8), + 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_encryption_test_case_6_sgl), - /** 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_2), TEST_CASE_ST(ut_setup, ut_teardown, - auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), + test_kasumi_encryption_test_case_3), 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_null_testsuite = { - .suite_name = "Crypto Device NULL Unit Test Suite", - .setup = testsuite_setup, - .teardown = testsuite_teardown, - .unit_test_cases = { + test_kasumi_encryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_null_invalid_operation), + test_kasumi_encryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_1_sgl), TEST_CASE_ST(ut_setup, ut_teardown, - test_null_burst_operation), + test_kasumi_encryption_test_case_1_oop_sgl), + /** KASUMI decrypt only (UEA1) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_null_all), + test_kasumi_decryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_null_all), + test_kasumi_decryption_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_null_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_armv8_all), - - /** Negative tests */ + test_kasumi_decryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), + test_kasumi_decryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), - - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; + test_kasumi_decryption_test_case_5), -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_multi_session_random_usage), + test_kasumi_encryption_test_case_1_oop), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_mrvl_all), + test_kasumi_decryption_test_case_1_oop), + + /** KASUMI hash only (UIA1) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_mrvl_all), + test_kasumi_hash_generate_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_mrvl_all), + test_kasumi_hash_generate_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_mrvl_all), + test_kasumi_hash_generate_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_mrvl_all), - - /** Negative tests */ + test_kasumi_hash_generate_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - authentication_verify_HMAC_SHA1_fail_data_corrupt), + test_kasumi_hash_generate_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - authentication_verify_HMAC_SHA1_fail_tag_corrupt), + test_kasumi_hash_generate_test_case_6), TEST_CASE_ST(ut_setup, ut_teardown, - auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), + test_kasumi_hash_verify_test_case_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_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_kasumi_hash_verify_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_multi_session_random_usage), + 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_AES_chain_ccp_all), + test_kasumi_hash_verify_test_case_5), + + /** NULL tests */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_ccp_all), + test_null_cipher_only_operation), TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_ccp_all), + test_null_auth_only_operation), TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_ccp_all), + test_null_cipher_auth_operation), TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_ccp_all), + test_null_auth_cipher_operation), /** 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, + authentication_verify_AES128_GMAC_fail_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_AES128_GMAC_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_octeontx_testsuite = { - .suite_name = "Crypto Device OCTEONTX Unit Test Suite", +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_AES_chain_octeontx_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_octeontx_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_octeontx_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_octeontx_all), + test_device_configure_invalid_dev_id), TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_octeontx_all), + test_device_configure_invalid_queue_pair_ids), + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_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), /** AES GCM Authenticated Encryption */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -12703,7 +13342,7 @@ test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/) return TEST_SKIPPED; } - return unit_test_suite_runner(&cryptodev_qat_testsuite); + return unit_test_suite_runner(&cryptodev_testsuite); } static int @@ -12735,7 +13374,7 @@ test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/) return TEST_SKIPPED; } - return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite); + return unit_test_suite_runner(&cryptodev_testsuite); } static int @@ -12751,7 +13390,7 @@ test_cryptodev_openssl(void) return TEST_SKIPPED; } - return unit_test_suite_runner(&cryptodev_openssl_testsuite); + return unit_test_suite_runner(&cryptodev_testsuite); } static int @@ -12767,7 +13406,30 @@ test_cryptodev_aesni_gcm(void) return TEST_SKIPPED; } - return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite); + return unit_test_suite_runner(&cryptodev_testsuite); +} + +static int +test_cryptodev_cpu_aesni_gcm(void) +{ + int32_t rc; + enum rte_security_session_action_type at; + + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled " + "in config file to run this testsuite.\n"); + return TEST_SKIPPED; + } + + at = gbl_action_type; + gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO; + rc = unit_test_suite_runner(&cryptodev_testsuite); + gbl_action_type = at; + return rc; } static int @@ -12783,7 +13445,7 @@ test_cryptodev_null(void) return TEST_SKIPPED; } - return unit_test_suite_runner(&cryptodev_null_testsuite); + return unit_test_suite_runner(&cryptodev_testsuite); } static int @@ -12799,7 +13461,7 @@ test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/) return TEST_SKIPPED; } - return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite); + return unit_test_suite_runner(&cryptodev_testsuite); } static int @@ -12815,7 +13477,7 @@ test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/) return TEST_SKIPPED; } - return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite); + return unit_test_suite_runner(&cryptodev_testsuite); } static int @@ -12831,7 +13493,7 @@ test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/) return TEST_SKIPPED; } - return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite); + return unit_test_suite_runner(&cryptodev_testsuite); } static int @@ -12957,6 +13619,21 @@ test_cryptodev_octeontx(void) return unit_test_suite_runner(&cryptodev_octeontx_testsuite); } +static int +test_cryptodev_octeontx2(void) +{ + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)); + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "OCTEON TX2 PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_OCTEONTX2_CRYPTO is " + "enabled in config file to run this " + "testsuite.\n"); + return TEST_FAILED; + } + return unit_test_suite_runner(&cryptodev_octeontx2_testsuite); +} + static int test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/) { @@ -12973,10 +13650,28 @@ test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/) return unit_test_suite_runner(&cryptodev_caam_jr_testsuite); } +static int +test_cryptodev_nitrox(void) +{ + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_NITROX_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "NITROX PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_NITROX is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } + + return unit_test_suite_runner(&cryptodev_nitrox_testsuite); +} + REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat); REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb); REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl); REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm); +REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest, + test_cryptodev_cpu_aesni_gcm); REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null); REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g); REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi); @@ -12988,4 +13683,6 @@ REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec); REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp); REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio); REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx); +REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2); REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr); +REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);