X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_cryptodev.c;h=cdb840879c4fc7087f243767ae71f4715705c21a;hb=27ea35b743aa3c735d04848b5c795ae0b8cd311b;hp=fa044cb717f0c6b7b5078876f47c3aeaa0333660;hpb=f5862ae99e058c0cee36a08dfd51f8a3b766999a;p=dpdk.git diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index fa044cb717..cdb840879c 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 @@ -52,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; @@ -139,9 +142,99 @@ ceil_byte_length(uint32_t num_bits) return (num_bits >> 3); } +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 void +process_cpu_crypt_auth_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 = (void **)&sop->aead.aad.data; + symvec.digest = (void **)&sop->auth.digest.data; + symvec.status = &st; + symvec.num = 1; + + ofs.raw = 0; + ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset; + ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) - + (sop->cipher.data.offset + sop->cipher.data.length); + + 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) { RTE_LOG(ERR, USER1, "Error sending packet for encryption\n"); return NULL; @@ -674,6 +767,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]); @@ -745,6 +845,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]); @@ -1353,6 +1458,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); @@ -1422,8 +1540,14 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void) sym_op->cipher.data.length = QUOTE_512_BYTES; /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_crypt_auth_op(ts_params->valid_devs[0], + ut_params->op); + else + TEST_ASSERT_NOT_NULL( + process_crypto_request(ts_params->valid_devs[0], + ut_params->op), + "failed to process sym crypto op"); TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, "crypto op processing failed"); @@ -1573,8 +1697,14 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, sym_op->cipher.data.length = QUOTE_512_BYTES; /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_crypt_auth_op(ts_params->valid_devs[0], + ut_params->op); + else + TEST_ASSERT_NOT_NULL( + process_crypto_request(ts_params->valid_devs[0], + ut_params->op), + "failed to process sym crypto op"); TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, "crypto op processing failed"); @@ -1596,7 +1726,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; @@ -1605,9 +1735,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"); @@ -1615,1645 +1747,1656 @@ 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 */ + /* 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), + iv, iv_len); + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = cipher_offset; + return 0; +} static int -test_AES_chain_openssl_all(void) +create_wireless_algo_cipher_operation_oop(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; - - 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"); + struct crypto_unittest_params *ut_params = &unittest_params; - return TEST_SUCCESS; -} + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate pktmbuf offload"); -static int -test_AES_cipheronly_openssl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - 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); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; + sym_op->m_dst = ut_params->obuf; - return TEST_SUCCESS; + /* iv */ + rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), + iv, iv_len); + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = cipher_offset; + return 0; } static int -test_AES_chain_ccp_all(void) +create_wireless_algo_cipher_auth_session(uint8_t dev_id, + enum rte_crypto_cipher_operation cipher_op, + enum rte_crypto_auth_operation auth_op, + enum rte_crypto_auth_algorithm auth_algo, + enum rte_crypto_cipher_algorithm cipher_algo, + const uint8_t *key, uint8_t key_len, + uint8_t auth_iv_len, uint8_t auth_len, + uint8_t cipher_iv_len) + { - struct crypto_testsuite_params *ts_params = &testsuite_params; + uint8_t cipher_auth_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_CCP_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; - return TEST_SUCCESS; -} + memcpy(cipher_auth_key, key, key_len); -static int -test_AES_cipheronly_ccp_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* Setup Authentication Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; - 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); + ut_params->auth_xform.auth.op = auth_op; + ut_params->auth_xform.auth.algo = auth_algo; + ut_params->auth_xform.auth.key.length = key_len; + /* Hash key = cipher key */ + ut_params->auth_xform.auth.key.data = cipher_auth_key; + ut_params->auth_xform.auth.digest_length = auth_len; + /* Auth IV will be after cipher IV */ + ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len; + ut_params->auth_xform.auth.iv.length = auth_iv_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 = &ut_params->auth_xform; - return TEST_SUCCESS; -} + ut_params->cipher_xform.cipher.algo = cipher_algo; + ut_params->cipher_xform.cipher.op = cipher_op; + ut_params->cipher_xform.cipher.key.data = cipher_auth_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 = cipher_iv_len; -static int -test_AES_chain_qat_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_QAT_SYM_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); + /* 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"); - TEST_ASSERT_EQUAL(status, 0, "Test 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; - return TEST_SUCCESS; + TEST_ASSERT_EQUAL(status, 0, "session init failed"); + return 0; } static int -test_AES_cipheronly_qat_all(void) +create_wireless_cipher_auth_session(uint8_t dev_id, + enum rte_crypto_cipher_operation cipher_op, + enum rte_crypto_auth_operation auth_op, + enum rte_crypto_auth_algorithm auth_algo, + enum rte_crypto_cipher_algorithm cipher_algo, + const struct wireless_test_data *tdata) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + const uint8_t key_len = tdata->key.len; + uint8_t cipher_auth_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_QAT_SYM_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + const uint8_t *key = tdata->key.data; + const uint8_t auth_len = tdata->digest.len; + uint8_t cipher_iv_len = tdata->cipher_iv.len; + uint8_t auth_iv_len = tdata->auth_iv.len; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + memcpy(cipher_auth_key, key, key_len); - return TEST_SUCCESS; -} + /* Setup Authentication Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; -static int -test_AES_cipheronly_virtio_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + ut_params->auth_xform.auth.op = auth_op; + ut_params->auth_xform.auth.algo = auth_algo; + ut_params->auth_xform.auth.key.length = key_len; + /* Hash key = cipher key */ + ut_params->auth_xform.auth.key.data = cipher_auth_key; + ut_params->auth_xform.auth.digest_length = auth_len; + /* Auth IV will be after cipher IV */ + ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len; + ut_params->auth_xform.auth.iv.length = auth_iv_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_VIRTIO_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = &ut_params->auth_xform; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + ut_params->cipher_xform.cipher.algo = cipher_algo; + ut_params->cipher_xform.cipher.op = cipher_op; + ut_params->cipher_xform.cipher.key.data = cipher_auth_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 = cipher_iv_len; - return TEST_SUCCESS; -} -static int -test_AES_chain_caam_jr_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_CAAM_JR_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->cipher_xform, + ts_params->session_priv_mpool); - return TEST_SUCCESS; + TEST_ASSERT_EQUAL(status, 0, "session init failed"); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + return 0; } static int -test_AES_cipheronly_caam_jr_all(void) +create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id, + const struct wireless_test_data *tdata) { - 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; + return create_wireless_cipher_auth_session(dev_id, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3, + RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata); } static int -test_authonly_caam_jr_all(void) +create_wireless_algo_auth_cipher_session(uint8_t dev_id, + enum rte_crypto_cipher_operation cipher_op, + enum rte_crypto_auth_operation auth_op, + enum rte_crypto_auth_algorithm auth_algo, + enum rte_crypto_cipher_algorithm cipher_algo, + const uint8_t *key, const uint8_t key_len, + uint8_t auth_iv_len, uint8_t auth_len, + uint8_t cipher_iv_len) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + uint8_t auth_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_CAAM_JR_PMD)), - BLKCIPHER_AUTHONLY_TYPE); + memcpy(auth_cipher_key, key, key_len); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* Setup Authentication Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.auth.op = auth_op; + ut_params->auth_xform.next = &ut_params->cipher_xform; + ut_params->auth_xform.auth.algo = auth_algo; + ut_params->auth_xform.auth.key.length = key_len; + ut_params->auth_xform.auth.key.data = auth_cipher_key; + ut_params->auth_xform.auth.digest_length = auth_len; + /* Auth IV will be after cipher IV */ + ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len; + ut_params->auth_xform.auth.iv.length = auth_iv_len; - return TEST_SUCCESS; -} + /* 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 = cipher_algo; + ut_params->cipher_xform.cipher.op = cipher_op; + ut_params->cipher_xform.cipher.key.data = auth_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 = cipher_iv_len; + debug_hexdump(stdout, "key:", key, key_len); -static int -test_AES_chain_dpaa_sec_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* 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 = 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; -} + 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); -static int -test_AES_cipheronly_dpaa_sec_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + } else + status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->auth_xform, + ts_params->session_priv_mpool); - 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); + if (status == -ENOTSUP) + return status; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + TEST_ASSERT_EQUAL(status, 0, "session init failed"); - return TEST_SUCCESS; + return 0; } static int -test_authonly_dpaa_sec_all(void) +create_wireless_algo_hash_operation(const uint8_t *auth_tag, + unsigned int auth_tag_len, + const uint8_t *iv, unsigned int iv_len, + unsigned int data_pad_len, + enum rte_crypto_auth_operation op, + unsigned int auth_len, unsigned int auth_offset) { 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"); + struct crypto_unittest_params *ut_params = &unittest_params; - return TEST_SUCCESS; -} + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate pktmbuf offload"); -static int -test_AES_chain_dpaa2_sec_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - 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); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - return TEST_SUCCESS; -} + /* iv */ + rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), + iv, iv_len); + /* digest */ + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, auth_tag_len); -static int -test_AES_cipheronly_dpaa2_sec_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + 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 (op == RTE_CRYPTO_AUTH_OP_GENERATE) + memset(sym_op->auth.digest.data, 0, auth_tag_len); + else + rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_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_DPAA2_SEC_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); + debug_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + auth_tag_len); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + sym_op->auth.data.length = auth_len; + sym_op->auth.data.offset = auth_offset; - return TEST_SUCCESS; + return 0; } static int -test_authonly_dpaa2_sec_all(void) +create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata, + enum rte_crypto_auth_operation op) { 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_DPAA2_SEC_PMD)), - BLKCIPHER_AUTHONLY_TYPE); + const uint8_t *auth_tag = tdata->digest.data; + const unsigned int auth_tag_len = tdata->digest.len; + unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len); + unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + const uint8_t *cipher_iv = tdata->cipher_iv.data; + const uint8_t cipher_iv_len = tdata->cipher_iv.len; + const uint8_t *auth_iv = tdata->auth_iv.data; + const uint8_t auth_iv_len = tdata->auth_iv.len; + const unsigned int cipher_len = tdata->validCipherLenInBits.len; + const unsigned int auth_len = tdata->validAuthLenInBits.len; - return TEST_SUCCESS; -} + /* 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); -static int -test_authonly_openssl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - 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); + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* digest */ + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, auth_tag_len); - return TEST_SUCCESS; -} + 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 (op == RTE_CRYPTO_AUTH_OP_GENERATE) + memset(sym_op->auth.digest.data, 0, auth_tag_len); + else + rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); -static int -test_authonly_ccp_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + debug_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + auth_tag_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_CCP_PMD)), - BLKCIPHER_AUTHONLY_TYPE); + /* 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); + rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len); + iv_ptr += cipher_iv_len; + rte_memcpy(iv_ptr, auth_iv, auth_iv_len); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = 0; + sym_op->auth.data.length = auth_len; + sym_op->auth.data.offset = 0; - return TEST_SUCCESS; + return 0; } static int -test_AES_chain_armv8_all(void) +create_zuc_cipher_hash_generate_operation( + const struct wireless_test_data *tdata) { - 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; + return create_wireless_cipher_hash_operation(tdata, + RTE_CRYPTO_AUTH_OP_GENERATE); } static int -test_AES_chain_mrvl_all(void) +create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, + const unsigned auth_tag_len, + const uint8_t *auth_iv, uint8_t auth_iv_len, + unsigned data_pad_len, + enum rte_crypto_auth_operation op, + const uint8_t *cipher_iv, uint8_t cipher_iv_len, + const unsigned cipher_len, const unsigned cipher_offset, + const unsigned auth_len, const unsigned auth_offset) { 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"); + struct crypto_unittest_params *ut_params = &unittest_params; - return TEST_SUCCESS; -} + 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; -static int -test_AES_cipheronly_mrvl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* 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); - 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); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - return TEST_SUCCESS; -} + /* digest */ + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, auth_tag_len); -static int -test_authonly_mrvl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append auth tag"); + ut_params->digest = sym_op->auth.digest.data; - 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); + 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; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + 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); + } - return TEST_SUCCESS; -} + if (op == RTE_CRYPTO_AUTH_OP_GENERATE) + memset(sym_op->auth.digest.data, 0, auth_tag_len); + else + rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); -static int -test_3DES_chain_mrvl_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + debug_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + auth_tag_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_MVSAM_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); + /* 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); + rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len); + iv_ptr += cipher_iv_len; + rte_memcpy(iv_ptr, auth_iv, auth_iv_len); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + 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; + } - return TEST_SUCCESS; + 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 -test_3DES_cipheronly_mrvl_all(void) +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 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_MVSAM_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); + 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; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate pktmbuf offload"); - return TEST_SUCCESS; -} + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); -static int -test_AES_chain_octeontx_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - 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); + /* set crypto operation mbufs */ + sym_op->m_src = ut_params->ibuf; + if (op_mode == OUT_OF_PLACE) + sym_op->m_dst = ut_params->obuf; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* digest */ + if (!do_sgl) { + sym_op->auth.digest.data = rte_pktmbuf_mtod_offset( + (op_mode == IN_PLACE ? + ut_params->ibuf : ut_params->obuf), + uint8_t *, data_pad_len); + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( + (op_mode == IN_PLACE ? + ut_params->ibuf : ut_params->obuf), + data_pad_len); + memset(sym_op->auth.digest.data, 0, auth_tag_len); + } else { + uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3); + struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ? + sym_op->m_src : sym_op->m_dst); + while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) { + remaining_off -= rte_pktmbuf_data_len(sgl_buf); + sgl_buf = sgl_buf->next; + } + sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf, + uint8_t *, remaining_off); + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf, + remaining_off); + memset(sym_op->auth.digest.data, 0, remaining_off); + while (sgl_buf->next != NULL) { + memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *), + 0, rte_pktmbuf_data_len(sgl_buf)); + sgl_buf = sgl_buf->next; + } + } - return TEST_SUCCESS; -} + /* Copy digest for the verification */ + if (verify) + memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); -static int -test_AES_cipheronly_octeontx_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* 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); - 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); + rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len); + iv_ptr += cipher_iv_len; + rte_memcpy(iv_ptr, auth_iv, auth_iv_len); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + 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; + } - return TEST_SUCCESS; + 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 -test_3DES_chain_octeontx_all(void) +test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) { 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_OCTEONTX_SYM_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); + int retval; + unsigned plaintext_pad_len; + unsigned plaintext_len; + uint8_t *plaintext; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* 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; - return TEST_SUCCESS; -} + /* 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; -static int -test_AES_chain_nitrox_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* Create SNOW 3G session */ + retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], + tdata->key.data, tdata->key.len, + tdata->auth_iv.len, tdata->digest.len, + RTE_CRYPTO_AUTH_OP_GENERATE, + RTE_CRYPTO_AUTH_SNOW3G_UIA2); + 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_NITROX_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); + /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - return TEST_SUCCESS; -} + plaintext_len = ceil_byte_length(tdata->plaintext.len); + /* Append data which is padded to a multiple of */ + /* the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, plaintext_len); -static int -test_3DES_cipheronly_octeontx_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* Create SNOW 3G operation */ + retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, + tdata->auth_iv.data, tdata->auth_iv.len, + plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, + tdata->validAuthLenInBits.len, + 0); + 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_OCTEONTX_SYM_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + ut_params->obuf = ut_params->op->sym->m_src; + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + plaintext_pad_len; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ut_params->digest, + tdata->digest.data, + DIGEST_BYTE_LENGTH_SNOW3G_UIA2, + "SNOW 3G Generated auth tag not as expected"); - return TEST_SUCCESS; + return 0; } static int -test_authonly_octeontx_all(void) +test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) { 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); + struct crypto_unittest_params *ut_params = &unittest_params; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + int retval; + unsigned plaintext_pad_len; + unsigned plaintext_len; + uint8_t *plaintext; - return TEST_SUCCESS; -} + /* 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; -static int -test_AES_chain_octeontx2_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* 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; - 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_OCTEONTX2_PMD)), - BLKCIPHER_AES_CHAIN_TYPE); + /* Create SNOW 3G session */ + retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], + tdata->key.data, tdata->key.len, + tdata->auth_iv.len, tdata->digest.len, + RTE_CRYPTO_AUTH_OP_VERIFY, + RTE_CRYPTO_AUTH_SNOW3G_UIA2); + if (retval < 0) + return retval; + /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - return TEST_SUCCESS; -} + plaintext_len = ceil_byte_length(tdata->plaintext.len); + /* Append data which is padded to a multiple of */ + /* the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, plaintext_len); -static int -test_AES_cipheronly_octeontx2_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* Create SNOW 3G operation */ + retval = create_wireless_algo_hash_operation(tdata->digest.data, + tdata->digest.len, + tdata->auth_iv.data, tdata->auth_iv.len, + plaintext_pad_len, + RTE_CRYPTO_AUTH_OP_VERIFY, + tdata->validAuthLenInBits.len, + 0); + 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_OCTEONTX2_PMD)), - BLKCIPHER_AES_CIPHERONLY_TYPE); + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->obuf = ut_params->op->sym->m_src; + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + plaintext_pad_len; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* Validate obuf */ + if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) + return 0; + else + return -1; - return TEST_SUCCESS; + return 0; } static int -test_3DES_chain_octeontx2_all(void) +test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) { 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_OCTEONTX2_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); + int retval; + unsigned plaintext_pad_len; + unsigned plaintext_len; + uint8_t *plaintext; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* 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; - return TEST_SUCCESS; -} + /* Create KASUMI session */ + retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], + tdata->key.data, tdata->key.len, + 0, tdata->digest.len, + RTE_CRYPTO_AUTH_OP_GENERATE, + RTE_CRYPTO_AUTH_KASUMI_F9); + if (retval < 0) + return retval; -static int -test_3DES_cipheronly_octeontx2_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - 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_OCTEONTX2_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + plaintext_len = ceil_byte_length(tdata->plaintext.len); + /* Append data which is padded to a multiple of */ + /* the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, plaintext_len); - return TEST_SUCCESS; -} + /* Create KASUMI operation */ + retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, + NULL, 0, + plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, + tdata->plaintext.len, + 0); + if (retval < 0) + return retval; -static int -test_authonly_octeontx2_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_crypt_auth_op(ts_params->valid_devs[0], + ut_params->op); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); - 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_OCTEONTX2_PMD)), - BLKCIPHER_AUTHONLY_TYPE); + ut_params->obuf = ut_params->op->sym->m_src; + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + plaintext_pad_len; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ut_params->digest, + tdata->digest.data, + DIGEST_BYTE_LENGTH_KASUMI_F9, + "KASUMI Generated auth tag not as expected"); - return TEST_SUCCESS; + return 0; } -/* ***** 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) +test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) { - 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); + int retval; + unsigned plaintext_pad_len; + unsigned plaintext_len; + uint8_t *plaintext; - 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; -} + /* 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; -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; + /* Create KASUMI session */ + retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], + tdata->key.data, tdata->key.len, + 0, tdata->digest.len, + RTE_CRYPTO_AUTH_OP_VERIFY, + RTE_CRYPTO_AUTH_KASUMI_F9); + if (retval < 0) + return retval; + /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - memcpy(cipher_key, key, key_len); + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = NULL; + plaintext_len = ceil_byte_length(tdata->plaintext.len); + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, plaintext_len); - 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; + /* Create KASUMI operation */ + retval = create_wireless_algo_hash_operation(tdata->digest.data, + tdata->digest.len, + NULL, 0, + plaintext_pad_len, + RTE_CRYPTO_AUTH_OP_VERIFY, + tdata->plaintext.len, + 0); + if (retval < 0) + return retval; - debug_hexdump(stdout, "key:", key, key_len); + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->obuf = ut_params->op->sym->m_src; + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + plaintext_pad_len; - /* Create Crypto session */ - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + /* Validate obuf */ + if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) + return 0; + else + return -1; - 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) +test_snow3g_hash_generate_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + return test_snow3g_authentication(&snow3g_hash_test_case_1); +} - /* 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); +static int +test_snow3g_hash_generate_test_case_2(void) +{ + return test_snow3g_authentication(&snow3g_hash_test_case_2); +} - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; +static int +test_snow3g_hash_generate_test_case_3(void) +{ + return test_snow3g_authentication(&snow3g_hash_test_case_3); +} - /* set crypto operation source mbuf */ - sym_op->m_src = ut_params->ibuf; +static int +test_snow3g_hash_generate_test_case_4(void) +{ + return test_snow3g_authentication(&snow3g_hash_test_case_4); +} - /* iv */ - rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), - iv, iv_len); - sym_op->cipher.data.length = cipher_len; - sym_op->cipher.data.offset = cipher_offset; - return 0; +static int +test_snow3g_hash_generate_test_case_5(void) +{ + return test_snow3g_authentication(&snow3g_hash_test_case_5); } static int -create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len, - unsigned int cipher_len, - unsigned int cipher_offset) +test_snow3g_hash_generate_test_case_6(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + return test_snow3g_authentication(&snow3g_hash_test_case_6); +} - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate pktmbuf offload"); +static int +test_snow3g_hash_verify_test_case_1(void) +{ + return test_snow3g_authentication_verify(&snow3g_hash_test_case_1); - /* 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; +static int +test_snow3g_hash_verify_test_case_2(void) +{ + return test_snow3g_authentication_verify(&snow3g_hash_test_case_2); +} - /* set crypto operation source mbuf */ - sym_op->m_src = ut_params->ibuf; - sym_op->m_dst = ut_params->obuf; +static int +test_snow3g_hash_verify_test_case_3(void) +{ + return test_snow3g_authentication_verify(&snow3g_hash_test_case_3); +} - /* iv */ - rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), - iv, iv_len); - sym_op->cipher.data.length = cipher_len; - sym_op->cipher.data.offset = cipher_offset; - return 0; +static int +test_snow3g_hash_verify_test_case_4(void) +{ + return test_snow3g_authentication_verify(&snow3g_hash_test_case_4); } static int -create_wireless_algo_cipher_auth_session(uint8_t dev_id, - enum rte_crypto_cipher_operation cipher_op, - enum rte_crypto_auth_operation auth_op, - enum rte_crypto_auth_algorithm auth_algo, - enum rte_crypto_cipher_algorithm cipher_algo, - const uint8_t *key, uint8_t key_len, - uint8_t auth_iv_len, uint8_t auth_len, - uint8_t cipher_iv_len) +test_snow3g_hash_verify_test_case_5(void) +{ + return test_snow3g_authentication_verify(&snow3g_hash_test_case_5); +} +static int +test_snow3g_hash_verify_test_case_6(void) { - uint8_t cipher_auth_key[key_len]; - int status; + return test_snow3g_authentication_verify(&snow3g_hash_test_case_6); +} - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; +static int +test_kasumi_hash_generate_test_case_1(void) +{ + return test_kasumi_authentication(&kasumi_hash_test_case_1); +} - memcpy(cipher_auth_key, key, key_len); +static int +test_kasumi_hash_generate_test_case_2(void) +{ + return test_kasumi_authentication(&kasumi_hash_test_case_2); +} - /* Setup Authentication Parameters */ - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = NULL; +static int +test_kasumi_hash_generate_test_case_3(void) +{ + return test_kasumi_authentication(&kasumi_hash_test_case_3); +} - ut_params->auth_xform.auth.op = auth_op; - ut_params->auth_xform.auth.algo = auth_algo; - ut_params->auth_xform.auth.key.length = key_len; - /* Hash key = cipher key */ - ut_params->auth_xform.auth.key.data = cipher_auth_key; - ut_params->auth_xform.auth.digest_length = auth_len; - /* Auth IV will be after cipher IV */ - ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len; - ut_params->auth_xform.auth.iv.length = auth_iv_len; +static int +test_kasumi_hash_generate_test_case_4(void) +{ + return test_kasumi_authentication(&kasumi_hash_test_case_4); +} - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = &ut_params->auth_xform; +static int +test_kasumi_hash_generate_test_case_5(void) +{ + return test_kasumi_authentication(&kasumi_hash_test_case_5); +} - ut_params->cipher_xform.cipher.algo = cipher_algo; - ut_params->cipher_xform.cipher.op = cipher_op; - ut_params->cipher_xform.cipher.key.data = cipher_auth_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 = cipher_iv_len; +static int +test_kasumi_hash_generate_test_case_6(void) +{ + return test_kasumi_authentication(&kasumi_hash_test_case_6); +} - debug_hexdump(stdout, "key:", key, key_len); +static int +test_kasumi_hash_verify_test_case_1(void) +{ + return test_kasumi_authentication_verify(&kasumi_hash_test_case_1); +} - /* 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"); +static int +test_kasumi_hash_verify_test_case_2(void) +{ + return test_kasumi_authentication_verify(&kasumi_hash_test_case_2); +} - 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; +static int +test_kasumi_hash_verify_test_case_3(void) +{ + return test_kasumi_authentication_verify(&kasumi_hash_test_case_3); +} - TEST_ASSERT_EQUAL(status, 0, "session init failed"); - return 0; +static int +test_kasumi_hash_verify_test_case_4(void) +{ + return test_kasumi_authentication_verify(&kasumi_hash_test_case_4); } static int -create_wireless_cipher_auth_session(uint8_t dev_id, - enum rte_crypto_cipher_operation cipher_op, - enum rte_crypto_auth_operation auth_op, - enum rte_crypto_auth_algorithm auth_algo, - enum rte_crypto_cipher_algorithm cipher_algo, - const struct wireless_test_data *tdata) +test_kasumi_hash_verify_test_case_5(void) { - const uint8_t key_len = tdata->key.len; - uint8_t cipher_auth_key[key_len]; - int status; + return test_kasumi_authentication_verify(&kasumi_hash_test_case_5); +} +static int +test_kasumi_encryption(const struct kasumi_test_data *tdata) +{ struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - const uint8_t *key = tdata->key.data; - const uint8_t auth_len = tdata->digest.len; - uint8_t cipher_iv_len = tdata->cipher_iv.len; - uint8_t auth_iv_len = tdata->auth_iv.len; - memcpy(cipher_auth_key, key, key_len); + int retval; + uint8_t *plaintext, *ciphertext; + unsigned plaintext_pad_len; + unsigned plaintext_len; - /* Setup Authentication Parameters */ - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = NULL; + /* 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; - ut_params->auth_xform.auth.op = auth_op; - ut_params->auth_xform.auth.algo = auth_algo; - ut_params->auth_xform.auth.key.length = key_len; - /* Hash key = cipher key */ - ut_params->auth_xform.auth.key.data = cipher_auth_key; - ut_params->auth_xform.auth.digest_length = auth_len; - /* Auth IV will be after cipher IV */ - ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len; - ut_params->auth_xform.auth.iv.length = auth_iv_len; + /* Create KASUMI session */ + retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_CIPHER_KASUMI_F8, + tdata->key.data, tdata->key.len, + tdata->cipher_iv.len); + if (retval < 0) + return retval; - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = &ut_params->auth_xform; + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - ut_params->cipher_xform.cipher.algo = cipher_algo; - ut_params->cipher_xform.cipher.op = cipher_op; - ut_params->cipher_xform.cipher.key.data = cipher_auth_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 = cipher_iv_len; + /* Clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + plaintext_len = ceil_byte_length(tdata->plaintext.len); + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, plaintext_len); - debug_hexdump(stdout, "key:", key, key_len); + debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); - /* Create Crypto session*/ - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + /* Create KASUMI operation */ + retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, + tdata->cipher_iv.len, + RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), + tdata->validCipherOffsetInBits.len); + if (retval < 0) + return retval; - status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, - &ut_params->cipher_xform, - ts_params->session_priv_mpool); + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - TEST_ASSERT_EQUAL(status, 0, "session init failed"); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); - return 0; -} + ut_params->obuf = ut_params->op->sym->m_dst; + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); + else + ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3); -static int -create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id, - const struct wireless_test_data *tdata) -{ - return create_wireless_cipher_auth_session(dev_id, - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3, - RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata); + debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); + + const uint8_t *reference_ciphertext = tdata->ciphertext.data + + (tdata->validCipherOffsetInBits.len >> 3); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + reference_ciphertext, + tdata->validCipherLenInBits.len, + "KASUMI Ciphertext data not as expected"); + return 0; } static int -create_wireless_algo_auth_cipher_session(uint8_t dev_id, - enum rte_crypto_cipher_operation cipher_op, - enum rte_crypto_auth_operation auth_op, - enum rte_crypto_auth_algorithm auth_algo, - enum rte_crypto_cipher_algorithm cipher_algo, - const uint8_t *key, const uint8_t key_len, - uint8_t auth_iv_len, uint8_t auth_len, - uint8_t cipher_iv_len) +test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) { - uint8_t auth_cipher_key[key_len]; - int status; struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - memcpy(auth_cipher_key, key, key_len); + int retval; - /* Setup Authentication Parameters */ - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.auth.op = auth_op; - ut_params->auth_xform.next = &ut_params->cipher_xform; - ut_params->auth_xform.auth.algo = auth_algo; - ut_params->auth_xform.auth.key.length = key_len; - ut_params->auth_xform.auth.key.data = auth_cipher_key; - ut_params->auth_xform.auth.digest_length = auth_len; - /* Auth IV will be after cipher IV */ - ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len; - ut_params->auth_xform.auth.iv.length = auth_iv_len; + unsigned int plaintext_pad_len; + unsigned int plaintext_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 = cipher_algo; - ut_params->cipher_xform.cipher.op = cipher_op; - ut_params->cipher_xform.cipher.key.data = auth_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 = cipher_iv_len; + uint8_t buffer[10000]; + const uint8_t *ciphertext; - debug_hexdump(stdout, "key:", key, key_len); + struct rte_cryptodev_info dev_info; - /* 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"); + /* 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; - 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); + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - } else - status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, - &ut_params->auth_xform, - ts_params->session_priv_mpool); + uint64_t feat_flags = dev_info.feature_flags; - if (status == -ENOTSUP) - return status; + if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { + printf("Device doesn't support in-place scatter-gather. " + "Test Skipped.\n"); + return -ENOTSUP; + } - TEST_ASSERT_EQUAL(status, 0, "session init failed"); + /* Create KASUMI session */ + retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_CIPHER_KASUMI_F8, + tdata->key.data, tdata->key.len, + tdata->cipher_iv.len); + if (retval < 0) + return retval; - return 0; -} + plaintext_len = ceil_byte_length(tdata->plaintext.len); -static int -create_wireless_algo_hash_operation(const uint8_t *auth_tag, - unsigned int auth_tag_len, - const uint8_t *iv, unsigned int iv_len, - unsigned int data_pad_len, - enum rte_crypto_auth_operation op, - unsigned int auth_len, unsigned int auth_offset) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); - /* 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"); + ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, + plaintext_pad_len, 10, 0); - /* Set crypto operation data parameters */ - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + /* Create KASUMI operation */ + retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, + tdata->cipher_iv.len, + RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), + tdata->validCipherOffsetInBits.len); + if (retval < 0) + return retval; - /* set crypto operation source mbuf */ - sym_op->m_src = ut_params->ibuf; + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - /* iv */ - rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), - iv, iv_len); - /* digest */ - sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( - ut_params->ibuf, auth_tag_len); + ut_params->obuf = ut_params->op->sym->m_dst; - 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 (op == RTE_CRYPTO_AUTH_OP_GENERATE) - memset(sym_op->auth.digest.data, 0, auth_tag_len); + if (ut_params->obuf) + ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, + plaintext_len, buffer); else - rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); - - debug_hexdump(stdout, "digest:", - sym_op->auth.digest.data, - auth_tag_len); + ciphertext = rte_pktmbuf_read(ut_params->ibuf, + tdata->validCipherOffsetInBits.len >> 3, + plaintext_len, buffer); - sym_op->auth.data.length = auth_len; - sym_op->auth.data.offset = auth_offset; + /* Validate obuf */ + debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); + const uint8_t *reference_ciphertext = tdata->ciphertext.data + + (tdata->validCipherOffsetInBits.len >> 3); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + reference_ciphertext, + tdata->validCipherLenInBits.len, + "KASUMI Ciphertext data not as expected"); return 0; } static int -create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata, - enum rte_crypto_auth_operation op) +test_kasumi_encryption_oop(const struct kasumi_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - const uint8_t *auth_tag = tdata->digest.data; - const unsigned int auth_tag_len = tdata->digest.len; - unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len); - unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); + int retval; + uint8_t *plaintext, *ciphertext; + unsigned plaintext_pad_len; + unsigned plaintext_len; - const uint8_t *cipher_iv = tdata->cipher_iv.data; - const uint8_t cipher_iv_len = tdata->cipher_iv.len; - const uint8_t *auth_iv = tdata->auth_iv.data; - const uint8_t auth_iv_len = tdata->auth_iv.len; - const unsigned int cipher_len = tdata->validCipherLenInBits.len; - const unsigned int auth_len = tdata->validAuthLenInBits.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; - /* 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); + /* Create KASUMI session */ + retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_CIPHER_KASUMI_F8, + tdata->key.data, tdata->key.len, + tdata->cipher_iv.len); + if (retval < 0) + return retval; - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - /* set crypto operation source mbuf */ - sym_op->m_src = ut_params->ibuf; + /* Clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - /* digest */ - sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( - ut_params->ibuf, auth_tag_len); + plaintext_len = ceil_byte_length(tdata->plaintext.len); + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, plaintext_len); - 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 (op == RTE_CRYPTO_AUTH_OP_GENERATE) - memset(sym_op->auth.digest.data, 0, auth_tag_len); - else - rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); + debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); - debug_hexdump(stdout, "digest:", - sym_op->auth.digest.data, - auth_tag_len); + /* Create KASUMI operation */ + retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + tdata->cipher_iv.len, + RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), + tdata->validCipherOffsetInBits.len); + if (retval < 0) + return retval; - /* 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); - rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len); - iv_ptr += cipher_iv_len; - rte_memcpy(iv_ptr, auth_iv, auth_iv_len); + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - sym_op->cipher.data.length = cipher_len; - sym_op->cipher.data.offset = 0; - sym_op->auth.data.length = auth_len; - sym_op->auth.data.offset = 0; + ut_params->obuf = ut_params->op->sym->m_dst; + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); + else + ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3); - return 0; -} + debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); -static int -create_zuc_cipher_hash_generate_operation( - const struct wireless_test_data *tdata) -{ - return create_wireless_cipher_hash_operation(tdata, - RTE_CRYPTO_AUTH_OP_GENERATE); + const uint8_t *reference_ciphertext = tdata->ciphertext.data + + (tdata->validCipherOffsetInBits.len >> 3); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + reference_ciphertext, + tdata->validCipherLenInBits.len, + "KASUMI Ciphertext data not as expected"); + return 0; } static int -create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, - const unsigned auth_tag_len, - const uint8_t *auth_iv, uint8_t auth_iv_len, - unsigned data_pad_len, - enum rte_crypto_auth_operation op, - const uint8_t *cipher_iv, uint8_t cipher_iv_len, - const unsigned cipher_len, const unsigned cipher_offset, - const unsigned auth_len, const unsigned auth_offset) +test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata) { 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; + int retval; + unsigned int plaintext_pad_len; + unsigned int plaintext_len; - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate pktmbuf offload"); - /* Set crypto operation data parameters */ - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + const uint8_t *ciphertext; + uint8_t buffer[2048]; - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + struct rte_cryptodev_info dev_info; - /* set crypto operation source mbuf */ - sym_op->m_src = ut_params->ibuf; + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_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; - /* digest */ - sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( - ut_params->ibuf, auth_tag_len); + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, - "no room to append auth tag"); - ut_params->digest = sym_op->auth.digest.data; + uint64_t feat_flags = dev_info.feature_flags; + 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. " + "Test Skipped.\n"); + return -ENOTSUP; + } - 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; + /* Create KASUMI session */ + retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_CIPHER_KASUMI_F8, + tdata->key.data, tdata->key.len, + tdata->cipher_iv.len); + if (retval < 0) + return retval; - 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); - } + plaintext_len = ceil_byte_length(tdata->plaintext.len); + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); - if (op == RTE_CRYPTO_AUTH_OP_GENERATE) - memset(sym_op->auth.digest.data, 0, auth_tag_len); - else - rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); + ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, + plaintext_pad_len, 10, 0); + ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, + plaintext_pad_len, 3, 0); - debug_hexdump(stdout, "digest:", - sym_op->auth.digest.data, - auth_tag_len); + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); - /* 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); - rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len); - iv_ptr += cipher_iv_len; - rte_memcpy(iv_ptr, auth_iv, auth_iv_len); + /* Create KASUMI operation */ + retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + tdata->cipher_iv.len, + RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), + tdata->validCipherOffsetInBits.len); + if (retval < 0) + return retval; - 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; - } + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - 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; - } + ut_params->obuf = ut_params->op->sym->m_dst; + if (ut_params->obuf) + ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, + plaintext_pad_len, buffer); + else + ciphertext = rte_pktmbuf_read(ut_params->ibuf, + tdata->validCipherOffsetInBits.len >> 3, + plaintext_pad_len, buffer); + const uint8_t *reference_ciphertext = tdata->ciphertext.data + + (tdata->validCipherOffsetInBits.len >> 3); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + reference_ciphertext, + tdata->validCipherLenInBits.len, + "KASUMI Ciphertext data not as expected"); return 0; } + static int -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 verify) +test_kasumi_decryption_oop(const struct kasumi_test_data *tdata) { 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; + int retval; + uint8_t *ciphertext, *plaintext; + unsigned ciphertext_pad_len; + unsigned ciphertext_len; - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate pktmbuf offload"); + /* 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; - /* Set crypto operation data parameters */ - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + /* Create KASUMI session */ + retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_DECRYPT, + RTE_CRYPTO_CIPHER_KASUMI_F8, + tdata->key.data, tdata->key.len, + tdata->cipher_iv.len); + if (retval < 0) + return retval; - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - /* set crypto operation mbufs */ - sym_op->m_src = ut_params->ibuf; - if (op_mode == OUT_OF_PLACE) - sym_op->m_dst = ut_params->obuf; + /* Clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - /* digest */ - if (!do_sgl) { - sym_op->auth.digest.data = rte_pktmbuf_mtod_offset( - (op_mode == IN_PLACE ? - ut_params->ibuf : ut_params->obuf), - uint8_t *, data_pad_len); - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( - (op_mode == IN_PLACE ? - ut_params->ibuf : ut_params->obuf), - data_pad_len); - memset(sym_op->auth.digest.data, 0, auth_tag_len); - } else { - uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3); - struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ? - sym_op->m_src : sym_op->m_dst); - while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) { - remaining_off -= rte_pktmbuf_data_len(sgl_buf); - sgl_buf = sgl_buf->next; - } - sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf, - uint8_t *, remaining_off); - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf, - remaining_off); - memset(sym_op->auth.digest.data, 0, remaining_off); - while (sgl_buf->next != NULL) { - memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *), - 0, rte_pktmbuf_data_len(sgl_buf)); - sgl_buf = sgl_buf->next; - } - } + ciphertext_len = ceil_byte_length(tdata->ciphertext.len); + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8); + ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + ciphertext_pad_len); + rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); + memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); - /* Copy digest for the verification */ - if (verify) - memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); + debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_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); + /* Create KASUMI operation */ + retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + tdata->cipher_iv.len, + RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), + tdata->validCipherOffsetInBits.len); + if (retval < 0) + return retval; - rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len); - iv_ptr += cipher_iv_len; - rte_memcpy(iv_ptr, auth_iv, auth_iv_len); + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - 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; - } + ut_params->obuf = ut_params->op->sym->m_dst; + if (ut_params->obuf) + plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); + else + plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 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; - } + debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); + const uint8_t *reference_plaintext = tdata->plaintext.data + + (tdata->validCipherOffsetInBits.len >> 3); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + plaintext, + reference_plaintext, + tdata->validCipherLenInBits.len, + "KASUMI Plaintext data not as expected"); return 0; } static int -test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) +test_kasumi_decryption(const struct kasumi_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; - unsigned plaintext_pad_len; - unsigned plaintext_len; - uint8_t *plaintext; + uint8_t *ciphertext, *plaintext; + unsigned ciphertext_pad_len; + unsigned ciphertext_len; - /* Create SNOW 3G session */ - retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], - tdata->key.data, tdata->key.len, - tdata->auth_iv.len, tdata->digest.len, - RTE_CRYPTO_AUTH_OP_GENERATE, - RTE_CRYPTO_AUTH_SNOW3G_UIA2); + /* 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, + RTE_CRYPTO_CIPHER_KASUMI_F8, + tdata->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; - /* alloc mbuf and set payload */ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + /* Clear mbuf payload */ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + rte_pktmbuf_tailroom(ut_params->ibuf)); - plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple of */ - /* the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, plaintext_len); + ciphertext_len = ceil_byte_length(tdata->ciphertext.len); + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8); + ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + ciphertext_pad_len); + memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); - /* Create SNOW 3G operation */ - retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, - tdata->auth_iv.data, tdata->auth_iv.len, - plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, - tdata->validAuthLenInBits.len, - 0); + debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); + + /* Create KASUMI operation */ + retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, + tdata->cipher_iv.len, + tdata->ciphertext.len, + tdata->validCipherOffsetInBits.len); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - ut_params->obuf = ut_params->op->sym->m_src; + ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len; - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ut_params->digest, - tdata->digest.data, - DIGEST_BYTE_LENGTH_SNOW3G_UIA2, - "SNOW 3G Generated auth tag not as expected"); + ut_params->obuf = ut_params->op->sym->m_dst; + if (ut_params->obuf) + plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); + else + plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3); + + debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); + const uint8_t *reference_plaintext = tdata->plaintext.data + + (tdata->validCipherOffsetInBits.len >> 3); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + plaintext, + reference_plaintext, + tdata->validCipherLenInBits.len, + "KASUMI Plaintext data not as expected"); return 0; } static int -test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) +test_snow3g_encryption(const struct snow3g_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; + uint8_t *plaintext, *ciphertext; unsigned plaintext_pad_len; unsigned plaintext_len; - uint8_t *plaintext; + + /* 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_hash_session(ts_params->valid_devs[0], - tdata->key.data, tdata->key.len, - tdata->auth_iv.len, tdata->digest.len, - RTE_CRYPTO_AUTH_OP_VERIFY, - RTE_CRYPTO_AUTH_SNOW3G_UIA2); + retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + tdata->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; - /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + /* Clear mbuf payload */ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + rte_pktmbuf_tailroom(ut_params->ibuf)); plaintext_len = ceil_byte_length(tdata->plaintext.len); /* Append data which is padded to a multiple of */ @@ -3263,307 +3406,357 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) plaintext_pad_len); memcpy(plaintext, tdata->plaintext.data, plaintext_len); + debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); + /* Create SNOW 3G operation */ - retval = create_wireless_algo_hash_operation(tdata->digest.data, - tdata->digest.len, - tdata->auth_iv.data, tdata->auth_iv.len, - plaintext_pad_len, - RTE_CRYPTO_AUTH_OP_VERIFY, - tdata->validAuthLenInBits.len, - 0); + retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, + tdata->cipher_iv.len, + tdata->validCipherLenInBits.len, + 0); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ut_params->obuf = ut_params->op->sym->m_src; - ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len; - /* Validate obuf */ - if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) - return 0; + ut_params->obuf = ut_params->op->sym->m_dst; + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else - return -1; + ciphertext = plaintext; + + debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + tdata->ciphertext.data, + tdata->validDataLenInBits.len, + "SNOW 3G Ciphertext data not as expected"); return 0; } + static int -test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) +test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + uint8_t *plaintext, *ciphertext; int retval; unsigned plaintext_pad_len; unsigned plaintext_len; - uint8_t *plaintext; - /* Create KASUMI session */ - retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], - tdata->key.data, tdata->key.len, - 0, tdata->digest.len, - RTE_CRYPTO_AUTH_OP_GENERATE, - RTE_CRYPTO_AUTH_KASUMI_F9); + /* 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, + RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + tdata->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; - /* alloc mbuf and set payload */ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); + TEST_ASSERT_NOT_NULL(ut_params->obuf, + "Failed to allocate output buffer in mempool"); + /* Clear mbuf payload */ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + rte_pktmbuf_tailroom(ut_params->ibuf)); plaintext_len = ceil_byte_length(tdata->plaintext.len); /* Append data which is padded to a multiple of */ /* the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, plaintext_pad_len); + rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); memcpy(plaintext, tdata->plaintext.data, plaintext_len); - /* Create KASUMI operation */ - retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, - NULL, 0, - plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, - tdata->plaintext.len, - 0); - if (retval < 0) - return retval; + debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); + + /* Create SNOW 3G operation */ + retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + tdata->cipher_iv.len, + tdata->validCipherLenInBits.len, + 0); + if (retval < 0) + return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - ut_params->obuf = ut_params->op->sym->m_src; + ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len; - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ut_params->digest, - tdata->digest.data, - DIGEST_BYTE_LENGTH_KASUMI_F9, - "KASUMI Generated auth tag not as expected"); + ut_params->obuf = ut_params->op->sym->m_dst; + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); + else + ciphertext = plaintext; + debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + tdata->ciphertext.data, + tdata->validDataLenInBits.len, + "SNOW 3G Ciphertext data not as expected"); return 0; } static int -test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) +test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; - unsigned plaintext_pad_len; - unsigned plaintext_len; - uint8_t *plaintext; + unsigned int plaintext_pad_len; + unsigned int plaintext_len; + uint8_t buffer[10000]; + const uint8_t *ciphertext; - /* Create KASUMI session */ - retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], - tdata->key.data, tdata->key.len, - 0, tdata->digest.len, - RTE_CRYPTO_AUTH_OP_VERIFY, - RTE_CRYPTO_AUTH_KASUMI_F9); + 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; + + 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. " + "Test Skipped.\n"); + return -ENOTSUP; + } + + /* Create SNOW 3G session */ + retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + tdata->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; - /* alloc mbuf and set payload */ - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple */ - /* of the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, plaintext_len); + /* Append data which is padded to a multiple of */ + /* the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - /* Create KASUMI operation */ - retval = create_wireless_algo_hash_operation(tdata->digest.data, - tdata->digest.len, - NULL, 0, - plaintext_pad_len, - RTE_CRYPTO_AUTH_OP_VERIFY, - tdata->plaintext.len, - 0); + ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, + plaintext_pad_len, 10, 0); + ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, + plaintext_pad_len, 3, 0); + + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); + TEST_ASSERT_NOT_NULL(ut_params->obuf, + "Failed to allocate output buffer in mempool"); + + pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); + + /* Create SNOW 3G operation */ + retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + tdata->cipher_iv.len, + tdata->validCipherLenInBits.len, + 0); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ut_params->obuf = ut_params->op->sym->m_src; - ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len; - /* Validate obuf */ - if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) - return 0; + ut_params->obuf = ut_params->op->sym->m_dst; + if (ut_params->obuf) + ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, + plaintext_len, buffer); else - return -1; + ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, + plaintext_len, buffer); + + debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + tdata->ciphertext.data, + tdata->validDataLenInBits.len, + "SNOW 3G Ciphertext data not as expected"); return 0; } -static int -test_snow3g_hash_generate_test_case_1(void) +/* Shift right a buffer by "offset" bits, "offset" < 8 */ +static void +buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset) { - return test_snow3g_authentication(&snow3g_hash_test_case_1); -} + uint8_t curr_byte, prev_byte; + uint32_t length_in_bytes = ceil_byte_length(length + offset); + uint8_t lower_byte_mask = (1 << offset) - 1; + unsigned i; -static int -test_snow3g_hash_generate_test_case_2(void) -{ - return test_snow3g_authentication(&snow3g_hash_test_case_2); -} + prev_byte = buffer[0]; + buffer[0] >>= offset; -static int -test_snow3g_hash_generate_test_case_3(void) -{ - return test_snow3g_authentication(&snow3g_hash_test_case_3); + for (i = 1; i < length_in_bytes; i++) { + curr_byte = buffer[i]; + buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) | + (curr_byte >> offset); + prev_byte = curr_byte; + } } static int -test_snow3g_hash_generate_test_case_4(void) +test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) { - return test_snow3g_authentication(&snow3g_hash_test_case_4); -} + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + uint8_t *plaintext, *ciphertext; + int retval; + uint32_t plaintext_len; + uint32_t plaintext_pad_len; + uint8_t extra_offset = 4; + uint8_t *expected_ciphertext_shifted; -static int -test_snow3g_hash_generate_test_case_5(void) -{ - return test_snow3g_authentication(&snow3g_hash_test_case_5); -} + /* 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; -static int -test_snow3g_hash_generate_test_case_6(void) -{ - return test_snow3g_authentication(&snow3g_hash_test_case_6); -} + /* 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; -static int -test_snow3g_hash_verify_test_case_1(void) -{ - return test_snow3g_authentication_verify(&snow3g_hash_test_case_1); + /* Create SNOW 3G session */ + retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + tdata->key.data, tdata->key.len, + tdata->cipher_iv.len); + if (retval < 0) + return retval; -} + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); -static int -test_snow3g_hash_verify_test_case_2(void) -{ - return test_snow3g_authentication_verify(&snow3g_hash_test_case_2); -} + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); + TEST_ASSERT_NOT_NULL(ut_params->obuf, + "Failed to allocate output buffer in mempool"); -static int -test_snow3g_hash_verify_test_case_3(void) -{ - return test_snow3g_authentication_verify(&snow3g_hash_test_case_3); -} + /* Clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); -static int -test_snow3g_hash_verify_test_case_4(void) -{ - return test_snow3g_authentication_verify(&snow3g_hash_test_case_4); -} + plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset); + /* + * Append data which is padded to a + * multiple of the algorithms block size + */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); -static int -test_snow3g_hash_verify_test_case_5(void) -{ - return test_snow3g_authentication_verify(&snow3g_hash_test_case_5); -} + plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); -static int -test_snow3g_hash_verify_test_case_6(void) -{ - return test_snow3g_authentication_verify(&snow3g_hash_test_case_6); -} + rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); -static int -test_kasumi_hash_generate_test_case_1(void) -{ - return test_kasumi_authentication(&kasumi_hash_test_case_1); -} + memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3)); + buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset); -static int -test_kasumi_hash_generate_test_case_2(void) -{ - return test_kasumi_authentication(&kasumi_hash_test_case_2); -} - -static int -test_kasumi_hash_generate_test_case_3(void) -{ - return test_kasumi_authentication(&kasumi_hash_test_case_3); -} - -static int -test_kasumi_hash_generate_test_case_4(void) -{ - return test_kasumi_authentication(&kasumi_hash_test_case_4); -} - -static int -test_kasumi_hash_generate_test_case_5(void) -{ - return test_kasumi_authentication(&kasumi_hash_test_case_5); -} +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); +#endif + /* Create SNOW 3G operation */ + retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + tdata->cipher_iv.len, + tdata->validCipherLenInBits.len, + extra_offset); + if (retval < 0) + return retval; -static int -test_kasumi_hash_generate_test_case_6(void) -{ - return test_kasumi_authentication(&kasumi_hash_test_case_6); -} + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); -static int -test_kasumi_hash_verify_test_case_1(void) -{ - return test_kasumi_authentication_verify(&kasumi_hash_test_case_1); -} + ut_params->obuf = ut_params->op->sym->m_dst; + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); + else + ciphertext = plaintext; -static int -test_kasumi_hash_verify_test_case_2(void) -{ - return test_kasumi_authentication_verify(&kasumi_hash_test_case_2); -} +#ifdef RTE_APP_TEST_DEBUG + rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); +#endif -static int -test_kasumi_hash_verify_test_case_3(void) -{ - return test_kasumi_authentication_verify(&kasumi_hash_test_case_3); -} + expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8); -static int -test_kasumi_hash_verify_test_case_4(void) -{ - return test_kasumi_authentication_verify(&kasumi_hash_test_case_4); -} + TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted, + "failed to reserve memory for ciphertext shifted\n"); -static int -test_kasumi_hash_verify_test_case_5(void) -{ - return test_kasumi_authentication_verify(&kasumi_hash_test_case_5); + memcpy(expected_ciphertext_shifted, tdata->ciphertext.data, + ceil_byte_length(tdata->ciphertext.len)); + buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len, + extra_offset); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET( + ciphertext, + expected_ciphertext_shifted, + tdata->validDataLenInBits.len, + extra_offset, + "SNOW 3G Ciphertext data not as expected"); + return 0; } -static int -test_kasumi_encryption(const struct kasumi_test_data *tdata) +static int test_snow3g_decryption(const struct snow3g_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; + uint8_t *plaintext, *ciphertext; - unsigned plaintext_pad_len; - unsigned plaintext_len; + unsigned ciphertext_pad_len; + unsigned ciphertext_len; - /* Create KASUMI session */ + /* 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, - RTE_CRYPTO_CIPHER_KASUMI_F8, + RTE_CRYPTO_CIPHER_OP_DECRYPT, + RTE_CRYPTO_CIPHER_SNOW3G_UEA2, tdata->key.data, tdata->key.len, tdata->cipher_iv.len); if (retval < 0) @@ -3575,750 +3768,1049 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata) memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->ibuf)); - plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple */ - /* of the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, plaintext_len); + ciphertext_len = ceil_byte_length(tdata->ciphertext.len); + /* Append data which is padded to a multiple of */ + /* the algorithms block size */ + ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); + ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + ciphertext_pad_len); + memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); - debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); + debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); - /* Create KASUMI operation */ + /* Create SNOW 3G operation */ retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, - tdata->cipher_iv.len, - RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), - tdata->validCipherOffsetInBits.len); + tdata->cipher_iv.len, + tdata->validCipherLenInBits.len, + tdata->cipher.offset_bits); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); + plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else - ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3); + plaintext = ciphertext; - debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); + debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); - const uint8_t *reference_ciphertext = tdata->ciphertext.data + - (tdata->validCipherOffsetInBits.len >> 3); /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - reference_ciphertext, - tdata->validCipherLenInBits.len, - "KASUMI Ciphertext data not as expected"); + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext, + tdata->plaintext.data, + tdata->validDataLenInBits.len, + "SNOW 3G Plaintext data not as expected"); return 0; } -static int -test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) +static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; - unsigned int plaintext_pad_len; - unsigned int plaintext_len; - - uint8_t buffer[10000]; - const uint8_t *ciphertext; - - struct rte_cryptodev_info dev_info; - - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - - uint64_t feat_flags = dev_info.feature_flags; + uint8_t *plaintext, *ciphertext; + unsigned ciphertext_pad_len; + unsigned ciphertext_len; - if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { - printf("Device doesn't support in-place scatter-gather. " - "Test Skipped.\n"); + /* 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 KASUMI session */ + /* Create SNOW 3G session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_CIPHER_KASUMI_F8, + RTE_CRYPTO_CIPHER_OP_DECRYPT, + RTE_CRYPTO_CIPHER_SNOW3G_UEA2, tdata->key.data, tdata->key.len, tdata->cipher_iv.len); if (retval < 0) return retval; - plaintext_len = ceil_byte_length(tdata->plaintext.len); + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer"); + TEST_ASSERT_NOT_NULL(ut_params->obuf, + "Failed to allocate output buffer"); - /* Append data which is padded to a multiple */ - /* of the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); + /* Clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, - plaintext_pad_len, 10, 0); + memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->obuf)); - pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); + ciphertext_len = ceil_byte_length(tdata->ciphertext.len); + /* Append data which is padded to a multiple of */ + /* the algorithms block size */ + ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); + ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + ciphertext_pad_len); + rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); + memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); - /* Create KASUMI operation */ - retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, - tdata->cipher_iv.len, - RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), - tdata->validCipherOffsetInBits.len); + debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); + + /* Create SNOW 3G operation */ + retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + tdata->cipher_iv.len, + tdata->validCipherLenInBits.len, + 0); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ut_params->obuf = ut_params->op->sym->m_dst; - if (ut_params->obuf) - ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, - plaintext_len, buffer); + plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else - ciphertext = rte_pktmbuf_read(ut_params->ibuf, - tdata->validCipherOffsetInBits.len >> 3, - plaintext_len, buffer); + plaintext = ciphertext; - /* Validate obuf */ - debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); + debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); - const uint8_t *reference_ciphertext = tdata->ciphertext.data + - (tdata->validCipherOffsetInBits.len >> 3); /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - reference_ciphertext, - tdata->validCipherLenInBits.len, - "KASUMI Ciphertext data not as expected"); + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext, + tdata->plaintext.data, + tdata->validDataLenInBits.len, + "SNOW 3G Plaintext data not as expected"); return 0; } static int -test_kasumi_encryption_oop(const struct kasumi_test_data *tdata) +test_zuc_cipher_auth(const struct wireless_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; + uint8_t *plaintext, *ciphertext; - unsigned plaintext_pad_len; - unsigned plaintext_len; + unsigned int plaintext_pad_len; + unsigned int plaintext_len; - /* Create KASUMI session */ - retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_CIPHER_KASUMI_F8, - tdata->key.data, tdata->key.len, - tdata->cipher_iv.len); - if (retval < 0) - return retval; + struct rte_cryptodev_sym_capability_idx cap_idx; + + /* Check if device supports ZUC EEA3 */ + cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3; + + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + 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; + + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create ZUC session */ + retval = create_zuc_cipher_auth_encrypt_generate_session( + ts_params->valid_devs[0], + tdata); + if (retval < 0) + return retval; ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - /* Clear mbuf payload */ + /* clear mbuf payload */ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + rte_pktmbuf_tailroom(ut_params->ibuf)); plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple */ - /* of the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); + /* Append data which is padded to a multiple of */ + /* the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, plaintext_pad_len); - rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); memcpy(plaintext, tdata->plaintext.data, plaintext_len); debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); - /* Create KASUMI operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, - tdata->cipher_iv.len, - RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), - tdata->validCipherOffsetInBits.len); + /* Create ZUC operation */ + retval = create_zuc_cipher_hash_generate_operation(tdata); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - - ut_params->obuf = ut_params->op->sym->m_dst; + ut_params->obuf = ut_params->op->sym->m_src; if (ut_params->obuf) ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else - ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3); + ciphertext = plaintext; debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); - - const uint8_t *reference_ciphertext = tdata->ciphertext.data + - (tdata->validCipherOffsetInBits.len >> 3); /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - reference_ciphertext, - tdata->validCipherLenInBits.len, - "KASUMI Ciphertext data not as expected"); + ciphertext, + tdata->ciphertext.data, + tdata->validDataLenInBits.len, + "ZUC Ciphertext data not as expected"); + + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + plaintext_pad_len; + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ut_params->digest, + tdata->digest.data, + 4, + "ZUC Generated auth tag not as expected"); return 0; } static int -test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata) +test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; - unsigned int plaintext_pad_len; - unsigned int plaintext_len; - - const uint8_t *ciphertext; - uint8_t buffer[2048]; - - struct rte_cryptodev_info dev_info; - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + uint8_t *plaintext, *ciphertext; + unsigned plaintext_pad_len; + unsigned plaintext_len; - uint64_t feat_flags = dev_info.feature_flags; - 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. " - "Test Skipped.\n"); + /* 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 KASUMI session */ - retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_CIPHER_KASUMI_F8, - tdata->key.data, tdata->key.len, - tdata->cipher_iv.len); + /* Create SNOW 3G session */ + retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + RTE_CRYPTO_AUTH_SNOW3G_UIA2, + RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + tdata->key.data, tdata->key.len, + tdata->auth_iv.len, tdata->digest.len, + tdata->cipher_iv.len); if (retval < 0) return retval; + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple */ - /* of the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, - plaintext_pad_len, 10, 0); - ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, - plaintext_pad_len, 3, 0); + plaintext_len = ceil_byte_length(tdata->plaintext.len); + /* Append data which is padded to a multiple of */ + /* the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, plaintext_len); - /* Append data which is padded to a multiple */ - /* of the algorithms block size */ - pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); + debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); - /* Create KASUMI operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, - tdata->cipher_iv.len, - RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), - tdata->validCipherOffsetInBits.len); + /* Create SNOW 3G operation */ + retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data, + tdata->digest.len, tdata->auth_iv.data, + tdata->auth_iv.len, + plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, + tdata->cipher_iv.data, tdata->cipher_iv.len, + tdata->validCipherLenInBits.len, + 0, + tdata->validAuthLenInBits.len, + 0 + ); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - - ut_params->obuf = ut_params->op->sym->m_dst; + ut_params->obuf = ut_params->op->sym->m_src; if (ut_params->obuf) - ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, - plaintext_pad_len, buffer); + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else - ciphertext = rte_pktmbuf_read(ut_params->ibuf, - tdata->validCipherOffsetInBits.len >> 3, - plaintext_pad_len, buffer); + ciphertext = plaintext; - const uint8_t *reference_ciphertext = tdata->ciphertext.data + - (tdata->validCipherOffsetInBits.len >> 3); + debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - reference_ciphertext, - tdata->validCipherLenInBits.len, - "KASUMI Ciphertext data not as expected"); + ciphertext, + tdata->ciphertext.data, + tdata->validDataLenInBits.len, + "SNOW 3G Ciphertext data not as expected"); + + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + plaintext_pad_len; + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ut_params->digest, + tdata->digest.data, + DIGEST_BYTE_LENGTH_SNOW3G_UIA2, + "SNOW 3G Generated auth tag not as expected"); return 0; } - static int -test_kasumi_decryption_oop(const struct kasumi_test_data *tdata) +test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, + uint8_t op_mode, uint8_t verify) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; - uint8_t *ciphertext, *plaintext; - unsigned ciphertext_pad_len; - unsigned ciphertext_len; - /* Create KASUMI session */ - retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_DECRYPT, - RTE_CRYPTO_CIPHER_KASUMI_F8, - tdata->key.data, tdata->key.len, - tdata->cipher_iv.len); - if (retval < 0) - return 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; - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + struct rte_cryptodev_info dev_info; - /* Clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = RTE_CRYPTO_AUTH_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; - ciphertext_len = ceil_byte_length(tdata->ciphertext.len); - /* Append data which is padded to a multiple */ - /* of the algorithms block size */ - ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8); - ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - ciphertext_pad_len); - rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); - memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); + 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; + } + } + + /* Create SNOW 3G session */ + retval = create_wireless_algo_auth_cipher_session( + ts_params->valid_devs[0], + (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT + : RTE_CRYPTO_CIPHER_OP_ENCRYPT), + (verify ? RTE_CRYPTO_AUTH_OP_VERIFY + : RTE_CRYPTO_AUTH_OP_GENERATE), + RTE_CRYPTO_AUTH_SNOW3G_UIA2, + RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + tdata->key.data, tdata->key.len, + tdata->auth_iv.len, tdata->digest.len, + tdata->cipher_iv.len); - /* Create KASUMI operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, - tdata->cipher_iv.len, - RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), - tdata->validCipherOffsetInBits.len); if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - - ut_params->obuf = ut_params->op->sym->m_dst; - if (ut_params->obuf) - plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); - else - plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3); + 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); - debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); + /* 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)); - const uint8_t *reference_plaintext = tdata->plaintext.data + - (tdata->validCipherOffsetInBits.len >> 3); - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - plaintext, - reference_plaintext, - tdata->validCipherLenInBits.len, - "KASUMI Plaintext data not as expected"); - return 0; -} + ciphertext_len = ceil_byte_length(tdata->ciphertext.len); + plaintext_len = ceil_byte_length(tdata->plaintext.len); + ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); -static int -test_kasumi_decryption(const struct kasumi_test_data *tdata) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + 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); + } - int retval; - uint8_t *ciphertext, *plaintext; - unsigned ciphertext_pad_len; - unsigned ciphertext_len; + /* Create SNOW 3G operation */ + retval = create_wireless_algo_auth_cipher_operation( + 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 ? + (verify ? ciphertext_pad_len : plaintext_pad_len) + : tdata->digest.offset_bytes), + tdata->validCipherLenInBits.len, + tdata->cipher.offset_bits, + tdata->validAuthLenInBits.len, + tdata->auth.offset_bits, + op_mode, 0, verify); - /* Create KASUMI session */ - retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_DECRYPT, - RTE_CRYPTO_CIPHER_KASUMI_F8, - tdata->key.data, tdata->key.len, - tdata->cipher_iv.len); if (retval < 0) return retval; - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); - /* Clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ciphertext_len = ceil_byte_length(tdata->ciphertext.len); - /* Append data which is padded to a multiple */ - /* of the algorithms block size */ - ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8); - ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - ciphertext_pad_len); - memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); + ut_params->obuf = (op_mode == IN_PLACE ? + ut_params->op->sym->m_src : ut_params->op->sym->m_dst); - debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); + if (verify) { + if (ut_params->obuf) + plaintext = rte_pktmbuf_mtod(ut_params->obuf, + uint8_t *); + else + plaintext = ciphertext + + (tdata->cipher.offset_bits >> 3); - /* Create KASUMI operation */ - retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, - tdata->cipher_iv.len, - tdata->ciphertext.len, - tdata->validCipherOffsetInBits.len); - if (retval < 0) - return retval; + debug_hexdump(stdout, "plaintext:", plaintext, + (tdata->plaintext.len >> 3) - tdata->digest.len); + debug_hexdump(stdout, "plaintext expected:", + tdata->plaintext.data, + (tdata->plaintext.len >> 3) - tdata->digest.len); + } else { + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, + uint8_t *); + else + ciphertext = plaintext; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + debug_hexdump(stdout, "ciphertext:", ciphertext, + ciphertext_len); + debug_hexdump(stdout, "ciphertext expected:", + tdata->ciphertext.data, tdata->ciphertext.len >> 3); - ut_params->obuf = ut_params->op->sym->m_dst; - if (ut_params->obuf) - plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); - else - plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3); + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + (tdata->digest.offset_bytes == 0 ? + plaintext_pad_len : tdata->digest.offset_bytes); - debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); + debug_hexdump(stdout, "digest:", ut_params->digest, + tdata->digest.len); + debug_hexdump(stdout, "digest expected:", tdata->digest.data, + tdata->digest.len); + } - const uint8_t *reference_plaintext = tdata->plaintext.data + - (tdata->validCipherOffsetInBits.len >> 3); /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - plaintext, - reference_plaintext, - tdata->validCipherLenInBits.len, - "KASUMI Plaintext data not as expected"); + if (verify) { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len >> 3, + "SNOW 3G Plaintext data not as expected"); + } else { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + tdata->ciphertext.data, + tdata->validDataLenInBits.len, + "SNOW 3G Ciphertext data not as expected"); + + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ut_params->digest, + tdata->digest.data, + DIGEST_BYTE_LENGTH_SNOW3G_UIA2, + "SNOW 3G Generated auth tag not as expected"); + } return 0; } static int -test_snow3g_encryption(const struct snow3g_test_data *tdata) +test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, + uint8_t op_mode, uint8_t verify) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; - uint8_t *plaintext, *ciphertext; - unsigned plaintext_pad_len; - unsigned plaintext_len; - /* Create SNOW 3G session */ - retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2, - tdata->key.data, tdata->key.len, - tdata->cipher_iv.len); - if (retval < 0) - return retval; + 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]; - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + struct rte_cryptodev_info dev_info; - /* Clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = RTE_CRYPTO_AUTH_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; - plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple of */ - /* the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, plaintext_len); + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); + uint64_t feat_flags = dev_info.feature_flags; + + 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; + } + } + + /* Create SNOW 3G session */ + retval = create_wireless_algo_auth_cipher_session( + ts_params->valid_devs[0], + (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT + : RTE_CRYPTO_CIPHER_OP_ENCRYPT), + (verify ? RTE_CRYPTO_AUTH_OP_VERIFY + : RTE_CRYPTO_AUTH_OP_GENERATE), + RTE_CRYPTO_AUTH_SNOW3G_UIA2, + RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + tdata->key.data, tdata->key.len, + tdata->auth_iv.len, tdata->digest.len, + tdata->cipher_iv.len); - /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, - tdata->cipher_iv.len, - tdata->validCipherLenInBits.len, - 0); if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ciphertext_len = ceil_byte_length(tdata->ciphertext.len); + plaintext_len = ceil_byte_length(tdata->plaintext.len); + ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - ut_params->obuf = ut_params->op->sym->m_dst; - if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); - else - ciphertext = plaintext; - - debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); - - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - tdata->ciphertext.data, - tdata->validDataLenInBits.len, - "SNOW 3G Ciphertext data not as expected"); - return 0; -} + ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, + plaintext_pad_len, 15, 0); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); + 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_snow3g_encryption_oop(const struct snow3g_test_data *tdata) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - uint8_t *plaintext, *ciphertext; + 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)); - int retval; - unsigned plaintext_pad_len; - unsigned plaintext_len; + /* Create SNOW 3G operation */ + retval = create_wireless_algo_auth_cipher_operation( + 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 ? + (verify ? ciphertext_pad_len : plaintext_pad_len) + : tdata->digest.offset_bytes), + tdata->validCipherLenInBits.len, + tdata->cipher.offset_bits, + tdata->validAuthLenInBits.len, + tdata->auth.offset_bits, + op_mode, 1, verify); - /* Create SNOW 3G session */ - retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2, - tdata->key.data, tdata->key.len, - tdata->cipher_iv.len); if (retval < 0) return retval; - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - - TEST_ASSERT_NOT_NULL(ut_params->ibuf, - "Failed to allocate input buffer in mempool"); - TEST_ASSERT_NOT_NULL(ut_params->obuf, - "Failed to allocate output buffer in mempool"); + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); - /* Clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple of */ - /* the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, plaintext_len); + ut_params->obuf = (op_mode == IN_PLACE ? + ut_params->op->sym->m_src : ut_params->op->sym->m_dst); - debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); + 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); - /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, - tdata->cipher_iv.len, - tdata->validCipherLenInBits.len, - 0); - if (retval < 0) - return retval; + debug_hexdump(stdout, "plaintext:", plaintext, + (tdata->plaintext.len >> 3) - tdata->digest.len); + debug_hexdump(stdout, "plaintext expected:", + tdata->plaintext.data, + (tdata->plaintext.len >> 3) - tdata->digest.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); - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + debug_hexdump(stdout, "ciphertext:", ciphertext, + ciphertext_len); + debug_hexdump(stdout, "ciphertext expected:", + tdata->ciphertext.data, tdata->ciphertext.len >> 3); - ut_params->obuf = ut_params->op->sym->m_dst; - if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); - else - ciphertext = plaintext; + if (ut_params->obuf) + digest = rte_pktmbuf_read(ut_params->obuf, + (tdata->digest.offset_bytes == 0 ? + plaintext_pad_len : tdata->digest.offset_bytes), + tdata->digest.len, digest_buffer); + else + digest = rte_pktmbuf_read(ut_params->ibuf, + (tdata->digest.offset_bytes == 0 ? + plaintext_pad_len : tdata->digest.offset_bytes), + tdata->digest.len, digest_buffer); - debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); + debug_hexdump(stdout, "digest:", digest, + tdata->digest.len); + debug_hexdump(stdout, "digest expected:", + tdata->digest.data, tdata->digest.len); + } /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - tdata->ciphertext.data, - tdata->validDataLenInBits.len, - "SNOW 3G Ciphertext data not as expected"); + if (verify) { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len >> 3, + "SNOW 3G Plaintext data not as expected"); + } else { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + tdata->ciphertext.data, + tdata->validDataLenInBits.len, + "SNOW 3G Ciphertext data not as expected"); + + TEST_ASSERT_BUFFERS_ARE_EQUAL( + digest, + tdata->digest.data, + DIGEST_BYTE_LENGTH_SNOW3G_UIA2, + "SNOW 3G Generated auth tag not as expected"); + } return 0; } static int -test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) +test_kasumi_auth_cipher(const struct kasumi_test_data *tdata, + uint8_t op_mode, uint8_t verify) { struct crypto_testsuite_params *ts_params = &testsuite_params; 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; - uint8_t buffer[10000]; - const uint8_t *ciphertext; + unsigned int ciphertext_pad_len; + unsigned int ciphertext_len; 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; - 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. " - "Test Skipped.\n"); - return -ENOTSUP; + if (op_mode == OUT_OF_PLACE) { + if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { + printf("Device doesn't support digest encrypted.\n"); + return -ENOTSUP; + } } - /* Create SNOW 3G session */ - retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2, - tdata->key.data, tdata->key.len, - tdata->cipher_iv.len); + /* Create KASUMI session */ + retval = create_wireless_algo_auth_cipher_session( + ts_params->valid_devs[0], + (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT + : RTE_CRYPTO_CIPHER_OP_ENCRYPT), + (verify ? RTE_CRYPTO_AUTH_OP_VERIFY + : RTE_CRYPTO_AUTH_OP_GENERATE), + RTE_CRYPTO_AUTH_KASUMI_F9, + RTE_CRYPTO_CIPHER_KASUMI_F8, + tdata->key.data, tdata->key.len, + 0, tdata->digest.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); plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple of */ - /* the algorithms block size */ + ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, - plaintext_pad_len, 10, 0); - ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, - plaintext_pad_len, 3, 0); + 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); + } - TEST_ASSERT_NOT_NULL(ut_params->ibuf, - "Failed to allocate input buffer in mempool"); - TEST_ASSERT_NOT_NULL(ut_params->obuf, - "Failed to allocate output buffer in mempool"); - - pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); + /* Create KASUMI operation */ + retval = create_wireless_algo_auth_cipher_operation( + tdata->digest.data, tdata->digest.len, + tdata->cipher_iv.data, tdata->cipher_iv.len, + NULL, 0, + (tdata->digest.offset_bytes == 0 ? + (verify ? ciphertext_pad_len : plaintext_pad_len) + : tdata->digest.offset_bytes), + tdata->validCipherLenInBits.len, + tdata->validCipherOffsetInBits.len, + tdata->validAuthLenInBits.len, + 0, + op_mode, 0, verify); - /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, - tdata->cipher_iv.len, - tdata->validCipherLenInBits.len, - 0); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ut_params->obuf = ut_params->op->sym->m_dst; - if (ut_params->obuf) - ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, - plaintext_len, buffer); - else - ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, - plaintext_len, buffer); + ut_params->obuf = (op_mode == IN_PLACE ? + ut_params->op->sym->m_src : ut_params->op->sym->m_dst); - debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - tdata->ciphertext.data, - tdata->validDataLenInBits.len, - "SNOW 3G Ciphertext data not as expected"); + if (verify) { + if (ut_params->obuf) + plaintext = rte_pktmbuf_mtod(ut_params->obuf, + uint8_t *); + else + plaintext = ciphertext; - return 0; -} + debug_hexdump(stdout, "plaintext:", plaintext, + (tdata->plaintext.len >> 3) - tdata->digest.len); + debug_hexdump(stdout, "plaintext expected:", + tdata->plaintext.data, + (tdata->plaintext.len >> 3) - tdata->digest.len); + } else { + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, + uint8_t *); + else + ciphertext = plaintext; -/* Shift right a buffer by "offset" bits, "offset" < 8 */ -static void -buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset) -{ - uint8_t curr_byte, prev_byte; - uint32_t length_in_bytes = ceil_byte_length(length + offset); - uint8_t lower_byte_mask = (1 << offset) - 1; - unsigned i; + debug_hexdump(stdout, "ciphertext:", ciphertext, + ciphertext_len); + debug_hexdump(stdout, "ciphertext expected:", + tdata->ciphertext.data, tdata->ciphertext.len >> 3); - prev_byte = buffer[0]; - buffer[0] >>= offset; + ut_params->digest = rte_pktmbuf_mtod( + ut_params->obuf, uint8_t *) + + (tdata->digest.offset_bytes == 0 ? + plaintext_pad_len : tdata->digest.offset_bytes); - for (i = 1; i < length_in_bytes; i++) { - curr_byte = buffer[i]; - buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) | - (curr_byte >> offset); - prev_byte = curr_byte; + debug_hexdump(stdout, "digest:", ut_params->digest, + tdata->digest.len); + debug_hexdump(stdout, "digest expected:", + tdata->digest.data, tdata->digest.len); + } + + /* Validate obuf */ + if (verify) { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len >> 3, + "KASUMI Plaintext data not as expected"); + } else { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + tdata->ciphertext.data, + tdata->ciphertext.len >> 3, + "KASUMI Ciphertext data not as expected"); + + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ut_params->digest, + tdata->digest.data, + DIGEST_BYTE_LENGTH_KASUMI_F9, + "KASUMI Generated auth tag not as expected"); } + return 0; } static int -test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) +test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata, + uint8_t op_mode, uint8_t verify) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - uint8_t *plaintext, *ciphertext; + int retval; - uint32_t plaintext_len; - uint32_t plaintext_pad_len; - uint8_t extra_offset = 4; - uint8_t *expected_ciphertext_shifted; - /* Create SNOW 3G session */ - retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2, - tdata->key.data, tdata->key.len, - tdata->cipher_iv.len); + 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]; + + 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; + + 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; + } + } + + /* Create KASUMI session */ + retval = create_wireless_algo_auth_cipher_session( + ts_params->valid_devs[0], + (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT + : RTE_CRYPTO_CIPHER_OP_ENCRYPT), + (verify ? RTE_CRYPTO_AUTH_OP_VERIFY + : RTE_CRYPTO_AUTH_OP_GENERATE), + RTE_CRYPTO_AUTH_KASUMI_F9, + RTE_CRYPTO_CIPHER_KASUMI_F8, + tdata->key.data, tdata->key.len, + 0, tdata->digest.len, + tdata->cipher_iv.len); + if (retval < 0) return retval; - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ciphertext_len = ceil_byte_length(tdata->ciphertext.len); + plaintext_len = ceil_byte_length(tdata->plaintext.len); + ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); + ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, + plaintext_pad_len, 15, 0); TEST_ASSERT_NOT_NULL(ut_params->ibuf, "Failed to allocate input buffer in mempool"); - TEST_ASSERT_NOT_NULL(ut_params->obuf, - "Failed to allocate output buffer in mempool"); - /* Clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); - - plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset); - /* - * Append data which is padded to a - * multiple of the algorithms block size - */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - - plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); + 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"); + } - rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); + 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)); - memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3)); - buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset); + /* Create KASUMI operation */ + retval = create_wireless_algo_auth_cipher_operation( + tdata->digest.data, tdata->digest.len, + tdata->cipher_iv.data, tdata->cipher_iv.len, + NULL, 0, + (tdata->digest.offset_bytes == 0 ? + (verify ? ciphertext_pad_len : plaintext_pad_len) + : tdata->digest.offset_bytes), + tdata->validCipherLenInBits.len, + tdata->validCipherOffsetInBits.len, + tdata->validAuthLenInBits.len, + 0, + op_mode, 1, verify); -#ifdef RTE_APP_TEST_DEBUG - rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); -#endif - /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, - tdata->cipher_iv.len, - tdata->validCipherLenInBits.len, - extra_offset); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ut_params->obuf = ut_params->op->sym->m_dst; - if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); - else - ciphertext = plaintext; + ut_params->obuf = (op_mode == IN_PLACE ? + ut_params->op->sym->m_src : ut_params->op->sym->m_dst); -#ifdef RTE_APP_TEST_DEBUG - rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); -#endif + 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); - expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8); + debug_hexdump(stdout, "plaintext:", plaintext, + (tdata->plaintext.len >> 3) - tdata->digest.len); + debug_hexdump(stdout, "plaintext expected:", + tdata->plaintext.data, + (tdata->plaintext.len >> 3) - tdata->digest.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); - TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted, - "failed to reserve memory for ciphertext shifted\n"); + debug_hexdump(stdout, "ciphertext:", ciphertext, + ciphertext_len); + debug_hexdump(stdout, "ciphertext expected:", + tdata->ciphertext.data, tdata->ciphertext.len >> 3); + + if (ut_params->obuf) + digest = rte_pktmbuf_read(ut_params->obuf, + (tdata->digest.offset_bytes == 0 ? + plaintext_pad_len : tdata->digest.offset_bytes), + tdata->digest.len, digest_buffer); + else + digest = rte_pktmbuf_read(ut_params->ibuf, + (tdata->digest.offset_bytes == 0 ? + plaintext_pad_len : tdata->digest.offset_bytes), + tdata->digest.len, digest_buffer); + + debug_hexdump(stdout, "digest:", digest, + tdata->digest.len); + debug_hexdump(stdout, "digest expected:", + tdata->digest.data, tdata->digest.len); + } - memcpy(expected_ciphertext_shifted, tdata->ciphertext.data, - ceil_byte_length(tdata->ciphertext.len)); - buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len, - extra_offset); /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET( - ciphertext, - expected_ciphertext_shifted, - tdata->validDataLenInBits.len, - extra_offset, - "SNOW 3G Ciphertext data not as expected"); + if (verify) { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len >> 3, + "KASUMI Plaintext data not as expected"); + } else { + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + tdata->ciphertext.data, + tdata->validDataLenInBits.len, + "KASUMI Ciphertext data not as expected"); + + TEST_ASSERT_BUFFERS_ARE_EQUAL( + digest, + tdata->digest.data, + DIGEST_BYTE_LENGTH_KASUMI_F9, + "KASUMI Generated auth tag not as expected"); + } return 0; } -static int test_snow3g_decryption(const struct snow3g_test_data *tdata) +static int +test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -4326,111 +4818,147 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) int retval; uint8_t *plaintext, *ciphertext; - unsigned ciphertext_pad_len; - unsigned ciphertext_len; + unsigned plaintext_pad_len; + unsigned plaintext_len; - /* Create SNOW 3G session */ - retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_DECRYPT, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2, - tdata->key.data, tdata->key.len, - tdata->cipher_iv.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], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + RTE_CRYPTO_AUTH_KASUMI_F9, + RTE_CRYPTO_CIPHER_KASUMI_F8, + tdata->key.data, tdata->key.len, + 0, tdata->digest.len, + tdata->cipher_iv.len); if (retval < 0) return retval; ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - /* Clear mbuf payload */ + /* clear mbuf payload */ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + rte_pktmbuf_tailroom(ut_params->ibuf)); - ciphertext_len = ceil_byte_length(tdata->ciphertext.len); + plaintext_len = ceil_byte_length(tdata->plaintext.len); /* Append data which is padded to a multiple of */ /* the algorithms block size */ - ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); - ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - ciphertext_pad_len); - memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, plaintext_len); - debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); + debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); - /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, - tdata->cipher_iv.len, - tdata->validCipherLenInBits.len, - tdata->cipher.offset_bits); + /* Create KASUMI operation */ + retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data, + tdata->digest.len, NULL, 0, + plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, + tdata->cipher_iv.data, tdata->cipher_iv.len, + RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), + tdata->validCipherOffsetInBits.len, + tdata->validAuthLenInBits.len, + 0 + ); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ut_params->obuf = ut_params->op->sym->m_dst; - if (ut_params->obuf) - plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); + + if (ut_params->op->sym->m_dst) + ut_params->obuf = ut_params->op->sym->m_dst; else - plaintext = ciphertext; + ut_params->obuf = ut_params->op->sym->m_src; - debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); + ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, + tdata->validCipherOffsetInBits.len >> 3); + + ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + plaintext_pad_len; + const uint8_t *reference_ciphertext = tdata->ciphertext.data + + (tdata->validCipherOffsetInBits.len >> 3); /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext, - tdata->plaintext.data, - tdata->validDataLenInBits.len, - "SNOW 3G Plaintext data not as expected"); + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + reference_ciphertext, + tdata->validCipherLenInBits.len, + "KASUMI Ciphertext data not as expected"); + + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ut_params->digest, + tdata->digest.data, + DIGEST_BYTE_LENGTH_SNOW3G_UIA2, + "KASUMI Generated auth tag not as expected"); return 0; } -static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) +static int +test_zuc_encryption(const struct wireless_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; - uint8_t *plaintext, *ciphertext; - unsigned ciphertext_pad_len; - unsigned ciphertext_len; + unsigned plaintext_pad_len; + unsigned plaintext_len; - /* Create SNOW 3G session */ + struct rte_cryptodev_sym_capability_idx cap_idx; + + /* Check if device supports ZUC EEA3 */ + cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3; + + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + + /* Create ZUC session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_DECRYPT, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata->key.data, tdata->key.len, tdata->cipher_iv.len); if (retval < 0) return retval; ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - - TEST_ASSERT_NOT_NULL(ut_params->ibuf, - "Failed to allocate input buffer"); - TEST_ASSERT_NOT_NULL(ut_params->obuf, - "Failed to allocate output buffer"); /* Clear mbuf payload */ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->ibuf)); - memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->obuf)); - - ciphertext_len = ceil_byte_length(tdata->ciphertext.len); - /* Append data which is padded to a multiple of */ - /* the algorithms block size */ - ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); - ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - ciphertext_pad_len); - rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); - memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); + plaintext_len = ceil_byte_length(tdata->plaintext.len); + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(plaintext, tdata->plaintext.data, plaintext_len); - debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); + debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); - /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + /* Create ZUC operation */ + retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, tdata->cipher_iv.len, - tdata->validCipherLenInBits.len, + tdata->plaintext.len, 0); if (retval < 0) return retval; @@ -4438,33 +4966,37 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else - plaintext = ciphertext; + ciphertext = plaintext; - debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); + debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext, - tdata->plaintext.data, - tdata->validDataLenInBits.len, - "SNOW 3G Plaintext data not as expected"); + TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( + ciphertext, + tdata->ciphertext.data, + tdata->validCipherLenInBits.len, + "ZUC Ciphertext data not as expected"); return 0; } static int -test_zuc_cipher_auth(const struct wireless_test_data *tdata) +test_zuc_encryption_sgl(const struct wireless_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; - uint8_t *plaintext, *ciphertext; unsigned int plaintext_pad_len; unsigned int plaintext_len; + const uint8_t *ciphertext; + uint8_t ciphertext_buffer[2048]; + struct rte_cryptodev_info dev_info; struct rte_cryptodev_sym_capability_idx cap_idx; @@ -4476,154 +5008,151 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata) &cap_idx) == NULL) 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; + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) + uint64_t feat_flags = dev_info.feature_flags; + + if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { + printf("Device doesn't support in-place scatter-gather. " + "Test Skipped.\n"); return -ENOTSUP; + } + + plaintext_len = ceil_byte_length(tdata->plaintext.len); + + /* Append data which is padded to a multiple */ + /* of the algorithms block size */ + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); + + ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, + plaintext_pad_len, 10, 0); + + pktmbuf_write(ut_params->ibuf, 0, plaintext_len, + tdata->plaintext.data); /* Create ZUC session */ - retval = create_zuc_cipher_auth_encrypt_generate_session( - ts_params->valid_devs[0], - tdata); + retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_CIPHER_ZUC_EEA3, + tdata->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - - /* clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); - plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple of */ - /* the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, plaintext_len); + /* Clear mbuf payload */ - debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); + pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); /* Create ZUC operation */ - retval = create_zuc_cipher_hash_generate_operation(tdata); + retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, + tdata->cipher_iv.len, tdata->plaintext.len, + 0); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ut_params->obuf = ut_params->op->sym->m_src; + + ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); + ciphertext = rte_pktmbuf_read(ut_params->obuf, + 0, plaintext_len, ciphertext_buffer); else - ciphertext = plaintext; + ciphertext = rte_pktmbuf_read(ut_params->ibuf, + 0, plaintext_len, ciphertext_buffer); + /* Validate obuf */ debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); + /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - tdata->ciphertext.data, - tdata->validDataLenInBits.len, - "ZUC Ciphertext data not as expected"); - - ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len; + ciphertext, + tdata->ciphertext.data, + tdata->validCipherLenInBits.len, + "ZUC Ciphertext data not as expected"); - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ut_params->digest, - tdata->digest.data, - 4, - "ZUC Generated auth tag not as expected"); return 0; } static int -test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) +test_zuc_authentication(const struct wireless_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; int retval; - - uint8_t *plaintext, *ciphertext; unsigned plaintext_pad_len; unsigned plaintext_len; + uint8_t *plaintext; - /* Create SNOW 3G session */ - retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_AUTH_OP_GENERATE, - RTE_CRYPTO_AUTH_SNOW3G_UIA2, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + 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; + + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + + /* Create ZUC session */ + retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], tdata->key.data, tdata->key.len, tdata->auth_iv.len, tdata->digest.len, - tdata->cipher_iv.len); + RTE_CRYPTO_AUTH_OP_GENERATE, + RTE_CRYPTO_AUTH_ZUC_EIA3); if (retval < 0) return retval; + + /* alloc mbuf and set payload */ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - /* clear mbuf payload */ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + rte_pktmbuf_tailroom(ut_params->ibuf)); plaintext_len = ceil_byte_length(tdata->plaintext.len); /* Append data which is padded to a multiple of */ /* the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); + plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, plaintext_pad_len); memcpy(plaintext, tdata->plaintext.data, plaintext_len); - debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); - - /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data, - tdata->digest.len, tdata->auth_iv.data, - tdata->auth_iv.len, + /* Create ZUC operation */ + retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, + tdata->auth_iv.data, tdata->auth_iv.len, plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, - tdata->cipher_iv.data, tdata->cipher_iv.len, - tdata->validCipherLenInBits.len, - 0, tdata->validAuthLenInBits.len, - 0 - ); + 0); if (retval < 0) return retval; ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->op); ut_params->obuf = ut_params->op->sym->m_src; - if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); - else - ciphertext = plaintext; - - debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - tdata->ciphertext.data, - tdata->validDataLenInBits.len, - "SNOW 3G Ciphertext data not as expected"); - + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len; + + plaintext_pad_len; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( - ut_params->digest, - tdata->digest.data, - DIGEST_BYTE_LENGTH_SNOW3G_UIA2, - "SNOW 3G Generated auth tag not as expected"); + ut_params->digest, + tdata->digest.data, + tdata->digest.len, + "ZUC Generated auth tag not as expected"); + return 0; } static int -test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, +test_zuc_auth_cipher(const struct wireless_test_data *tdata, uint8_t op_mode, uint8_t verify) { struct crypto_testsuite_params *ts_params = &testsuite_params; @@ -4638,27 +5167,34 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, unsigned int ciphertext_len; struct rte_cryptodev_info dev_info; + struct rte_cryptodev_sym_capability_idx cap_idx; + + /* Check if device supports ZUC EIA3 */ + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; + + 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; - 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 SNOW 3G session */ + /* Create ZUC session */ retval = create_wireless_algo_auth_cipher_session( ts_params->valid_devs[0], (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT : RTE_CRYPTO_CIPHER_OP_ENCRYPT), (verify ? RTE_CRYPTO_AUTH_OP_VERIFY : RTE_CRYPTO_AUTH_OP_GENERATE), - RTE_CRYPTO_AUTH_SNOW3G_UIA2, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + RTE_CRYPTO_AUTH_ZUC_EIA3, + RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata->key.data, tdata->key.len, tdata->auth_iv.len, tdata->digest.len, tdata->cipher_iv.len); @@ -4696,10 +5232,11 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, 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); + debug_hexdump(stdout, "plaintext:", plaintext, + plaintext_len); } - /* Create SNOW 3G operation */ + /* Create ZUC operation */ retval = create_wireless_algo_auth_cipher_operation( tdata->digest.data, tdata->digest.len, tdata->cipher_iv.data, tdata->cipher_iv.len, @@ -4708,9 +5245,9 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, (verify ? ciphertext_pad_len : plaintext_pad_len) : tdata->digest.offset_bytes), tdata->validCipherLenInBits.len, - tdata->cipher.offset_bits, + tdata->validCipherOffsetInBits.len, tdata->validAuthLenInBits.len, - tdata->auth.offset_bits, + 0, op_mode, 0, verify); if (retval < 0) @@ -4724,13 +5261,13 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, 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); + plaintext = ciphertext; debug_hexdump(stdout, "plaintext:", plaintext, (tdata->plaintext.len >> 3) - tdata->digest.len); @@ -4749,14 +5286,15 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, debug_hexdump(stdout, "ciphertext expected:", tdata->ciphertext.data, tdata->ciphertext.len >> 3); - ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + (tdata->digest.offset_bytes == 0 ? - plaintext_pad_len : tdata->digest.offset_bytes); + ut_params->digest = rte_pktmbuf_mtod( + ut_params->obuf, uint8_t *) + + (tdata->digest.offset_bytes == 0 ? + plaintext_pad_len : tdata->digest.offset_bytes); debug_hexdump(stdout, "digest:", ut_params->digest, tdata->digest.len); - debug_hexdump(stdout, "digest expected:", tdata->digest.data, - tdata->digest.len); + debug_hexdump(stdout, "digest expected:", + tdata->digest.data, tdata->digest.len); } /* Validate obuf */ @@ -4765,25 +5303,25 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3, - "SNOW 3G Plaintext data not as expected"); + "ZUC Plaintext data not as expected"); } else { TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( ciphertext, tdata->ciphertext.data, - tdata->validDataLenInBits.len, - "SNOW 3G Ciphertext data not as expected"); + tdata->ciphertext.len >> 3, + "ZUC Ciphertext data not as expected"); TEST_ASSERT_BUFFERS_ARE_EQUAL( ut_params->digest, tdata->digest.data, - DIGEST_BYTE_LENGTH_SNOW3G_UIA2, - "SNOW 3G Generated auth tag not as expected"); + DIGEST_BYTE_LENGTH_KASUMI_F9, + "ZUC Generated auth tag not as expected"); } return 0; } static int -test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, +test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, uint8_t op_mode, uint8_t verify) { struct crypto_testsuite_params *ts_params = &testsuite_params; @@ -4802,6 +5340,15 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, uint8_t digest_buffer[10000]; struct rte_cryptodev_info dev_info; + struct rte_cryptodev_sym_capability_idx cap_idx; + + /* Check if device supports ZUC EIA3 */ + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; + + 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); @@ -4825,15 +5372,15 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, } } - /* Create SNOW 3G session */ + /* Create ZUC session */ retval = create_wireless_algo_auth_cipher_session( ts_params->valid_devs[0], (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT : RTE_CRYPTO_CIPHER_OP_ENCRYPT), (verify ? RTE_CRYPTO_AUTH_OP_VERIFY : RTE_CRYPTO_AUTH_OP_GENERATE), - RTE_CRYPTO_AUTH_SNOW3G_UIA2, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + RTE_CRYPTO_AUTH_ZUC_EIA3, + RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata->key.data, tdata->key.len, tdata->auth_iv.len, tdata->digest.len, tdata->cipher_iv.len); @@ -4875,18 +5422,18 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, } memset(buffer, 0, sizeof(buffer)); - /* Create SNOW 3G operation */ + /* Create ZUC operation */ retval = create_wireless_algo_auth_cipher_operation( tdata->digest.data, tdata->digest.len, tdata->cipher_iv.data, tdata->cipher_iv.len, - tdata->auth_iv.data, tdata->auth_iv.len, + NULL, 0, (tdata->digest.offset_bytes == 0 ? (verify ? ciphertext_pad_len : plaintext_pad_len) : tdata->digest.offset_bytes), tdata->validCipherLenInBits.len, - tdata->cipher.offset_bits, + tdata->validCipherOffsetInBits.len, tdata->validAuthLenInBits.len, - tdata->auth.offset_bits, + 0, op_mode, 1, verify); if (retval < 0) @@ -4949,742 +5496,704 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3, - "SNOW 3G Plaintext data not as expected"); + "ZUC Plaintext data not as expected"); } else { TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( ciphertext, tdata->ciphertext.data, tdata->validDataLenInBits.len, - "SNOW 3G Ciphertext data not as expected"); + "ZUC Ciphertext data not as expected"); TEST_ASSERT_BUFFERS_ARE_EQUAL( digest, tdata->digest.data, - DIGEST_BYTE_LENGTH_SNOW3G_UIA2, - "SNOW 3G Generated auth tag not as expected"); + DIGEST_BYTE_LENGTH_KASUMI_F9, + "ZUC Generated auth tag not as expected"); } return 0; } static int -test_kasumi_auth_cipher(const struct kasumi_test_data *tdata, - uint8_t op_mode, uint8_t verify) +test_kasumi_encryption_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + return test_kasumi_encryption(&kasumi_test_case_1); +} - 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; +static int +test_kasumi_encryption_test_case_1_sgl(void) +{ + return test_kasumi_encryption_sgl(&kasumi_test_case_1); +} - struct rte_cryptodev_info dev_info; +static int +test_kasumi_encryption_test_case_1_oop(void) +{ + return test_kasumi_encryption_oop(&kasumi_test_case_1); +} - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); +static int +test_kasumi_encryption_test_case_1_oop_sgl(void) +{ + return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1); +} - uint64_t feat_flags = dev_info.feature_flags; +static int +test_kasumi_encryption_test_case_2(void) +{ + return test_kasumi_encryption(&kasumi_test_case_2); +} - if (op_mode == OUT_OF_PLACE) { - if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { - printf("Device doesn't support digest encrypted.\n"); - return -ENOTSUP; - } - } +static int +test_kasumi_encryption_test_case_3(void) +{ + return test_kasumi_encryption(&kasumi_test_case_3); +} - /* Create KASUMI session */ - retval = create_wireless_algo_auth_cipher_session( - ts_params->valid_devs[0], - (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT - : RTE_CRYPTO_CIPHER_OP_ENCRYPT), - (verify ? RTE_CRYPTO_AUTH_OP_VERIFY - : RTE_CRYPTO_AUTH_OP_GENERATE), - RTE_CRYPTO_AUTH_KASUMI_F9, - RTE_CRYPTO_CIPHER_KASUMI_F8, - tdata->key.data, tdata->key.len, - 0, tdata->digest.len, - tdata->cipher_iv.len); +static int +test_kasumi_encryption_test_case_4(void) +{ + return test_kasumi_encryption(&kasumi_test_case_4); +} - if (retval < 0) - return retval; +static int +test_kasumi_encryption_test_case_5(void) +{ + return test_kasumi_encryption(&kasumi_test_case_5); +} - 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); +static int +test_kasumi_decryption_test_case_1(void) +{ + return test_kasumi_decryption(&kasumi_test_case_1); +} - /* 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)); +static int +test_kasumi_decryption_test_case_1_oop(void) +{ + return test_kasumi_decryption_oop(&kasumi_test_case_1); +} - ciphertext_len = ceil_byte_length(tdata->ciphertext.len); - plaintext_len = ceil_byte_length(tdata->plaintext.len); - ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); +static int +test_kasumi_decryption_test_case_2(void) +{ + return test_kasumi_decryption(&kasumi_test_case_2); +} - 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); - } +static int +test_kasumi_decryption_test_case_3(void) +{ + return test_kasumi_decryption(&kasumi_test_case_3); +} - /* Create KASUMI operation */ - retval = create_wireless_algo_auth_cipher_operation( - tdata->digest.data, tdata->digest.len, - tdata->cipher_iv.data, tdata->cipher_iv.len, - NULL, 0, - (tdata->digest.offset_bytes == 0 ? - (verify ? ciphertext_pad_len : plaintext_pad_len) - : tdata->digest.offset_bytes), - tdata->validCipherLenInBits.len, - tdata->validCipherOffsetInBits.len, - tdata->validAuthLenInBits.len, - 0, - op_mode, 0, verify); +static int +test_kasumi_decryption_test_case_4(void) +{ + return test_kasumi_decryption(&kasumi_test_case_4); +} - if (retval < 0) - return retval; +static int +test_kasumi_decryption_test_case_5(void) +{ + return test_kasumi_decryption(&kasumi_test_case_5); +} +static int +test_snow3g_encryption_test_case_1(void) +{ + return test_snow3g_encryption(&snow3g_test_case_1); +} - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); +static int +test_snow3g_encryption_test_case_1_oop(void) +{ + return test_snow3g_encryption_oop(&snow3g_test_case_1); +} - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); +static int +test_snow3g_encryption_test_case_1_oop_sgl(void) +{ + return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1); +} - ut_params->obuf = (op_mode == IN_PLACE ? - ut_params->op->sym->m_src : ut_params->op->sym->m_dst); +static int +test_snow3g_encryption_test_case_1_offset_oop(void) +{ + return test_snow3g_encryption_offset_oop(&snow3g_test_case_1); +} - if (verify) { - if (ut_params->obuf) - plaintext = rte_pktmbuf_mtod(ut_params->obuf, - uint8_t *); - else - plaintext = ciphertext; +static int +test_snow3g_encryption_test_case_2(void) +{ + return test_snow3g_encryption(&snow3g_test_case_2); +} - debug_hexdump(stdout, "plaintext:", plaintext, - (tdata->plaintext.len >> 3) - tdata->digest.len); - debug_hexdump(stdout, "plaintext expected:", - tdata->plaintext.data, - (tdata->plaintext.len >> 3) - tdata->digest.len); - } else { - if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, - uint8_t *); - else - ciphertext = plaintext; +static int +test_snow3g_encryption_test_case_3(void) +{ + return test_snow3g_encryption(&snow3g_test_case_3); +} - debug_hexdump(stdout, "ciphertext:", ciphertext, - ciphertext_len); - debug_hexdump(stdout, "ciphertext expected:", - tdata->ciphertext.data, tdata->ciphertext.len >> 3); +static int +test_snow3g_encryption_test_case_4(void) +{ + return test_snow3g_encryption(&snow3g_test_case_4); +} - ut_params->digest = rte_pktmbuf_mtod( - ut_params->obuf, uint8_t *) + - (tdata->digest.offset_bytes == 0 ? - plaintext_pad_len : tdata->digest.offset_bytes); +static int +test_snow3g_encryption_test_case_5(void) +{ + return test_snow3g_encryption(&snow3g_test_case_5); +} - debug_hexdump(stdout, "digest:", ut_params->digest, - tdata->digest.len); - debug_hexdump(stdout, "digest expected:", - tdata->digest.data, tdata->digest.len); - } +static int +test_snow3g_decryption_test_case_1(void) +{ + return test_snow3g_decryption(&snow3g_test_case_1); +} - /* Validate obuf */ - if (verify) { - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - plaintext, - tdata->plaintext.data, - tdata->plaintext.len >> 3, - "KASUMI Plaintext data not as expected"); - } else { - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - tdata->ciphertext.data, - tdata->ciphertext.len >> 3, - "KASUMI Ciphertext data not as expected"); +static int +test_snow3g_decryption_test_case_1_oop(void) +{ + return test_snow3g_decryption_oop(&snow3g_test_case_1); +} - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ut_params->digest, - tdata->digest.data, - DIGEST_BYTE_LENGTH_KASUMI_F9, - "KASUMI Generated auth tag not as expected"); - } - return 0; +static int +test_snow3g_decryption_test_case_2(void) +{ + return test_snow3g_decryption(&snow3g_test_case_2); } static int -test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata, - uint8_t op_mode, uint8_t verify) +test_snow3g_decryption_test_case_3(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + return test_snow3g_decryption(&snow3g_test_case_3); +} - int retval; - - 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]; +static int +test_snow3g_decryption_test_case_4(void) +{ + return test_snow3g_decryption(&snow3g_test_case_4); +} - struct rte_cryptodev_info dev_info; +static int +test_snow3g_decryption_test_case_5(void) +{ + return test_snow3g_decryption(&snow3g_test_case_5); +} - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); +/* + * Function prepares snow3g_hash_test_data from snow3g_test_data. + * Pattern digest from snow3g_test_data must be allocated as + * 4 last bytes in plaintext. + */ +static void +snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern, + struct snow3g_hash_test_data *output) +{ + if ((pattern != NULL) && (output != NULL)) { + output->key.len = pattern->key.len; - uint64_t feat_flags = dev_info.feature_flags; + memcpy(output->key.data, + pattern->key.data, pattern->key.len); - 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; - } - } + output->auth_iv.len = pattern->auth_iv.len; - /* Create KASUMI session */ - retval = create_wireless_algo_auth_cipher_session( - ts_params->valid_devs[0], - (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT - : RTE_CRYPTO_CIPHER_OP_ENCRYPT), - (verify ? RTE_CRYPTO_AUTH_OP_VERIFY - : RTE_CRYPTO_AUTH_OP_GENERATE), - RTE_CRYPTO_AUTH_KASUMI_F9, - RTE_CRYPTO_CIPHER_KASUMI_F8, - tdata->key.data, tdata->key.len, - 0, tdata->digest.len, - tdata->cipher_iv.len); + memcpy(output->auth_iv.data, + pattern->auth_iv.data, pattern->auth_iv.len); - if (retval < 0) - return retval; + output->plaintext.len = pattern->plaintext.len; - ciphertext_len = ceil_byte_length(tdata->ciphertext.len); - plaintext_len = ceil_byte_length(tdata->plaintext.len); - ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); + memcpy(output->plaintext.data, + pattern->plaintext.data, pattern->plaintext.len >> 3); - ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, - plaintext_pad_len, 15, 0); - TEST_ASSERT_NOT_NULL(ut_params->ibuf, - "Failed to allocate input buffer in mempool"); + output->digest.len = pattern->digest.len; - 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"); - } + memcpy(output->digest.data, + &pattern->plaintext.data[pattern->digest.offset_bytes], + pattern->digest.len); - 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); + output->validAuthLenInBits.len = + pattern->validAuthLenInBits.len; } - memset(buffer, 0, sizeof(buffer)); - - /* Create KASUMI operation */ - retval = create_wireless_algo_auth_cipher_operation( - tdata->digest.data, tdata->digest.len, - tdata->cipher_iv.data, tdata->cipher_iv.len, - NULL, 0, - (tdata->digest.offset_bytes == 0 ? - (verify ? ciphertext_pad_len : plaintext_pad_len) - : tdata->digest.offset_bytes), - tdata->validCipherLenInBits.len, - tdata->validCipherOffsetInBits.len, - tdata->validAuthLenInBits.len, - 0, - op_mode, 1, verify); - - if (retval < 0) - return retval; - - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); +} - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); +/* + * Test case verify computed cipher and digest from snow3g_test_case_7 data. + */ +static int +test_snow3g_decryption_with_digest_test_case_1(void) +{ + struct snow3g_hash_test_data snow3g_hash_data; - ut_params->obuf = (op_mode == IN_PLACE ? - ut_params->op->sym->m_src : ut_params->op->sym->m_dst); + /* + * Function prepare data for hash veryfication test case. + * Digest is allocated in 4 last bytes in plaintext, pattern. + */ + snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data); - 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); + return test_snow3g_decryption(&snow3g_test_case_7) & + test_snow3g_authentication_verify(&snow3g_hash_data); +} - debug_hexdump(stdout, "plaintext:", plaintext, - (tdata->plaintext.len >> 3) - tdata->digest.len); - debug_hexdump(stdout, "plaintext expected:", - tdata->plaintext.data, - (tdata->plaintext.len >> 3) - tdata->digest.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); +static int +test_snow3g_cipher_auth_test_case_1(void) +{ + return test_snow3g_cipher_auth(&snow3g_test_case_3); +} - debug_hexdump(stdout, "ciphertext:", ciphertext, - ciphertext_len); - debug_hexdump(stdout, "ciphertext expected:", - tdata->ciphertext.data, tdata->ciphertext.len >> 3); +static int +test_snow3g_auth_cipher_test_case_1(void) +{ + return test_snow3g_auth_cipher( + &snow3g_auth_cipher_test_case_1, IN_PLACE, 0); +} - if (ut_params->obuf) - digest = rte_pktmbuf_read(ut_params->obuf, - (tdata->digest.offset_bytes == 0 ? - plaintext_pad_len : tdata->digest.offset_bytes), - tdata->digest.len, digest_buffer); - else - digest = rte_pktmbuf_read(ut_params->ibuf, - (tdata->digest.offset_bytes == 0 ? - plaintext_pad_len : tdata->digest.offset_bytes), - tdata->digest.len, digest_buffer); +static int +test_snow3g_auth_cipher_test_case_2(void) +{ + return test_snow3g_auth_cipher( + &snow3g_auth_cipher_test_case_2, IN_PLACE, 0); +} - debug_hexdump(stdout, "digest:", digest, - tdata->digest.len); - debug_hexdump(stdout, "digest expected:", - tdata->digest.data, tdata->digest.len); - } +static int +test_snow3g_auth_cipher_test_case_2_oop(void) +{ + return test_snow3g_auth_cipher( + &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0); +} - /* Validate obuf */ - if (verify) { - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - plaintext, - tdata->plaintext.data, - tdata->plaintext.len >> 3, - "KASUMI Plaintext data not as expected"); - } else { - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - tdata->ciphertext.data, - tdata->validDataLenInBits.len, - "KASUMI Ciphertext data not as expected"); +static int +test_snow3g_auth_cipher_part_digest_enc(void) +{ + return test_snow3g_auth_cipher( + &snow3g_auth_cipher_partial_digest_encryption, + IN_PLACE, 0); +} - TEST_ASSERT_BUFFERS_ARE_EQUAL( - digest, - tdata->digest.data, - DIGEST_BYTE_LENGTH_KASUMI_F9, - "KASUMI Generated auth tag not as expected"); - } - return 0; +static int +test_snow3g_auth_cipher_part_digest_enc_oop(void) +{ + return test_snow3g_auth_cipher( + &snow3g_auth_cipher_partial_digest_encryption, + OUT_OF_PLACE, 0); } static int -test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) +test_snow3g_auth_cipher_test_case_3_sgl(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + return test_snow3g_auth_cipher_sgl( + &snow3g_auth_cipher_test_case_3, IN_PLACE, 0); +} - int retval; +static int +test_snow3g_auth_cipher_test_case_3_oop_sgl(void) +{ + return test_snow3g_auth_cipher_sgl( + &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0); +} - uint8_t *plaintext, *ciphertext; - unsigned plaintext_pad_len; - unsigned plaintext_len; - - /* Create KASUMI session */ - retval = create_wireless_algo_cipher_auth_session( - ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_AUTH_OP_GENERATE, - RTE_CRYPTO_AUTH_KASUMI_F9, - RTE_CRYPTO_CIPHER_KASUMI_F8, - tdata->key.data, tdata->key.len, - 0, tdata->digest.len, - tdata->cipher_iv.len); - if (retval < 0) - return retval; +static int +test_snow3g_auth_cipher_part_digest_enc_sgl(void) +{ + return test_snow3g_auth_cipher_sgl( + &snow3g_auth_cipher_partial_digest_encryption, + IN_PLACE, 0); +} - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); +static int +test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void) +{ + return test_snow3g_auth_cipher_sgl( + &snow3g_auth_cipher_partial_digest_encryption, + OUT_OF_PLACE, 0); +} - /* clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); +static int +test_snow3g_auth_cipher_verify_test_case_1(void) +{ + return test_snow3g_auth_cipher( + &snow3g_auth_cipher_test_case_1, IN_PLACE, 1); +} - plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple of */ - /* the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, plaintext_len); +static int +test_snow3g_auth_cipher_verify_test_case_2(void) +{ + return test_snow3g_auth_cipher( + &snow3g_auth_cipher_test_case_2, IN_PLACE, 1); +} - debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); +static int +test_snow3g_auth_cipher_verify_test_case_2_oop(void) +{ + return test_snow3g_auth_cipher( + &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1); +} - /* Create KASUMI operation */ - retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data, - tdata->digest.len, NULL, 0, - plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, - tdata->cipher_iv.data, tdata->cipher_iv.len, - RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), - tdata->validCipherOffsetInBits.len, - tdata->validAuthLenInBits.len, - 0 - ); - if (retval < 0) - return retval; +static int +test_snow3g_auth_cipher_verify_part_digest_enc(void) +{ + return test_snow3g_auth_cipher( + &snow3g_auth_cipher_partial_digest_encryption, + IN_PLACE, 1); +} - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); +static int +test_snow3g_auth_cipher_verify_part_digest_enc_oop(void) +{ + return test_snow3g_auth_cipher( + &snow3g_auth_cipher_partial_digest_encryption, + OUT_OF_PLACE, 1); +} - if (ut_params->op->sym->m_dst) - ut_params->obuf = ut_params->op->sym->m_dst; - else - ut_params->obuf = ut_params->op->sym->m_src; +static int +test_snow3g_auth_cipher_verify_test_case_3_sgl(void) +{ + return test_snow3g_auth_cipher_sgl( + &snow3g_auth_cipher_test_case_3, IN_PLACE, 1); +} - ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, - tdata->validCipherOffsetInBits.len >> 3); +static int +test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void) +{ + return test_snow3g_auth_cipher_sgl( + &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1); +} - ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len; +static int +test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void) +{ + return test_snow3g_auth_cipher_sgl( + &snow3g_auth_cipher_partial_digest_encryption, + IN_PLACE, 1); +} - const uint8_t *reference_ciphertext = tdata->ciphertext.data + - (tdata->validCipherOffsetInBits.len >> 3); - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - reference_ciphertext, - tdata->validCipherLenInBits.len, - "KASUMI Ciphertext data not as expected"); +static int +test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void) +{ + return test_snow3g_auth_cipher_sgl( + &snow3g_auth_cipher_partial_digest_encryption, + OUT_OF_PLACE, 1); +} - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ut_params->digest, - tdata->digest.data, - DIGEST_BYTE_LENGTH_SNOW3G_UIA2, - "KASUMI Generated auth tag not as expected"); - return 0; +static int +test_snow3g_auth_cipher_with_digest_test_case_1(void) +{ + return test_snow3g_auth_cipher( + &snow3g_test_case_7, IN_PLACE, 0); } static int -test_zuc_encryption(const struct wireless_test_data *tdata) +test_kasumi_auth_cipher_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + return test_kasumi_auth_cipher( + &kasumi_test_case_3, IN_PLACE, 0); +} - int retval; - uint8_t *plaintext, *ciphertext; - unsigned plaintext_pad_len; - unsigned plaintext_len; +static int +test_kasumi_auth_cipher_test_case_2(void) +{ + return test_kasumi_auth_cipher( + &kasumi_auth_cipher_test_case_2, IN_PLACE, 0); +} - struct rte_cryptodev_sym_capability_idx cap_idx; +static int +test_kasumi_auth_cipher_test_case_2_oop(void) +{ + return test_kasumi_auth_cipher( + &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0); +} - /* Check if device supports ZUC EEA3 */ - cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3; +static int +test_kasumi_auth_cipher_test_case_2_sgl(void) +{ + return test_kasumi_auth_cipher_sgl( + &kasumi_auth_cipher_test_case_2, IN_PLACE, 0); +} - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) - return -ENOTSUP; +static int +test_kasumi_auth_cipher_test_case_2_oop_sgl(void) +{ + return test_kasumi_auth_cipher_sgl( + &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0); +} - /* Create ZUC session */ - retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_CIPHER_ZUC_EEA3, - tdata->key.data, tdata->key.len, - tdata->cipher_iv.len); - if (retval < 0) - return retval; +static int +test_kasumi_auth_cipher_verify_test_case_1(void) +{ + return test_kasumi_auth_cipher( + &kasumi_test_case_3, IN_PLACE, 1); +} - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); +static int +test_kasumi_auth_cipher_verify_test_case_2(void) +{ + return test_kasumi_auth_cipher( + &kasumi_auth_cipher_test_case_2, IN_PLACE, 1); +} - /* Clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); +static int +test_kasumi_auth_cipher_verify_test_case_2_oop(void) +{ + return test_kasumi_auth_cipher( + &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1); +} - plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple */ - /* of the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, plaintext_len); +static int +test_kasumi_auth_cipher_verify_test_case_2_sgl(void) +{ + return test_kasumi_auth_cipher_sgl( + &kasumi_auth_cipher_test_case_2, IN_PLACE, 1); +} - debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); +static int +test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void) +{ + return test_kasumi_auth_cipher_sgl( + &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1); +} - /* Create ZUC operation */ - retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, - tdata->cipher_iv.len, - tdata->plaintext.len, - 0); - if (retval < 0) - return retval; +static int +test_kasumi_cipher_auth_test_case_1(void) +{ + return test_kasumi_cipher_auth(&kasumi_test_case_6); +} - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); +static int +test_zuc_encryption_test_case_1(void) +{ + return test_zuc_encryption(&zuc_test_case_cipher_193b); +} - ut_params->obuf = ut_params->op->sym->m_dst; - if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); - else - ciphertext = plaintext; +static int +test_zuc_encryption_test_case_2(void) +{ + return test_zuc_encryption(&zuc_test_case_cipher_800b); +} - debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); +static int +test_zuc_encryption_test_case_3(void) +{ + return test_zuc_encryption(&zuc_test_case_cipher_1570b); +} - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - tdata->ciphertext.data, - tdata->validCipherLenInBits.len, - "ZUC Ciphertext data not as expected"); - return 0; +static int +test_zuc_encryption_test_case_4(void) +{ + return test_zuc_encryption(&zuc_test_case_cipher_2798b); } static int -test_zuc_encryption_sgl(const struct wireless_test_data *tdata) +test_zuc_encryption_test_case_5(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + return test_zuc_encryption(&zuc_test_case_cipher_4019b); +} - int retval; +static int +test_zuc_encryption_test_case_6_sgl(void) +{ + return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b); +} - unsigned int plaintext_pad_len; - unsigned int plaintext_len; - const uint8_t *ciphertext; - uint8_t ciphertext_buffer[2048]; - struct rte_cryptodev_info dev_info; +static int +test_zuc_hash_generate_test_case_1(void) +{ + return test_zuc_authentication(&zuc_test_case_auth_1b); +} - struct rte_cryptodev_sym_capability_idx cap_idx; +static int +test_zuc_hash_generate_test_case_2(void) +{ + return test_zuc_authentication(&zuc_test_case_auth_90b); +} - /* Check if device supports ZUC EEA3 */ - cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3; +static int +test_zuc_hash_generate_test_case_3(void) +{ + return test_zuc_authentication(&zuc_test_case_auth_577b); +} - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) +static int +test_zuc_hash_generate_test_case_4(void) +{ + return test_zuc_authentication(&zuc_test_case_auth_2079b); +} + +static int +test_zuc_hash_generate_test_case_5(void) +{ + return test_zuc_authentication(&zuc_test_auth_5670b); +} + +static int +test_zuc_hash_generate_test_case_6(void) +{ + return test_zuc_authentication(&zuc_test_case_auth_128b); +} + +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; - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + return test_zuc_authentication(&zuc_test_case_auth_2080b); +} - uint64_t feat_flags = dev_info.feature_flags; +static int +test_zuc_hash_generate_test_case_8(void) +{ + return test_zuc_authentication(&zuc_test_case_auth_584b); +} - if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { - printf("Device doesn't support in-place scatter-gather. " - "Test Skipped.\n"); +static int +test_zuc_cipher_auth_test_case_1(void) +{ + return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b); +} + +static int +test_zuc_cipher_auth_test_case_2(void) +{ + return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b); +} + +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; - } - plaintext_len = ceil_byte_length(tdata->plaintext.len); + return test_zuc_auth_cipher( + &zuc_auth_cipher_test_case_1, IN_PLACE, 0); +} - /* Append data which is padded to a multiple */ - /* of the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); +static int +test_zuc_auth_cipher_test_case_1_oop(void) +{ + return test_zuc_auth_cipher( + &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0); +} - ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, - plaintext_pad_len, 10, 0); +static int +test_zuc_auth_cipher_test_case_1_sgl(void) +{ + return test_zuc_auth_cipher_sgl( + &zuc_auth_cipher_test_case_1, IN_PLACE, 0); +} - pktmbuf_write(ut_params->ibuf, 0, plaintext_len, - tdata->plaintext.data); +static int +test_zuc_auth_cipher_test_case_1_oop_sgl(void) +{ + return test_zuc_auth_cipher_sgl( + &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0); +} - /* Create ZUC session */ - retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_CIPHER_ZUC_EEA3, - tdata->key.data, tdata->key.len, - tdata->cipher_iv.len); - if (retval < 0) - return retval; +static int +test_zuc_auth_cipher_verify_test_case_1(void) +{ + return test_zuc_auth_cipher( + &zuc_auth_cipher_test_case_1, IN_PLACE, 1); +} - /* Clear mbuf payload */ +static int +test_zuc_auth_cipher_verify_test_case_1_oop(void) +{ + return test_zuc_auth_cipher( + &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1); +} - pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); +static int +test_zuc_auth_cipher_verify_test_case_1_sgl(void) +{ + return test_zuc_auth_cipher_sgl( + &zuc_auth_cipher_test_case_1, IN_PLACE, 1); +} - /* Create ZUC operation */ - retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, - tdata->cipher_iv.len, tdata->plaintext.len, - 0); - if (retval < 0) - return retval; +static int +test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void) +{ + return test_zuc_auth_cipher_sgl( + &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1); +} - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); +static int +test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata) +{ + uint8_t dev_id = testsuite_params.valid_devs[0]; - ut_params->obuf = ut_params->op->sym->m_dst; - if (ut_params->obuf) - ciphertext = rte_pktmbuf_read(ut_params->obuf, - 0, plaintext_len, ciphertext_buffer); - else - ciphertext = rte_pktmbuf_read(ut_params->ibuf, - 0, plaintext_len, ciphertext_buffer); + struct rte_cryptodev_sym_capability_idx cap_idx; - /* Validate obuf */ - debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); + /* 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; - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - tdata->ciphertext.data, - tdata->validCipherLenInBits.len, - "ZUC Ciphertext data not as expected"); + /* 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_zuc_authentication(const struct wireless_test_data *tdata) +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; struct crypto_unittest_params *ut_params = &unittest_params; int retval; - unsigned plaintext_pad_len; - unsigned plaintext_len; - uint8_t *plaintext; - struct rte_cryptodev_sym_capability_idx cap_idx; + uint8_t *plaintext = NULL, *ciphertext = NULL; + unsigned int plaintext_pad_len; + unsigned int plaintext_len; + unsigned int ciphertext_pad_len; + unsigned int ciphertext_len; - /* Check if device supports ZUC EIA3 */ - cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; - cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; + struct rte_cryptodev_info dev_info; + struct rte_crypto_op *op; - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) + /* Check if device supports particular algorithms separately */ + if (test_mixed_check_if_unsupported(tdata)) return -ENOTSUP; - /* Create ZUC session */ - retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], - tdata->key.data, tdata->key.len, - tdata->auth_iv.len, tdata->digest.len, - RTE_CRYPTO_AUTH_OP_GENERATE, - RTE_CRYPTO_AUTH_ZUC_EIA3); - if (retval < 0) - return retval; + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - /* alloc mbuf and set payload */ - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + uint64_t feat_flags = dev_info.feature_flags; - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); - - plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple of */ - /* the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, plaintext_len); - - /* Create ZUC operation */ - retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, - tdata->auth_iv.data, tdata->auth_iv.len, - plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, - tdata->validAuthLenInBits.len, - 0); - if (retval < 0) - return retval; - - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - ut_params->obuf = ut_params->op->sym->m_src; - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); - ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len; - - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ut_params->digest, - tdata->digest.data, - DIGEST_BYTE_LENGTH_KASUMI_F9, - "ZUC Generated auth tag not as expected"); - - return 0; -} - -static int -test_zuc_auth_cipher(const struct wireless_test_data *tdata, - uint8_t op_mode, uint8_t verify) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - 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_cryptodev_sym_capability_idx cap_idx; - - /* Check if device supports ZUC EIA3 */ - cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; - cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; - - 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; - - if (op_mode == OUT_OF_PLACE) { - if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { - printf("Device doesn't support digest encrypted.\n"); - return -ENOTSUP; - } - } - - /* Create ZUC session */ - retval = create_wireless_algo_auth_cipher_session( - ts_params->valid_devs[0], - (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT - : RTE_CRYPTO_CIPHER_OP_ENCRYPT), - (verify ? RTE_CRYPTO_AUTH_OP_VERIFY - : RTE_CRYPTO_AUTH_OP_GENERATE), - RTE_CRYPTO_AUTH_ZUC_EIA3, - RTE_CRYPTO_CIPHER_ZUC_EEA3, - tdata->key.data, tdata->key.len, - tdata->auth_iv.len, tdata->digest.len, - tdata->cipher_iv.len); + 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; @@ -5697,117 +6206,131 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata, 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)); + rte_pktmbuf_tailroom(ut_params->obuf)); - ciphertext_len = ceil_byte_length(tdata->ciphertext.len); - plaintext_len = ceil_byte_length(tdata->plaintext.len); + 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); + 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); + ciphertext_len); } else { plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); + 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); + debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); } - /* Create ZUC operation */ + /* Create the operation */ retval = create_wireless_algo_auth_cipher_operation( - 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 ? - (verify ? ciphertext_pad_len : plaintext_pad_len) - : tdata->digest.offset_bytes), - tdata->validCipherLenInBits.len, - tdata->validCipherOffsetInBits.len, - tdata->validAuthLenInBits.len, - 0, - op_mode, 0, verify); + 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; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + 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); - + 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; + plaintext = ciphertext + + (tdata->cipher.offset_bits >> 3); debug_hexdump(stdout, "plaintext:", plaintext, - (tdata->plaintext.len >> 3) - tdata->digest.len); + tdata->plaintext.len_bits >> 3); debug_hexdump(stdout, "plaintext expected:", - tdata->plaintext.data, - (tdata->plaintext.len >> 3) - tdata->digest.len); + tdata->plaintext.data, + tdata->plaintext.len_bits >> 3); } else { if (ut_params->obuf) ciphertext = rte_pktmbuf_mtod(ut_params->obuf, - uint8_t *); + uint8_t *); else ciphertext = plaintext; debug_hexdump(stdout, "ciphertext:", ciphertext, - ciphertext_len); + ciphertext_len); debug_hexdump(stdout, "ciphertext expected:", - tdata->ciphertext.data, tdata->ciphertext.len >> 3); + tdata->ciphertext.data, + tdata->ciphertext.len_bits >> 3); - ut_params->digest = rte_pktmbuf_mtod( - ut_params->obuf, uint8_t *) + - (tdata->digest.offset_bytes == 0 ? - plaintext_pad_len : tdata->digest.offset_bytes); + 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.len); + tdata->digest_enc.len); debug_hexdump(stdout, "digest expected:", - tdata->digest.data, tdata->digest.len); + 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 >> 3, - "ZUC Plaintext data not as expected"); + 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->ciphertext.len >> 3, - "ZUC Ciphertext data not as expected"); + ciphertext, + tdata->ciphertext.data, + tdata->validDataLen.len_bits, + "Ciphertext data not as expected"); TEST_ASSERT_BUFFERS_ARE_EQUAL( - ut_params->digest, - tdata->digest.data, - DIGEST_BYTE_LENGTH_KASUMI_F9, - "ZUC Generated auth tag not as expected"); + ut_params->digest, + tdata->digest_enc.data, + DIGEST_BYTE_LENGTH_SNOW3G_UIA2, + "Generated auth tag not as expected"); } + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + return 0; } static int -test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, +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; @@ -5826,14 +6349,10 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, uint8_t digest_buffer[10000]; struct rte_cryptodev_info dev_info; - struct rte_cryptodev_sym_capability_idx cap_idx; - - /* Check if device supports ZUC EIA3 */ - cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; - cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; + struct rte_crypto_op *op; - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) + /* Check if device supports particular algorithms */ + if (test_mixed_check_if_unsupported(tdata)) return -ENOTSUP; rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); @@ -5858,38 +6377,46 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, } } - /* Create ZUC session */ - retval = create_wireless_algo_auth_cipher_session( - ts_params->valid_devs[0], - (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT - : RTE_CRYPTO_CIPHER_OP_ENCRYPT), - (verify ? RTE_CRYPTO_AUTH_OP_VERIFY - : RTE_CRYPTO_AUTH_OP_GENERATE), - RTE_CRYPTO_AUTH_ZUC_EIA3, - RTE_CRYPTO_CIPHER_ZUC_EEA3, - tdata->key.data, tdata->key.len, - tdata->auth_iv.len, tdata->digest.len, - tdata->cipher_iv.len); - - if (retval < 0) - return retval; - - ciphertext_len = ceil_byte_length(tdata->ciphertext.len); - plaintext_len = ceil_byte_length(tdata->plaintext.len); - ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); - plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); - - ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, - plaintext_pad_len, 15, 0); - TEST_ASSERT_NOT_NULL(ut_params->ibuf, - "Failed to allocate input buffer in mempool"); - - 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"); - } + /* 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; + + 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); + + 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"); + + 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"); + } if (verify) { pktmbuf_write(ut_params->ibuf, 0, ciphertext_len, @@ -5908,30 +6435,41 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, } memset(buffer, 0, sizeof(buffer)); - /* Create ZUC operation */ + /* Create the operation */ retval = create_wireless_algo_auth_cipher_operation( - tdata->digest.data, tdata->digest.len, - tdata->cipher_iv.data, tdata->cipher_iv.len, - NULL, 0, - (tdata->digest.offset_bytes == 0 ? - (verify ? ciphertext_pad_len : plaintext_pad_len) - : tdata->digest.offset_bytes), - tdata->validCipherLenInBits.len, - tdata->validCipherOffsetInBits.len, - tdata->validAuthLenInBits.len, - 0, - op_mode, 1, verify); + 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); if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + 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); + ut_params->op->sym->m_src : ut_params->op->sym->m_dst); if (verify) { if (ut_params->obuf) @@ -5942,10 +6480,12 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, plaintext_len, buffer); debug_hexdump(stdout, "plaintext:", plaintext, - (tdata->plaintext.len >> 3) - tdata->digest.len); + (tdata->plaintext.len_bits >> 3) - + tdata->digest_enc.len); debug_hexdump(stdout, "plaintext expected:", - tdata->plaintext.data, - (tdata->plaintext.len >> 3) - tdata->digest.len); + 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, @@ -5957,1860 +6497,1783 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); debug_hexdump(stdout, "ciphertext expected:", - tdata->ciphertext.data, tdata->ciphertext.len >> 3); + tdata->ciphertext.data, + tdata->ciphertext.len_bits >> 3); if (ut_params->obuf) digest = rte_pktmbuf_read(ut_params->obuf, - (tdata->digest.offset_bytes == 0 ? - plaintext_pad_len : tdata->digest.offset_bytes), - tdata->digest.len, digest_buffer); + (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.offset_bytes == 0 ? - plaintext_pad_len : tdata->digest.offset_bytes), - tdata->digest.len, digest_buffer); + (tdata->digest_enc.offset == 0 ? + plaintext_pad_len : + tdata->digest_enc.offset), + tdata->digest_enc.len, digest_buffer); debug_hexdump(stdout, "digest:", digest, - tdata->digest.len); + tdata->digest_enc.len); debug_hexdump(stdout, "digest expected:", - tdata->digest.data, tdata->digest.len); + 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 >> 3, - "ZUC Plaintext data not as expected"); + 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->validDataLenInBits.len, - "ZUC Ciphertext data not as expected"); - + ciphertext, + tdata->ciphertext.data, + tdata->validDataLen.len_bits, + "Ciphertext data not as expected"); TEST_ASSERT_BUFFERS_ARE_EQUAL( - digest, - tdata->digest.data, - DIGEST_BYTE_LENGTH_KASUMI_F9, - "ZUC Generated auth tag not as expected"); + digest, + tdata->digest_enc.data, + tdata->digest_enc.len, + "Generated auth tag not as expected"); } + + 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_kasumi_encryption_test_case_1(void) +test_aes_cmac_aes_ctr_digest_enc_test_case_1(void) { - return test_kasumi_encryption(&kasumi_test_case_1); + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0); } static int -test_kasumi_encryption_test_case_1_sgl(void) +test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void) { - return test_kasumi_encryption_sgl(&kasumi_test_case_1); + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); } static int -test_kasumi_encryption_test_case_1_oop(void) +test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void) { - return test_kasumi_encryption_oop(&kasumi_test_case_1); + return test_mixed_auth_cipher_sgl( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0); } static int -test_kasumi_encryption_test_case_1_oop_sgl(void) +test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void) { - return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1); + return test_mixed_auth_cipher_sgl( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); } static int -test_kasumi_encryption_test_case_2(void) +test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void) { - return test_kasumi_encryption(&kasumi_test_case_2); + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1); } static int -test_kasumi_encryption_test_case_3(void) +test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void) { - return test_kasumi_encryption(&kasumi_test_case_3); + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); } static int -test_kasumi_encryption_test_case_4(void) +test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void) { - return test_kasumi_encryption(&kasumi_test_case_4); + return test_mixed_auth_cipher_sgl( + &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1); } static int -test_kasumi_encryption_test_case_5(void) +test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void) { - return test_kasumi_encryption(&kasumi_test_case_5); + 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_kasumi_decryption_test_case_1(void) +test_auth_zuc_cipher_snow_test_case_1(void) { - return test_kasumi_decryption(&kasumi_test_case_1); + return test_mixed_auth_cipher( + &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0); } static int -test_kasumi_decryption_test_case_1_oop(void) +test_verify_auth_zuc_cipher_snow_test_case_1(void) { - return test_kasumi_decryption_oop(&kasumi_test_case_1); + return test_mixed_auth_cipher( + &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1); } static int -test_kasumi_decryption_test_case_2(void) +test_auth_aes_cmac_cipher_snow_test_case_1(void) { - return test_kasumi_decryption(&kasumi_test_case_2); + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0); } static int -test_kasumi_decryption_test_case_3(void) +test_verify_auth_aes_cmac_cipher_snow_test_case_1(void) { - return test_kasumi_decryption(&kasumi_test_case_3); + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1); } static int -test_kasumi_decryption_test_case_4(void) +test_auth_zuc_cipher_aes_ctr_test_case_1(void) { - return test_kasumi_decryption(&kasumi_test_case_4); + return test_mixed_auth_cipher( + &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); } static int -test_kasumi_decryption_test_case_5(void) +test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void) { - return test_kasumi_decryption(&kasumi_test_case_5); + return test_mixed_auth_cipher( + &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); } + static int -test_snow3g_encryption_test_case_1(void) +test_auth_snow_cipher_aes_ctr_test_case_1(void) { - return test_snow3g_encryption(&snow3g_test_case_1); + return test_mixed_auth_cipher( + &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); } static int -test_snow3g_encryption_test_case_1_oop(void) +test_verify_auth_snow_cipher_aes_ctr_test_case_1(void) { - return test_snow3g_encryption_oop(&snow3g_test_case_1); + return test_mixed_auth_cipher( + &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); } static int -test_snow3g_encryption_test_case_1_oop_sgl(void) +test_auth_snow_cipher_zuc_test_case_1(void) { - return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1); + return test_mixed_auth_cipher( + &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); } - static int -test_snow3g_encryption_test_case_1_offset_oop(void) +test_verify_auth_snow_cipher_zuc_test_case_1(void) { - return test_snow3g_encryption_offset_oop(&snow3g_test_case_1); + return test_mixed_auth_cipher( + &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); } static int -test_snow3g_encryption_test_case_2(void) +test_auth_aes_cmac_cipher_zuc_test_case_1(void) { - return test_snow3g_encryption(&snow3g_test_case_2); + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); } static int -test_snow3g_encryption_test_case_3(void) +test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void) { - return test_snow3g_encryption(&snow3g_test_case_3); + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); } static int -test_snow3g_encryption_test_case_4(void) +test_auth_null_cipher_snow_test_case_1(void) { - return test_snow3g_encryption(&snow3g_test_case_4); + return test_mixed_auth_cipher( + &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0); } static int -test_snow3g_encryption_test_case_5(void) +test_verify_auth_null_cipher_snow_test_case_1(void) { - return test_snow3g_encryption(&snow3g_test_case_5); + return test_mixed_auth_cipher( + &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1); } static int -test_snow3g_decryption_test_case_1(void) +test_auth_null_cipher_zuc_test_case_1(void) { - return test_snow3g_decryption(&snow3g_test_case_1); -} - -static int -test_snow3g_decryption_test_case_1_oop(void) -{ - return test_snow3g_decryption_oop(&snow3g_test_case_1); + return test_mixed_auth_cipher( + &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); } static int -test_snow3g_decryption_test_case_2(void) +test_verify_auth_null_cipher_zuc_test_case_1(void) { - return test_snow3g_decryption(&snow3g_test_case_2); + return test_mixed_auth_cipher( + &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); } static int -test_snow3g_decryption_test_case_3(void) +test_auth_snow_cipher_null_test_case_1(void) { - return test_snow3g_decryption(&snow3g_test_case_3); + return test_mixed_auth_cipher( + &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0); } static int -test_snow3g_decryption_test_case_4(void) +test_verify_auth_snow_cipher_null_test_case_1(void) { - return test_snow3g_decryption(&snow3g_test_case_4); + return test_mixed_auth_cipher( + &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1); } static int -test_snow3g_decryption_test_case_5(void) -{ - return test_snow3g_decryption(&snow3g_test_case_5); -} - -/* - * Function prepares snow3g_hash_test_data from snow3g_test_data. - * Pattern digest from snow3g_test_data must be allocated as - * 4 last bytes in plaintext. - */ -static void -snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern, - struct snow3g_hash_test_data *output) +test_auth_zuc_cipher_null_test_case_1(void) { - if ((pattern != NULL) && (output != NULL)) { - output->key.len = pattern->key.len; - - memcpy(output->key.data, - pattern->key.data, pattern->key.len); - - output->auth_iv.len = pattern->auth_iv.len; - - memcpy(output->auth_iv.data, - pattern->auth_iv.data, pattern->auth_iv.len); - - output->plaintext.len = pattern->plaintext.len; - - memcpy(output->plaintext.data, - pattern->plaintext.data, pattern->plaintext.len >> 3); - - output->digest.len = pattern->digest.len; - - memcpy(output->digest.data, - &pattern->plaintext.data[pattern->digest.offset_bytes], - pattern->digest.len); - - output->validAuthLenInBits.len = - pattern->validAuthLenInBits.len; - } + return test_mixed_auth_cipher( + &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0); } -/* - * Test case verify computed cipher and digest from snow3g_test_case_7 data. - */ static int -test_snow3g_decryption_with_digest_test_case_1(void) +test_verify_auth_zuc_cipher_null_test_case_1(void) { - struct snow3g_hash_test_data snow3g_hash_data; - - /* - * Function prepare data for hash veryfication test case. - * Digest is allocated in 4 last bytes in plaintext, pattern. - */ - snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data); - - return test_snow3g_decryption(&snow3g_test_case_7) & - test_snow3g_authentication_verify(&snow3g_hash_data); + return test_mixed_auth_cipher( + &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1); } static int -test_snow3g_cipher_auth_test_case_1(void) +test_auth_null_cipher_aes_ctr_test_case_1(void) { - return test_snow3g_cipher_auth(&snow3g_test_case_3); + return test_mixed_auth_cipher( + &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); } static int -test_snow3g_auth_cipher_test_case_1(void) +test_verify_auth_null_cipher_aes_ctr_test_case_1(void) { - return test_snow3g_auth_cipher( - &snow3g_auth_cipher_test_case_1, IN_PLACE, 0); + return test_mixed_auth_cipher( + &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); } static int -test_snow3g_auth_cipher_test_case_2(void) +test_auth_aes_cmac_cipher_null_test_case_1(void) { - return test_snow3g_auth_cipher( - &snow3g_auth_cipher_test_case_2, IN_PLACE, 0); + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0); } static int -test_snow3g_auth_cipher_test_case_2_oop(void) +test_verify_auth_aes_cmac_cipher_null_test_case_1(void) { - return test_snow3g_auth_cipher( - &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0); + return test_mixed_auth_cipher( + &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1); } -static int -test_snow3g_auth_cipher_part_digest_enc(void) -{ - return test_snow3g_auth_cipher( - &snow3g_auth_cipher_partial_digest_encryption, - IN_PLACE, 0); -} +/* ***** AEAD algorithm Tests ***** */ static int -test_snow3g_auth_cipher_part_digest_enc_oop(void) +create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo, + enum rte_crypto_aead_operation op, + const uint8_t *key, const uint8_t key_len, + const uint16_t aad_len, const uint8_t auth_len, + uint8_t iv_len) { - return test_snow3g_auth_cipher( - &snow3g_auth_cipher_partial_digest_encryption, - OUT_OF_PLACE, 0); -} + uint8_t aead_key[key_len]; -static int -test_snow3g_auth_cipher_test_case_3_sgl(void) -{ - return test_snow3g_auth_cipher_sgl( - &snow3g_auth_cipher_test_case_3, IN_PLACE, 0); -} + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; -static int -test_snow3g_auth_cipher_test_case_3_oop_sgl(void) -{ - return test_snow3g_auth_cipher_sgl( - &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0); -} + memcpy(aead_key, key, key_len); -static int -test_snow3g_auth_cipher_part_digest_enc_sgl(void) -{ - return test_snow3g_auth_cipher_sgl( - &snow3g_auth_cipher_partial_digest_encryption, - IN_PLACE, 0); -} + /* Setup AEAD Parameters */ + ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD; + ut_params->aead_xform.next = NULL; + ut_params->aead_xform.aead.algo = algo; + ut_params->aead_xform.aead.op = op; + ut_params->aead_xform.aead.key.data = aead_key; + ut_params->aead_xform.aead.key.length = key_len; + ut_params->aead_xform.aead.iv.offset = IV_OFFSET; + ut_params->aead_xform.aead.iv.length = iv_len; + ut_params->aead_xform.aead.digest_length = auth_len; + ut_params->aead_xform.aead.aad_length = aad_len; -static int -test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void) -{ - return test_snow3g_auth_cipher_sgl( - &snow3g_auth_cipher_partial_digest_encryption, - OUT_OF_PLACE, 0); -} + debug_hexdump(stdout, "key:", key, key_len); -static int -test_snow3g_auth_cipher_verify_test_case_1(void) -{ - return test_snow3g_auth_cipher( - &snow3g_auth_cipher_test_case_1, IN_PLACE, 1); -} + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); -static int -test_snow3g_auth_cipher_verify_test_case_2(void) -{ - return test_snow3g_auth_cipher( - &snow3g_auth_cipher_test_case_2, IN_PLACE, 1); -} + rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->aead_xform, + ts_params->session_priv_mpool); -static int -test_snow3g_auth_cipher_verify_test_case_2_oop(void) -{ - return test_snow3g_auth_cipher( - &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1); -} + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); -static int -test_snow3g_auth_cipher_verify_part_digest_enc(void) -{ - return test_snow3g_auth_cipher( - &snow3g_auth_cipher_partial_digest_encryption, - IN_PLACE, 1); + return 0; } static int -test_snow3g_auth_cipher_verify_part_digest_enc_oop(void) +create_aead_xform(struct rte_crypto_op *op, + enum rte_crypto_aead_algorithm algo, + enum rte_crypto_aead_operation aead_op, + uint8_t *key, const uint8_t key_len, + const uint8_t aad_len, const uint8_t auth_len, + uint8_t iv_len) { - return test_snow3g_auth_cipher( - &snow3g_auth_cipher_partial_digest_encryption, - OUT_OF_PLACE, 1); -} + TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1), + "failed to allocate space for crypto transform"); -static int -test_snow3g_auth_cipher_verify_test_case_3_sgl(void) -{ - return test_snow3g_auth_cipher_sgl( - &snow3g_auth_cipher_test_case_3, IN_PLACE, 1); -} + struct rte_crypto_sym_op *sym_op = op->sym; -static int -test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void) -{ - return test_snow3g_auth_cipher_sgl( - &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1); -} + /* Setup AEAD Parameters */ + sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD; + sym_op->xform->next = NULL; + sym_op->xform->aead.algo = algo; + sym_op->xform->aead.op = aead_op; + sym_op->xform->aead.key.data = key; + sym_op->xform->aead.key.length = key_len; + sym_op->xform->aead.iv.offset = IV_OFFSET; + sym_op->xform->aead.iv.length = iv_len; + sym_op->xform->aead.digest_length = auth_len; + sym_op->xform->aead.aad_length = aad_len; -static int -test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void) -{ - return test_snow3g_auth_cipher_sgl( - &snow3g_auth_cipher_partial_digest_encryption, - IN_PLACE, 1); -} + debug_hexdump(stdout, "key:", key, key_len); -static int -test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void) -{ - return test_snow3g_auth_cipher_sgl( - &snow3g_auth_cipher_partial_digest_encryption, - OUT_OF_PLACE, 1); + return 0; } static int -test_snow3g_auth_cipher_with_digest_test_case_1(void) +create_aead_operation(enum rte_crypto_aead_operation op, + const struct aead_test_data *tdata) { - return test_snow3g_auth_cipher( - &snow3g_test_case_7, IN_PLACE, 0); -} + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; -static int -test_kasumi_auth_cipher_test_case_1(void) -{ - return test_kasumi_auth_cipher( - &kasumi_test_case_3, IN_PLACE, 0); -} - -static int -test_kasumi_auth_cipher_test_case_2(void) -{ - return test_kasumi_auth_cipher( - &kasumi_auth_cipher_test_case_2, IN_PLACE, 0); -} + uint8_t *plaintext, *ciphertext; + unsigned int aad_pad_len, plaintext_pad_len; -static int -test_kasumi_auth_cipher_test_case_2_oop(void) -{ - return test_kasumi_auth_cipher( - &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0); -} + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); -static int -test_kasumi_auth_cipher_test_case_2_sgl(void) -{ - return test_kasumi_auth_cipher_sgl( - &kasumi_auth_cipher_test_case_2, IN_PLACE, 0); -} + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; -static int -test_kasumi_auth_cipher_test_case_2_oop_sgl(void) -{ - return test_kasumi_auth_cipher_sgl( - &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0); -} + /* Append aad data */ + if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) { + aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16); + sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + aad_pad_len); + TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data, + "no room to append aad"); -static int -test_kasumi_auth_cipher_verify_test_case_1(void) -{ - return test_kasumi_auth_cipher( - &kasumi_test_case_3, IN_PLACE, 1); -} + sym_op->aead.aad.phys_addr = + rte_pktmbuf_iova(ut_params->ibuf); + /* Copy AAD 18 bytes after the AAD pointer, according to the API */ + memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len); + debug_hexdump(stdout, "aad:", sym_op->aead.aad.data, + tdata->aad.len); -static int -test_kasumi_auth_cipher_verify_test_case_2(void) -{ - return test_kasumi_auth_cipher( - &kasumi_auth_cipher_test_case_2, IN_PLACE, 1); -} + /* Append IV at the end of the crypto operation*/ + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); -static int -test_kasumi_auth_cipher_verify_test_case_2_oop(void) -{ - return test_kasumi_auth_cipher( - &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1); -} + /* Copy IV 1 byte after the IV pointer, according to the API */ + rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len); + debug_hexdump(stdout, "iv:", iv_ptr, + tdata->iv.len); + } else { + aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); + sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + aad_pad_len); + TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data, + "no room to append aad"); -static int -test_kasumi_auth_cipher_verify_test_case_2_sgl(void) -{ - return test_kasumi_auth_cipher_sgl( - &kasumi_auth_cipher_test_case_2, IN_PLACE, 1); -} + sym_op->aead.aad.phys_addr = + rte_pktmbuf_iova(ut_params->ibuf); + memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len); + debug_hexdump(stdout, "aad:", sym_op->aead.aad.data, + tdata->aad.len); -static int -test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void) -{ - return test_kasumi_auth_cipher_sgl( - &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1); -} + /* Append IV at the end of the crypto operation*/ + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); -static int -test_kasumi_cipher_auth_test_case_1(void) -{ - return test_kasumi_cipher_auth(&kasumi_test_case_6); -} + if (tdata->iv.len == 0) { + rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH); + debug_hexdump(stdout, "iv:", iv_ptr, + AES_GCM_J0_LENGTH); + } else { + rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); + debug_hexdump(stdout, "iv:", iv_ptr, + tdata->iv.len); + } + } -static int -test_zuc_encryption_test_case_1(void) -{ - return test_zuc_encryption(&zuc_test_case_cipher_193b); -} + /* Append plaintext/ciphertext */ + if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) { + plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); -static int -test_zuc_encryption_test_case_2(void) -{ - return test_zuc_encryption(&zuc_test_case_cipher_800b); -} + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); + debug_hexdump(stdout, "plaintext:", plaintext, + tdata->plaintext.len); -static int -test_zuc_encryption_test_case_3(void) -{ - return test_zuc_encryption(&zuc_test_case_cipher_1570b); -} + if (ut_params->obuf) { + ciphertext = (uint8_t *)rte_pktmbuf_append( + ut_params->obuf, + plaintext_pad_len + aad_pad_len); + TEST_ASSERT_NOT_NULL(ciphertext, + "no room to append ciphertext"); -static int -test_zuc_encryption_test_case_4(void) -{ - return test_zuc_encryption(&zuc_test_case_cipher_2798b); -} + memset(ciphertext + aad_pad_len, 0, + tdata->ciphertext.len); + } + } else { + plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16); + ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + TEST_ASSERT_NOT_NULL(ciphertext, + "no room to append ciphertext"); -static int -test_zuc_encryption_test_case_5(void) -{ - return test_zuc_encryption(&zuc_test_case_cipher_4019b); -} + memcpy(ciphertext, tdata->ciphertext.data, + tdata->ciphertext.len); + debug_hexdump(stdout, "ciphertext:", ciphertext, + tdata->ciphertext.len); -static int -test_zuc_encryption_test_case_6_sgl(void) -{ - return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b); -} + if (ut_params->obuf) { + plaintext = (uint8_t *)rte_pktmbuf_append( + ut_params->obuf, + plaintext_pad_len + aad_pad_len); + TEST_ASSERT_NOT_NULL(plaintext, + "no room to append plaintext"); -static int -test_zuc_hash_generate_test_case_1(void) -{ - return test_zuc_authentication(&zuc_test_case_auth_1b); -} + memset(plaintext + aad_pad_len, 0, + tdata->plaintext.len); + } + } -static int -test_zuc_hash_generate_test_case_2(void) -{ - return test_zuc_authentication(&zuc_test_case_auth_90b); -} + /* Append digest data */ + if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) { + sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->obuf ? ut_params->obuf : + ut_params->ibuf, + tdata->auth_tag.len); + TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, + "no room to append digest"); + memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len); + sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset( + ut_params->obuf ? ut_params->obuf : + ut_params->ibuf, + plaintext_pad_len + + aad_pad_len); + } else { + sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, tdata->auth_tag.len); + TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, + "no room to append digest"); + sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset( + ut_params->ibuf, + plaintext_pad_len + aad_pad_len); -static int -test_zuc_hash_generate_test_case_3(void) -{ - return test_zuc_authentication(&zuc_test_case_auth_577b); -} + rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data, + tdata->auth_tag.len); + debug_hexdump(stdout, "digest:", + sym_op->aead.digest.data, + tdata->auth_tag.len); + } -static int -test_zuc_hash_generate_test_case_4(void) -{ - return test_zuc_authentication(&zuc_test_case_auth_2079b); -} + sym_op->aead.data.length = tdata->plaintext.len; + sym_op->aead.data.offset = aad_pad_len; -static int -test_zuc_hash_generate_test_case_5(void) -{ - return test_zuc_authentication(&zuc_test_auth_5670b); + return 0; } static int -test_zuc_hash_generate_test_case_6(void) +test_authenticated_encryption(const struct aead_test_data *tdata) { - return test_zuc_authentication(&zuc_test_case_auth_128b); -} + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; -static int -test_zuc_hash_generate_test_case_7(void) -{ - return test_zuc_authentication(&zuc_test_case_auth_2080b); -} + int retval; + uint8_t *ciphertext, *auth_tag; + uint16_t plaintext_pad_len; + uint32_t i; -static int -test_zuc_hash_generate_test_case_8(void) -{ - return test_zuc_authentication(&zuc_test_case_auth_584b); -} + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + const struct rte_cryptodev_symmetric_capability *capability; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; + cap_idx.algo.aead = tdata->algo; + capability = rte_cryptodev_sym_capability_get( + ts_params->valid_devs[0], &cap_idx); + if (capability == NULL) + return -ENOTSUP; + if (rte_cryptodev_sym_capability_check_aead( + capability, tdata->key.len, tdata->auth_tag.len, + tdata->aad.len, tdata->iv.len)) + return -ENOTSUP; -static int -test_zuc_cipher_auth_test_case_1(void) -{ - return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b); -} - -static int -test_zuc_cipher_auth_test_case_2(void) -{ - return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b); -} + /* Create AEAD session */ + retval = create_aead_session(ts_params->valid_devs[0], + tdata->algo, + RTE_CRYPTO_AEAD_OP_ENCRYPT, + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len, + tdata->iv.len); + if (retval < 0) + return retval; -static int -test_zuc_auth_cipher_test_case_1(void) -{ - return test_zuc_auth_cipher( - &zuc_auth_cipher_test_case_1, IN_PLACE, 0); -} + if (tdata->aad.len > MBUF_SIZE) { + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); + /* Populate full size of add data */ + for (i = 32; i < MAX_AAD_LENGTH; i += 32) + memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); + } else + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); -static int -test_zuc_auth_cipher_test_case_1_oop(void) -{ - return test_zuc_auth_cipher( - &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0); -} + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); -static int -test_zuc_auth_cipher_test_case_1_sgl(void) -{ - return test_zuc_auth_cipher_sgl( - &zuc_auth_cipher_test_case_1, IN_PLACE, 0); -} + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); + if (retval < 0) + return retval; -static int -test_zuc_auth_cipher_test_case_1_oop_sgl(void) -{ - return test_zuc_auth_cipher_sgl( - &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0); -} + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); -static int -test_zuc_auth_cipher_verify_test_case_1(void) -{ - return test_zuc_auth_cipher( - &zuc_auth_cipher_test_case_1, IN_PLACE, 1); -} + ut_params->op->sym->m_src = ut_params->ibuf; -static int -test_zuc_auth_cipher_verify_test_case_1_oop(void) -{ - return test_zuc_auth_cipher( - &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1); -} + /* Process crypto operation */ + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op); + else + TEST_ASSERT_NOT_NULL( + process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); -static int -test_zuc_auth_cipher_verify_test_case_1_sgl(void) -{ - return test_zuc_auth_cipher_sgl( - &zuc_auth_cipher_test_case_1, IN_PLACE, 1); -} + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); -static int -test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void) -{ - return test_zuc_auth_cipher_sgl( - &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1); -} + plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); -static int -test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata) -{ - uint8_t dev_id = testsuite_params.valid_devs[0]; + if (ut_params->op->sym->m_dst) { + ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, + uint8_t *); + auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, + uint8_t *, plaintext_pad_len); + } else { + ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, + uint8_t *, + ut_params->op->sym->cipher.data.offset); + auth_tag = ciphertext + plaintext_pad_len; + } - struct rte_cryptodev_sym_capability_idx cap_idx; + debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); + debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); - /* 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; + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ciphertext, + tdata->ciphertext.data, + tdata->ciphertext.len, + "Ciphertext data not as expected"); - /* 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; + TEST_ASSERT_BUFFERS_ARE_EQUAL( + auth_tag, + tdata->auth_tag.data, + tdata->auth_tag.len, + "Generated auth tag not as expected"); return 0; + } +#ifdef RTE_LIBRTE_SECURITY +/* Basic algorithm run function for async inplace mode. + * Creates a session from input parameters and runs one operation + * on input_vec. Checks the output of the crypto operation against + * output_vec. + */ static int -test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata, - uint8_t op_mode, uint8_t verify) +test_pdcp_proto(int i, int oop, + enum rte_crypto_cipher_operation opc, + enum rte_crypto_auth_operation opa, + uint8_t *input_vec, + unsigned int input_vec_len, + uint8_t *output_vec, + unsigned int output_vec_len) { struct crypto_testsuite_params *ts_params = &testsuite_params; 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]); - 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; + /* Verify the capabilities */ + struct rte_security_capability_idx sec_cap_idx; - /* Check if device supports particular algorithms separately */ - if (test_mixed_check_if_unsupported(tdata)) + 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; - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - - 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; - } - } - - /* 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; - + /* Generate test mbuf data */ 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)); + rte_pktmbuf_tailroom(ut_params->ibuf)); - 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); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + input_vec_len); + memcpy(plaintext, input_vec, input_vec_len); - 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); + /* Out of place support */ + if (oop) { + /* + * For out-op-place we need to alloc another mbuf + */ + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + rte_pktmbuf_append(ut_params->obuf, output_vec_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); + /* Set crypto type as IPSEC */ + ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; - /* 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; + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg; + ut_params->cipher_xform.cipher.op = opc; + ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i]; + ut_params->cipher_xform.cipher.key.length = + pdcp_test_params[i].cipher_key_len; + ut_params->cipher_xform.cipher.iv.length = 0; + + /* Setup HMAC Parameters if ICV header is required */ + if (pdcp_test_params[i].auth_alg != 0) { + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg; + ut_params->auth_xform.auth.op = opa; + ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i]; + ut_params->auth_xform.auth.key.length = + pdcp_test_params[i].auth_key_len; + + ut_params->cipher_xform.next = &ut_params->auth_xform; + } else { + ut_params->cipher_xform.next = NULL; } - ut_params->op = op; - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + struct rte_security_session_conf sess_conf = { + .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, + .protocol = RTE_SECURITY_PROTOCOL_PDCP, + {.pdcp = { + .bearer = pdcp_test_bearer[i], + .domain = pdcp_test_params[i].domain, + .pkt_dir = pdcp_test_packet_direction[i], + .sn_size = pdcp_test_data_sn_size[i], + .hfn = pdcp_test_hfn[i], + .hfn_threshold = pdcp_test_hfn_threshold[i], + } }, + .crypto_xform = &ut_params->cipher_xform + }; - ut_params->obuf = (op_mode == IN_PLACE ? - ut_params->op->sym->m_src : ut_params->op->sym->m_dst); + /* Create security session */ + ut_params->sec_session = rte_security_session_create(ctx, + &sess_conf, ts_params->session_priv_mpool); - if (verify) { - if (ut_params->obuf) - plaintext = rte_pktmbuf_mtod(ut_params->obuf, - uint8_t *); - else - plaintext = ciphertext + - (tdata->cipher.offset_bits >> 3); + if (!ut_params->sec_session) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, "Failed to allocate session"); + ret = TEST_FAILED; + goto on_err; + } - 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; + /* Generate crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + if (!ut_params->op) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, + "Failed to allocate symmetric crypto operation struct"); + ret = TEST_FAILED; + goto on_err; + } - debug_hexdump(stdout, "ciphertext:", ciphertext, - ciphertext_len); - debug_hexdump(stdout, "ciphertext expected:", - tdata->ciphertext.data, - tdata->ciphertext.len_bits >> 3); + rte_security_attach_session(ut_params->op, ut_params->sec_session); - ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + (tdata->digest_enc.offset == 0 ? - plaintext_pad_len : tdata->digest_enc.offset); + /* set crypto operation source mbuf */ + ut_params->op->sym->m_src = ut_params->ibuf; + if (oop) + ut_params->op->sym->m_dst = ut_params->obuf; - debug_hexdump(stdout, "digest:", ut_params->digest, - tdata->digest_enc.len); - debug_hexdump(stdout, "digest expected:", - tdata->digest_enc.data, - tdata->digest_enc.len); + /* Process crypto operation */ + if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) + == NULL) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, + "failed to process sym crypto op"); + ret = TEST_FAILED; + goto on_err; + } + + if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, "crypto op processing failed"); + ret = TEST_FAILED; + goto on_err; } /* 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"); + uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src, + uint8_t *); + if (oop) { + ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, + uint8_t *); + } - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ut_params->digest, - tdata->digest_enc.data, - DIGEST_BYTE_LENGTH_SNOW3G_UIA2, - "Generated auth tag not as expected"); + if (memcmp(ciphertext, output_vec, output_vec_len)) { + printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); + rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len); + rte_hexdump(stdout, "reference", output_vec, output_vec_len); + ret = TEST_FAILED; + goto on_err; } - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing failed"); +on_err: + rte_crypto_op_free(ut_params->op); + ut_params->op = NULL; - return 0; + if (ut_params->sec_session) + rte_security_session_destroy(ctx, ut_params->sec_session); + ut_params->sec_session = NULL; + + rte_pktmbuf_free(ut_params->ibuf); + ut_params->ibuf = NULL; + if (oop) { + rte_pktmbuf_free(ut_params->obuf); + ut_params->obuf = NULL; + } + + return ret; } static int -test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata, - uint8_t op_mode, uint8_t verify) +test_pdcp_proto_SGL(int i, int oop, + enum rte_crypto_cipher_operation opc, + enum rte_crypto_auth_operation opa, + uint8_t *input_vec, + unsigned int input_vec_len, + uint8_t *output_vec, + unsigned int output_vec_len, + uint32_t fragsz, + uint32_t fragsz_oop) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + uint8_t *plaintext; + struct rte_mbuf *buf, *buf_oop = NULL; + int ret = TEST_SUCCESS; + int to_trn = 0; + 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]); - int retval; + /* Verify the capabilities */ + struct rte_security_capability_idx sec_cap_idx; - 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]; + 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; - struct rte_cryptodev_info dev_info; - struct rte_crypto_op *op; + if (fragsz > input_vec_len) + fragsz = input_vec_len; - /* Check if device supports particular algorithms */ - if (test_mixed_check_if_unsupported(tdata)) - return -ENOTSUP; + uint16_t plaintext_len = fragsz; + uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz; - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + if (fragsz_oop > output_vec_len) + frag_size_oop = output_vec_len; - uint64_t feat_flags = dev_info.feature_flags; + int ecx = 0; + if (input_vec_len % fragsz != 0) { + if (input_vec_len / fragsz + 1 > 16) + return 1; + } else if (input_vec_len / fragsz > 16) + return 1; - 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; - } + /* Out of place support */ + if (oop) { + /* + * For out-op-place we need to alloc another mbuf + */ + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + rte_pktmbuf_append(ut_params->obuf, frag_size_oop); + buf_oop = ut_params->obuf; } - /* 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; + /* Generate test mbuf data */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - 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); + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - 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"); + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_len); + memcpy(plaintext, input_vec, plaintext_len); + trn_data += plaintext_len; - 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"); - } + buf = ut_params->ibuf; - 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)); + /* + * Loop until no more fragments + */ - /* 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); + while (trn_data < input_vec_len) { + ++segs; + to_trn = (input_vec_len - trn_data < fragsz) ? + (input_vec_len - trn_data) : fragsz; - if (retval < 0) - return retval; + to_trn_tbl[ecx++] = to_trn; - op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf = buf->next; - /* 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; - } + memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, + rte_pktmbuf_tailroom(buf)); - ut_params->op = op; + /* OOP */ + if (oop && !fragsz_oop) { + buf_oop->next = + rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf_oop = buf_oop->next; + memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), + 0, rte_pktmbuf_tailroom(buf_oop)); + rte_pktmbuf_append(buf_oop, to_trn); + } - TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + plaintext = (uint8_t *)rte_pktmbuf_append(buf, + to_trn); - ut_params->obuf = (op_mode == IN_PLACE ? - ut_params->op->sym->m_src : ut_params->op->sym->m_dst); + memcpy(plaintext, input_vec + trn_data, to_trn); + trn_data += to_trn; + } - 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); + ut_params->ibuf->nb_segs = segs; - 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); + segs = 1; + if (fragsz_oop && oop) { + to_trn = 0; + ecx = 0; - debug_hexdump(stdout, "ciphertext:", ciphertext, - ciphertext_len); - debug_hexdump(stdout, "ciphertext expected:", - tdata->ciphertext.data, - tdata->ciphertext.len_bits >> 3); + trn_data = frag_size_oop; + while (trn_data < output_vec_len) { + ++segs; + to_trn = + (output_vec_len - trn_data < + frag_size_oop) ? + (output_vec_len - trn_data) : + frag_size_oop; - 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); + to_trn_tbl[ecx++] = to_trn; - debug_hexdump(stdout, "digest:", digest, - tdata->digest_enc.len); - debug_hexdump(stdout, "digest expected:", - tdata->digest_enc.data, tdata->digest_enc.len); - } + buf_oop->next = + rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf_oop = buf_oop->next; + memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), + 0, rte_pktmbuf_tailroom(buf_oop)); + rte_pktmbuf_append(buf_oop, to_trn); - /* 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"); + trn_data += to_trn; + } + ut_params->obuf->nb_segs = segs; } - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing failed"); + ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; - return 0; -} + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg; + ut_params->cipher_xform.cipher.op = opc; + ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i]; + ut_params->cipher_xform.cipher.key.length = + pdcp_test_params[i].cipher_key_len; + ut_params->cipher_xform.cipher.iv.length = 0; -/** AUTH AES CMAC + CIPHER AES CTR */ + /* Setup HMAC Parameters if ICV header is required */ + if (pdcp_test_params[i].auth_alg != 0) { + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg; + ut_params->auth_xform.auth.op = opa; + ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i]; + ut_params->auth_xform.auth.key.length = + pdcp_test_params[i].auth_key_len; -static int -test_aes_cmac_aes_ctr_digest_enc_test_case_1(void) -{ - return test_mixed_auth_cipher( - &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0); -} + ut_params->cipher_xform.next = &ut_params->auth_xform; + } else { + ut_params->cipher_xform.next = NULL; + } -static int -test_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, 0); -} + struct rte_security_session_conf sess_conf = { + .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, + .protocol = RTE_SECURITY_PROTOCOL_PDCP, + {.pdcp = { + .bearer = pdcp_test_bearer[i], + .domain = pdcp_test_params[i].domain, + .pkt_dir = pdcp_test_packet_direction[i], + .sn_size = pdcp_test_data_sn_size[i], + .hfn = pdcp_test_hfn[i], + .hfn_threshold = pdcp_test_hfn_threshold[i], + } }, + .crypto_xform = &ut_params->cipher_xform + }; -static int -test_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, 0); -} + /* Create security session */ + ut_params->sec_session = rte_security_session_create(ctx, + &sess_conf, ts_params->session_priv_mpool); -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); -} + if (!ut_params->sec_session) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, "Failed to allocate session"); + ret = TEST_FAILED; + goto on_err; + } -static int -test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void) -{ - return test_mixed_auth_cipher( - &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1); + /* Generate crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + if (!ut_params->op) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, + "Failed to allocate symmetric crypto operation struct"); + ret = TEST_FAILED; + goto on_err; + } + + rte_security_attach_session(ut_params->op, ut_params->sec_session); + + /* set crypto operation source mbuf */ + ut_params->op->sym->m_src = ut_params->ibuf; + if (oop) + ut_params->op->sym->m_dst = ut_params->obuf; + + /* Process crypto operation */ + if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) + == NULL) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, + "failed to process sym crypto op"); + ret = TEST_FAILED; + goto on_err; + } + + if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, "crypto op processing failed"); + ret = TEST_FAILED; + goto on_err; + } + + /* Validate obuf */ + uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src, + uint8_t *); + if (oop) { + ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, + uint8_t *); + } + if (fragsz_oop) + fragsz = frag_size_oop; + if (memcmp(ciphertext, output_vec, fragsz)) { + printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); + rte_hexdump(stdout, "encrypted", ciphertext, fragsz); + rte_hexdump(stdout, "reference", output_vec, fragsz); + ret = TEST_FAILED; + goto on_err; + } + + buf = ut_params->op->sym->m_src->next; + if (oop) + buf = ut_params->op->sym->m_dst->next; + + unsigned int off = fragsz; + + ecx = 0; + while (buf) { + ciphertext = rte_pktmbuf_mtod(buf, + uint8_t *); + if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) { + printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); + rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]); + rte_hexdump(stdout, "reference", output_vec + off, + to_trn_tbl[ecx]); + ret = TEST_FAILED; + goto on_err; + } + off += to_trn_tbl[ecx++]; + buf = buf->next; + } +on_err: + rte_crypto_op_free(ut_params->op); + ut_params->op = NULL; + + if (ut_params->sec_session) + rte_security_session_destroy(ctx, ut_params->sec_session); + ut_params->sec_session = NULL; + + rte_pktmbuf_free(ut_params->ibuf); + ut_params->ibuf = NULL; + if (oop) { + rte_pktmbuf_free(ut_params->obuf); + ut_params->obuf = NULL; + } + + return ret; } -static int -test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void) +int +test_pdcp_proto_cplane_encap(int i) { - return test_mixed_auth_cipher( - &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i]+4); } -static int -test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void) +int +test_pdcp_proto_uplane_encap(int i) { - return test_mixed_auth_cipher_sgl( - &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1); + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i]); + } -static int -test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void) +int +test_pdcp_proto_uplane_encap_with_int(int i) { - return test_mixed_auth_cipher_sgl( - &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i] + 4); } -/** MIXED AUTH + CIPHER */ +int +test_pdcp_proto_cplane_decap(int i) +{ + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_DECRYPT, + RTE_CRYPTO_AUTH_OP_VERIFY, + pdcp_test_data_out[i], + pdcp_test_data_in_len[i] + 4, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i]); +} -static int -test_auth_zuc_cipher_snow_test_case_1(void) +int +test_pdcp_proto_uplane_decap(int i) { - return test_mixed_auth_cipher( - &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0); + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_DECRYPT, + RTE_CRYPTO_AUTH_OP_VERIFY, + pdcp_test_data_out[i], + pdcp_test_data_in_len[i], + pdcp_test_data_in[i], + pdcp_test_data_in_len[i]); } -static int -test_verify_auth_zuc_cipher_snow_test_case_1(void) +int +test_pdcp_proto_uplane_decap_with_int(int i) { - return test_mixed_auth_cipher( - &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1); + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_DECRYPT, + RTE_CRYPTO_AUTH_OP_VERIFY, + pdcp_test_data_out[i], + pdcp_test_data_in_len[i] + 4, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i]); } static int -test_auth_aes_cmac_cipher_snow_test_case_1(void) +test_PDCP_PROTO_SGL_in_place_32B(void) { - return test_mixed_auth_cipher( - &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0); + /* i can be used for running any PDCP case + * In this case it is uplane 12-bit AES-SNOW DL encap + */ + int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK; + return test_pdcp_proto_SGL(i, IN_PLACE, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i]+4, + 32, 0); } - static int -test_verify_auth_aes_cmac_cipher_snow_test_case_1(void) +test_PDCP_PROTO_SGL_oop_32B_128B(void) { - return test_mixed_auth_cipher( - &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1); + /* i can be used for running any PDCP case + * In this case it is uplane 18-bit NULL-NULL DL encap + */ + int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK; + return test_pdcp_proto_SGL(i, OUT_OF_PLACE, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i]+4, + 32, 128); } - static int -test_auth_zuc_cipher_aes_ctr_test_case_1(void) +test_PDCP_PROTO_SGL_oop_32B_40B(void) { - return test_mixed_auth_cipher( - &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); + /* i can be used for running any PDCP case + * In this case it is uplane 18-bit AES DL encap + */ + int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET + + DOWNLINK; + return test_pdcp_proto_SGL(i, OUT_OF_PLACE, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i], + 32, 40); } - static int -test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void) +test_PDCP_PROTO_SGL_oop_128B_32B(void) { - return test_mixed_auth_cipher( - &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); + /* i can be used for running any PDCP case + * In this case it is cplane 12-bit AES-ZUC DL encap + */ + int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK; + return test_pdcp_proto_SGL(i, OUT_OF_PLACE, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i]+4, + 128, 32); } +#endif static int -test_auth_snow_cipher_aes_ctr_test_case_1(void) +test_AES_GCM_authenticated_encryption_test_case_1(void) { - return test_mixed_auth_cipher( - &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); + return test_authenticated_encryption(&gcm_test_case_1); } static int -test_verify_auth_snow_cipher_aes_ctr_test_case_1(void) +test_AES_GCM_authenticated_encryption_test_case_2(void) { - return test_mixed_auth_cipher( - &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); + return test_authenticated_encryption(&gcm_test_case_2); } static int -test_auth_snow_cipher_zuc_test_case_1(void) +test_AES_GCM_authenticated_encryption_test_case_3(void) { - return test_mixed_auth_cipher( - &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); + return test_authenticated_encryption(&gcm_test_case_3); } static int -test_verify_auth_snow_cipher_zuc_test_case_1(void) +test_AES_GCM_authenticated_encryption_test_case_4(void) { - return test_mixed_auth_cipher( - &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); + return test_authenticated_encryption(&gcm_test_case_4); } static int -test_auth_aes_cmac_cipher_zuc_test_case_1(void) +test_AES_GCM_authenticated_encryption_test_case_5(void) { - return test_mixed_auth_cipher( - &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); + return test_authenticated_encryption(&gcm_test_case_5); } static int -test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void) +test_AES_GCM_authenticated_encryption_test_case_6(void) { - return test_mixed_auth_cipher( - &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); + return test_authenticated_encryption(&gcm_test_case_6); } static int -test_auth_null_cipher_snow_test_case_1(void) +test_AES_GCM_authenticated_encryption_test_case_7(void) { - return test_mixed_auth_cipher( - &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0); + return test_authenticated_encryption(&gcm_test_case_7); } static int -test_verify_auth_null_cipher_snow_test_case_1(void) +test_AES_GCM_authenticated_encryption_test_case_8(void) { - return test_mixed_auth_cipher( - &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1); + return test_authenticated_encryption(&gcm_test_case_8); } static int -test_auth_null_cipher_zuc_test_case_1(void) +test_AES_GCM_J0_authenticated_encryption_test_case_1(void) { - return test_mixed_auth_cipher( - &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); + return test_authenticated_encryption(&gcm_J0_test_case_1); } static int -test_verify_auth_null_cipher_zuc_test_case_1(void) +test_AES_GCM_auth_encryption_test_case_192_1(void) { - return test_mixed_auth_cipher( - &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); + return test_authenticated_encryption(&gcm_test_case_192_1); } static int -test_auth_snow_cipher_null_test_case_1(void) +test_AES_GCM_auth_encryption_test_case_192_2(void) { - return test_mixed_auth_cipher( - &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0); + return test_authenticated_encryption(&gcm_test_case_192_2); } static int -test_verify_auth_snow_cipher_null_test_case_1(void) +test_AES_GCM_auth_encryption_test_case_192_3(void) { - return test_mixed_auth_cipher( - &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1); + return test_authenticated_encryption(&gcm_test_case_192_3); } static int -test_auth_zuc_cipher_null_test_case_1(void) +test_AES_GCM_auth_encryption_test_case_192_4(void) { - return test_mixed_auth_cipher( - &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0); + return test_authenticated_encryption(&gcm_test_case_192_4); } static int -test_verify_auth_zuc_cipher_null_test_case_1(void) +test_AES_GCM_auth_encryption_test_case_192_5(void) { - return test_mixed_auth_cipher( - &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1); + return test_authenticated_encryption(&gcm_test_case_192_5); } static int -test_auth_null_cipher_aes_ctr_test_case_1(void) +test_AES_GCM_auth_encryption_test_case_192_6(void) { - return test_mixed_auth_cipher( - &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); + return test_authenticated_encryption(&gcm_test_case_192_6); } static int -test_verify_auth_null_cipher_aes_ctr_test_case_1(void) +test_AES_GCM_auth_encryption_test_case_192_7(void) { - return test_mixed_auth_cipher( - &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); + return test_authenticated_encryption(&gcm_test_case_192_7); } static int -test_auth_aes_cmac_cipher_null_test_case_1(void) +test_AES_GCM_auth_encryption_test_case_256_1(void) { - return test_mixed_auth_cipher( - &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0); + return test_authenticated_encryption(&gcm_test_case_256_1); } static int -test_verify_auth_aes_cmac_cipher_null_test_case_1(void) +test_AES_GCM_auth_encryption_test_case_256_2(void) { - return test_mixed_auth_cipher( - &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1); + return test_authenticated_encryption(&gcm_test_case_256_2); } static int -test_3DES_chain_qat_all(void) +test_AES_GCM_auth_encryption_test_case_256_3(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_3DES_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_authenticated_encryption(&gcm_test_case_256_3); } static int -test_DES_cipheronly_qat_all(void) +test_AES_GCM_auth_encryption_test_case_256_4(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_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_authenticated_encryption(&gcm_test_case_256_4); } static int -test_DES_cipheronly_openssl_all(void) +test_AES_GCM_auth_encryption_test_case_256_5(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_DES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_authenticated_encryption(&gcm_test_case_256_5); } static int -test_DES_docsis_openssl_all(void) +test_AES_GCM_auth_encryption_test_case_256_6(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_DES_DOCSIS_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_authenticated_encryption(&gcm_test_case_256_6); } static int -test_DES_cipheronly_mb_all(void) +test_AES_GCM_auth_encryption_test_case_256_7(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_DES_CIPHERONLY_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; + return test_authenticated_encryption(&gcm_test_case_256_7); } + static int -test_3DES_cipheronly_mb_all(void) +test_AES_GCM_auth_encryption_test_case_aad_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + return test_authenticated_encryption(&gcm_test_case_aad_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_AESNI_MB_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); +static int +test_AES_GCM_auth_encryption_test_case_aad_2(void) +{ + return test_authenticated_encryption(&gcm_test_case_aad_2); +} - TEST_ASSERT_EQUAL(status, 0, "Test failed"); +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_DES_docsis_mb_all(void) +test_AES_GCM_auth_encryption_fail_in_data_corrupt(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_DES_DOCSIS_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + 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_3DES_chain_caam_jr_all(void) +test_AES_GCM_auth_encryption_fail_out_data_corrupt(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_CHAIN_TYPE); - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + 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_3DES_cipheronly_caam_jr_all(void) +test_AES_GCM_auth_encryption_fail_aad_len_corrupt(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"); + 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_3DES_chain_dpaa_sec_all(void) +test_AES_GCM_auth_encryption_fail_aad_corrupt(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"); + 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_3DES_cipheronly_dpaa_sec_all(void) +test_AES_GCM_auth_encryption_fail_tag_corrupt(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"); + 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_3DES_chain_dpaa2_sec_all(void) +test_authenticated_decryption(const struct aead_test_data *tdata) { 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_DPAA2_SEC_PMD)), - BLKCIPHER_3DES_CHAIN_TYPE); + int retval; + uint8_t *plaintext; + uint32_t i; - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* 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; - return TEST_SUCCESS; -} + /* Create AEAD session */ + retval = create_aead_session(ts_params->valid_devs[0], + tdata->algo, + RTE_CRYPTO_AEAD_OP_DECRYPT, + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len, + tdata->iv.len); + if (retval < 0) + return retval; -static int -test_3DES_cipheronly_dpaa2_sec_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + /* alloc mbuf and set payload */ + if (tdata->aad.len > MBUF_SIZE) { + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); + /* Populate full size of add data */ + for (i = 32; i < MAX_AAD_LENGTH; i += 32) + memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); + } else + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - 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); + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); + if (retval < 0) + return retval; - return TEST_SUCCESS; -} + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); -static int -test_3DES_chain_ccp_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + ut_params->op->sym->m_src = ut_params->ibuf; - 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); + /* Process crypto operation */ + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op); + else + TEST_ASSERT_NOT_NULL( + process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); - 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; -} + if (ut_params->op->sym->m_dst) + plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, + uint8_t *); + else + plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, + uint8_t *, + ut_params->op->sym->cipher.data.offset); -static int -test_3DES_cipheronly_ccp_all(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.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_CCP_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len, + "Plaintext data not as expected"); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + TEST_ASSERT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, + "Authentication failed"); - return TEST_SUCCESS; + return 0; } static int -test_3DES_cipheronly_qat_all(void) +test_AES_GCM_authenticated_decryption_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_QAT_SYM_PMD)), - BLKCIPHER_3DES_CIPHERONLY_TYPE); + return test_authenticated_decryption(&gcm_test_case_1); +} - TEST_ASSERT_EQUAL(status, 0, "Test failed"); +static int +test_AES_GCM_authenticated_decryption_test_case_2(void) +{ + return test_authenticated_decryption(&gcm_test_case_2); +} - return TEST_SUCCESS; +static int +test_AES_GCM_authenticated_decryption_test_case_3(void) +{ + return test_authenticated_decryption(&gcm_test_case_3); } static int -test_3DES_chain_openssl_all(void) +test_AES_GCM_authenticated_decryption_test_case_4(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + return test_authenticated_decryption(&gcm_test_case_4); +} - 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_AES_GCM_authenticated_decryption_test_case_5(void) +{ + return test_authenticated_decryption(&gcm_test_case_5); +} - TEST_ASSERT_EQUAL(status, 0, "Test failed"); +static int +test_AES_GCM_authenticated_decryption_test_case_6(void) +{ + return test_authenticated_decryption(&gcm_test_case_6); +} - return TEST_SUCCESS; +static int +test_AES_GCM_authenticated_decryption_test_case_7(void) +{ + return test_authenticated_decryption(&gcm_test_case_7); } static int -test_3DES_cipheronly_openssl_all(void) +test_AES_GCM_authenticated_decryption_test_case_8(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; + return test_authenticated_decryption(&gcm_test_case_8); +} - 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_AES_GCM_J0_authenticated_decryption_test_case_1(void) +{ + return test_authenticated_decryption(&gcm_J0_test_case_1); +} - TEST_ASSERT_EQUAL(status, 0, "Test failed"); +static int +test_AES_GCM_auth_decryption_test_case_192_1(void) +{ + return test_authenticated_decryption(&gcm_test_case_192_1); +} - return TEST_SUCCESS; +static int +test_AES_GCM_auth_decryption_test_case_192_2(void) +{ + return test_authenticated_decryption(&gcm_test_case_192_2); } -/* ***** AEAD algorithm Tests ***** */ +static int +test_AES_GCM_auth_decryption_test_case_192_3(void) +{ + return test_authenticated_decryption(&gcm_test_case_192_3); +} static int -create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo, - enum rte_crypto_aead_operation op, - const uint8_t *key, const uint8_t key_len, - const uint16_t aad_len, const uint8_t auth_len, - uint8_t iv_len) +test_AES_GCM_auth_decryption_test_case_192_4(void) { - uint8_t aead_key[key_len]; + return test_authenticated_decryption(&gcm_test_case_192_4); +} - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; +static int +test_AES_GCM_auth_decryption_test_case_192_5(void) +{ + return test_authenticated_decryption(&gcm_test_case_192_5); +} - memcpy(aead_key, key, key_len); +static int +test_AES_GCM_auth_decryption_test_case_192_6(void) +{ + return test_authenticated_decryption(&gcm_test_case_192_6); +} - /* Setup AEAD Parameters */ - ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD; - ut_params->aead_xform.next = NULL; - ut_params->aead_xform.aead.algo = algo; - ut_params->aead_xform.aead.op = op; - ut_params->aead_xform.aead.key.data = aead_key; - ut_params->aead_xform.aead.key.length = key_len; - ut_params->aead_xform.aead.iv.offset = IV_OFFSET; - ut_params->aead_xform.aead.iv.length = iv_len; - ut_params->aead_xform.aead.digest_length = auth_len; - ut_params->aead_xform.aead.aad_length = aad_len; +static int +test_AES_GCM_auth_decryption_test_case_192_7(void) +{ + return test_authenticated_decryption(&gcm_test_case_192_7); +} - debug_hexdump(stdout, "key:", key, key_len); +static int +test_AES_GCM_auth_decryption_test_case_256_1(void) +{ + return test_authenticated_decryption(&gcm_test_case_256_1); +} - /* Create Crypto session*/ - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); +static int +test_AES_GCM_auth_decryption_test_case_256_2(void) +{ + return test_authenticated_decryption(&gcm_test_case_256_2); +} - rte_cryptodev_sym_session_init(dev_id, ut_params->sess, - &ut_params->aead_xform, - ts_params->session_priv_mpool); +static int +test_AES_GCM_auth_decryption_test_case_256_3(void) +{ + return test_authenticated_decryption(&gcm_test_case_256_3); +} - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); +static int +test_AES_GCM_auth_decryption_test_case_256_4(void) +{ + return test_authenticated_decryption(&gcm_test_case_256_4); +} - return 0; +static int +test_AES_GCM_auth_decryption_test_case_256_5(void) +{ + return test_authenticated_decryption(&gcm_test_case_256_5); } static int -create_aead_xform(struct rte_crypto_op *op, - enum rte_crypto_aead_algorithm algo, - enum rte_crypto_aead_operation aead_op, - uint8_t *key, const uint8_t key_len, - const uint8_t aad_len, const uint8_t auth_len, - uint8_t iv_len) +test_AES_GCM_auth_decryption_test_case_256_6(void) { - TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1), - "failed to allocate space for crypto transform"); + return test_authenticated_decryption(&gcm_test_case_256_6); +} - struct rte_crypto_sym_op *sym_op = op->sym; +static int +test_AES_GCM_auth_decryption_test_case_256_7(void) +{ + return test_authenticated_decryption(&gcm_test_case_256_7); +} - /* Setup AEAD Parameters */ - sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD; - sym_op->xform->next = NULL; - sym_op->xform->aead.algo = algo; - sym_op->xform->aead.op = aead_op; - sym_op->xform->aead.key.data = key; - sym_op->xform->aead.key.length = key_len; - sym_op->xform->aead.iv.offset = IV_OFFSET; - sym_op->xform->aead.iv.length = iv_len; - sym_op->xform->aead.digest_length = auth_len; - sym_op->xform->aead.aad_length = aad_len; - - debug_hexdump(stdout, "key:", key, key_len); - - return 0; +static int +test_AES_GCM_auth_decryption_test_case_aad_1(void) +{ + return test_authenticated_decryption(&gcm_test_case_aad_1); } static int -create_aead_operation(enum rte_crypto_aead_operation op, - const struct aead_test_data *tdata) +test_AES_GCM_auth_decryption_test_case_aad_2(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - - uint8_t *plaintext, *ciphertext; - unsigned int aad_pad_len, plaintext_pad_len; - - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate symmetric crypto operation struct"); - - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - - /* Append aad data */ - if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) { - aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16); - sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - aad_pad_len); - TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data, - "no room to append aad"); - - sym_op->aead.aad.phys_addr = - rte_pktmbuf_iova(ut_params->ibuf); - /* Copy AAD 18 bytes after the AAD pointer, according to the API */ - memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len); - debug_hexdump(stdout, "aad:", sym_op->aead.aad.data, - tdata->aad.len); - - /* Append IV at the end of the crypto operation*/ - uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, - uint8_t *, IV_OFFSET); - - /* Copy IV 1 byte after the IV pointer, according to the API */ - rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len); - debug_hexdump(stdout, "iv:", iv_ptr, - tdata->iv.len); - } else { - aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); - sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - aad_pad_len); - TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data, - "no room to append aad"); - - sym_op->aead.aad.phys_addr = - rte_pktmbuf_iova(ut_params->ibuf); - memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len); - debug_hexdump(stdout, "aad:", sym_op->aead.aad.data, - tdata->aad.len); - - /* Append IV at the end of the crypto operation*/ - uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, - uint8_t *, IV_OFFSET); + return test_authenticated_decryption(&gcm_test_case_aad_2); +} - rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); - debug_hexdump(stdout, "iv:", iv_ptr, - tdata->iv.len); - } +static int +test_AES_GCM_auth_decryption_fail_iv_corrupt(void) +{ + struct aead_test_data tdata; + int res; - /* Append plaintext/ciphertext */ - if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) { - plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); + 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; +} - memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); - debug_hexdump(stdout, "plaintext:", plaintext, - tdata->plaintext.len); +static int +test_AES_GCM_auth_decryption_fail_in_data_corrupt(void) +{ + struct aead_test_data tdata; + int res; - if (ut_params->obuf) { - ciphertext = (uint8_t *)rte_pktmbuf_append( - ut_params->obuf, - plaintext_pad_len + aad_pad_len); - TEST_ASSERT_NOT_NULL(ciphertext, - "no room to append ciphertext"); + 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; +} - memset(ciphertext + aad_pad_len, 0, - tdata->ciphertext.len); - } - } else { - plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16); - ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - TEST_ASSERT_NOT_NULL(ciphertext, - "no room to append ciphertext"); +static int +test_AES_GCM_auth_decryption_fail_out_data_corrupt(void) +{ + struct aead_test_data tdata; + int res; - memcpy(ciphertext, tdata->ciphertext.data, - tdata->ciphertext.len); - debug_hexdump(stdout, "ciphertext:", ciphertext, - tdata->ciphertext.len); + 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; +} - if (ut_params->obuf) { - plaintext = (uint8_t *)rte_pktmbuf_append( - ut_params->obuf, - plaintext_pad_len + aad_pad_len); - TEST_ASSERT_NOT_NULL(plaintext, - "no room to append plaintext"); +static int +test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void) +{ + struct aead_test_data tdata; + int res; - memset(plaintext + aad_pad_len, 0, - tdata->plaintext.len); - } - } + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.aad.len += 1; + res = test_authenticated_decryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; +} - /* Append digest data */ - if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) { - sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append( - ut_params->obuf ? ut_params->obuf : - ut_params->ibuf, - tdata->auth_tag.len); - TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, - "no room to append digest"); - memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len); - sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset( - ut_params->obuf ? ut_params->obuf : - ut_params->ibuf, - plaintext_pad_len + - aad_pad_len); - } else { - sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append( - ut_params->ibuf, tdata->auth_tag.len); - TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, - "no room to append digest"); - sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset( - ut_params->ibuf, - plaintext_pad_len + aad_pad_len); +static int +test_AES_GCM_auth_decryption_fail_aad_corrupt(void) +{ + struct aead_test_data tdata; + uint8_t aad[gcm_test_case_7.aad.len]; + int res; - rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data, - tdata->auth_tag.len); - debug_hexdump(stdout, "digest:", - sym_op->aead.digest.data, - tdata->auth_tag.len); - } + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len); + aad[0] += 1; + tdata.aad.data = aad; + res = test_authenticated_decryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; +} - sym_op->aead.data.length = tdata->plaintext.len; - sym_op->aead.data.offset = aad_pad_len; +static int +test_AES_GCM_auth_decryption_fail_tag_corrupt(void) +{ + struct aead_test_data tdata; + int res; - return 0; + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.auth_tag.data[0] += 1; + res = test_authenticated_decryption(&tdata); + if (res == -ENOTSUP) + return res; + TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed"); + return TEST_SUCCESS; } static int -test_authenticated_encryption(const struct aead_test_data *tdata) +test_authenticated_encryption_oop(const struct aead_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -7818,7 +8281,18 @@ test_authenticated_encryption(const struct aead_test_data *tdata) int retval; uint8_t *ciphertext, *auth_tag; uint16_t plaintext_pad_len; - uint32_t i; + + /* 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], @@ -7830,17 +8304,14 @@ test_authenticated_encryption(const struct aead_test_data *tdata) if (retval < 0) return retval; - if (tdata->aad.len > MBUF_SIZE) { - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); - /* Populate full size of add data */ - for (i = 32; i < MAX_AAD_LENGTH; i += 32) - memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); - } else - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); /* clear mbuf payload */ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->ibuf)); + memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->obuf)); /* Create AEAD operation */ retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); @@ -7850,6 +8321,7 @@ test_authenticated_encryption(const struct aead_test_data *tdata) rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); ut_params->op->sym->m_src = ut_params->ibuf; + ut_params->op->sym->m_dst = ut_params->obuf; /* Process crypto operation */ TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], @@ -7860,17 +8332,9 @@ test_authenticated_encryption(const struct aead_test_data *tdata) plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); - if (ut_params->op->sym->m_dst) { - ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, - uint8_t *); - auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, - uint8_t *, plaintext_pad_len); - } else { - ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, - uint8_t *, - ut_params->op->sym->cipher.data.offset); - auth_tag = ciphertext + plaintext_pad_len; - } + ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, + ut_params->op->sym->cipher.data.offset); + auth_tag = ciphertext + plaintext_pad_len; debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); @@ -7892,1666 +8356,1412 @@ test_authenticated_encryption(const struct aead_test_data *tdata) } -#ifdef RTE_LIBRTE_SECURITY -/* Basic algorithm run function for async inplace mode. - * Creates a session from input parameters and runs one operation - * on input_vec. Checks the output of the crypto operation against - * output_vec. - */ static int -test_pdcp_proto(int i, int oop, - enum rte_crypto_cipher_operation opc, - enum rte_crypto_auth_operation opa, - uint8_t *input_vec, - unsigned int input_vec_len, - uint8_t *output_vec, - unsigned int output_vec_len) +test_AES_GCM_authenticated_encryption_oop_test_case_1(void) +{ + return test_authenticated_encryption_oop(&gcm_test_case_5); +} + +static int +test_authenticated_decryption_oop(const struct aead_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - uint8_t *plaintext; - int ret = TEST_SUCCESS; - - /* Generate test mbuf data */ - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - - /* clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); - - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - input_vec_len); - memcpy(plaintext, input_vec, input_vec_len); - - /* Out of place support */ - if (oop) { - /* - * For out-op-place we need to alloc another mbuf - */ - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - rte_pktmbuf_append(ut_params->obuf, output_vec_len); - } - - /* Set crypto type as IPSEC */ - ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; - - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg; - ut_params->cipher_xform.cipher.op = opc; - ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i]; - ut_params->cipher_xform.cipher.key.length = - pdcp_test_params[i].cipher_key_len; - ut_params->cipher_xform.cipher.iv.length = 0; - /* Setup HMAC Parameters if ICV header is required */ - if (pdcp_test_params[i].auth_alg != 0) { - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = NULL; - ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg; - ut_params->auth_xform.auth.op = opa; - ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i]; - ut_params->auth_xform.auth.key.length = - pdcp_test_params[i].auth_key_len; + int retval; + uint8_t *plaintext; - ut_params->cipher_xform.next = &ut_params->auth_xform; - } else { - ut_params->cipher_xform.next = NULL; - } + /* 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; - struct rte_security_session_conf sess_conf = { - .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, - .protocol = RTE_SECURITY_PROTOCOL_PDCP, - {.pdcp = { - .bearer = pdcp_test_bearer[i], - .domain = pdcp_test_params[i].domain, - .pkt_dir = pdcp_test_packet_direction[i], - .sn_size = pdcp_test_data_sn_size[i], - .hfn = pdcp_test_hfn[i], - .hfn_threshold = pdcp_test_hfn_threshold[i], - } }, - .crypto_xform = &ut_params->cipher_xform - }; + /* not supported with CPU crypto */ + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; - struct rte_security_ctx *ctx = (struct rte_security_ctx *) - rte_cryptodev_get_sec_ctx( - ts_params->valid_devs[0]); + /* Create AEAD session */ + retval = create_aead_session(ts_params->valid_devs[0], + tdata->algo, + RTE_CRYPTO_AEAD_OP_DECRYPT, + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len, + tdata->iv.len); + if (retval < 0) + return retval; - /* Create security session */ - ut_params->sec_session = rte_security_session_create(ctx, - &sess_conf, ts_params->session_priv_mpool); + /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - if (!ut_params->sec_session) { - printf("TestCase %s()-%d line %d failed %s: ", - __func__, i, __LINE__, "Failed to allocate session"); - ret = TEST_FAILED; - goto on_err; - } + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->obuf)); - /* Generate crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - if (!ut_params->op) { - printf("TestCase %s()-%d line %d failed %s: ", - __func__, i, __LINE__, - "Failed to allocate symmetric crypto operation struct"); - ret = TEST_FAILED; - goto on_err; - } + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); + if (retval < 0) + return retval; - rte_security_attach_session(ut_params->op, ut_params->sec_session); + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - /* set crypto operation source mbuf */ ut_params->op->sym->m_src = ut_params->ibuf; - if (oop) - ut_params->op->sym->m_dst = ut_params->obuf; + ut_params->op->sym->m_dst = ut_params->obuf; /* Process crypto operation */ - if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) - == NULL) { - printf("TestCase %s()-%d line %d failed %s: ", - __func__, i, __LINE__, - "failed to process sym crypto op"); - ret = TEST_FAILED; - goto on_err; - } - - if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { - printf("TestCase %s()-%d line %d failed %s: ", - __func__, i, __LINE__, "crypto op processing failed"); - ret = TEST_FAILED; - goto on_err; - } + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); - /* Validate obuf */ - uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src, - uint8_t *); - if (oop) { - ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, - uint8_t *); - } + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); - if (memcmp(ciphertext, output_vec, output_vec_len)) { - printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); - rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len); - rte_hexdump(stdout, "reference", output_vec, output_vec_len); - ret = TEST_FAILED; - goto on_err; - } + plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, + ut_params->op->sym->cipher.data.offset); -on_err: - rte_crypto_op_free(ut_params->op); - ut_params->op = NULL; + debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); - if (ut_params->sec_session) - rte_security_session_destroy(ctx, ut_params->sec_session); - ut_params->sec_session = NULL; + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len, + "Plaintext data not as expected"); - rte_pktmbuf_free(ut_params->ibuf); - ut_params->ibuf = NULL; - if (oop) { - rte_pktmbuf_free(ut_params->obuf); - ut_params->obuf = NULL; - } + TEST_ASSERT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, + "Authentication failed"); + return 0; +} - return ret; +static int +test_AES_GCM_authenticated_decryption_oop_test_case_1(void) +{ + return test_authenticated_decryption_oop(&gcm_test_case_5); } static int -test_pdcp_proto_SGL(int i, int oop, - enum rte_crypto_cipher_operation opc, - enum rte_crypto_auth_operation opa, - uint8_t *input_vec, - unsigned int input_vec_len, - uint8_t *output_vec, - unsigned int output_vec_len, - uint32_t fragsz, - uint32_t fragsz_oop) +test_authenticated_encryption_sessionless( + const struct aead_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - uint8_t *plaintext; - struct rte_mbuf *buf, *buf_oop = NULL; - int ret = TEST_SUCCESS; - int to_trn = 0; - int to_trn_tbl[16]; - int segs = 1; - unsigned int trn_data = 0; - - if (fragsz > input_vec_len) - fragsz = input_vec_len; - uint16_t plaintext_len = fragsz; - uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz; + int retval; + uint8_t *ciphertext, *auth_tag; + uint16_t plaintext_pad_len; + uint8_t key[tdata->key.len + 1]; - if (fragsz_oop > output_vec_len) - frag_size_oop = output_vec_len; + /* 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; - int ecx = 0; - if (input_vec_len % fragsz != 0) { - if (input_vec_len / fragsz + 1 > 16) - return 1; - } else if (input_vec_len / fragsz > 16) - return 1; + /* not supported with CPU crypto */ + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; - /* Out of place support */ - if (oop) { - /* - * For out-op-place we need to alloc another mbuf - */ - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - rte_pktmbuf_append(ut_params->obuf, frag_size_oop); - buf_oop = ut_params->obuf; - } + /* 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; - /* Generate test mbuf data */ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); /* clear mbuf payload */ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->ibuf)); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_len); - memcpy(plaintext, input_vec, plaintext_len); - trn_data += plaintext_len; + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); + if (retval < 0) + return retval; - buf = ut_params->ibuf; - - /* - * Loop until no more fragments - */ - - while (trn_data < input_vec_len) { - ++segs; - to_trn = (input_vec_len - trn_data < fragsz) ? - (input_vec_len - trn_data) : fragsz; + /* Create GCM xform */ + memcpy(key, tdata->key.data, tdata->key.len); + retval = create_aead_xform(ut_params->op, + tdata->algo, + RTE_CRYPTO_AEAD_OP_ENCRYPT, + key, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len, + tdata->iv.len); + if (retval < 0) + return retval; - to_trn_tbl[ecx++] = to_trn; + ut_params->op->sym->m_src = ut_params->ibuf; - buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); - buf = buf->next; + TEST_ASSERT_EQUAL(ut_params->op->sess_type, + RTE_CRYPTO_OP_SESSIONLESS, + "crypto op session type not sessionless"); - memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, - rte_pktmbuf_tailroom(buf)); + /* Process crypto operation */ + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); - /* OOP */ - if (oop && !fragsz_oop) { - buf_oop->next = - rte_pktmbuf_alloc(ts_params->mbuf_pool); - buf_oop = buf_oop->next; - memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), - 0, rte_pktmbuf_tailroom(buf_oop)); - rte_pktmbuf_append(buf_oop, to_trn); - } + TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - plaintext = (uint8_t *)rte_pktmbuf_append(buf, - to_trn); + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op status not success"); - memcpy(plaintext, input_vec + trn_data, to_trn); - trn_data += to_trn; - } + plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); - ut_params->ibuf->nb_segs = segs; + ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, + ut_params->op->sym->cipher.data.offset); + auth_tag = ciphertext + plaintext_pad_len; - segs = 1; - if (fragsz_oop && oop) { - to_trn = 0; - ecx = 0; + debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); + debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); - trn_data = frag_size_oop; - while (trn_data < output_vec_len) { - ++segs; - to_trn = - (output_vec_len - trn_data < - frag_size_oop) ? - (output_vec_len - trn_data) : - frag_size_oop; + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ciphertext, + tdata->ciphertext.data, + tdata->ciphertext.len, + "Ciphertext data not as expected"); - to_trn_tbl[ecx++] = to_trn; + TEST_ASSERT_BUFFERS_ARE_EQUAL( + auth_tag, + tdata->auth_tag.data, + tdata->auth_tag.len, + "Generated auth tag not as expected"); - buf_oop->next = - rte_pktmbuf_alloc(ts_params->mbuf_pool); - buf_oop = buf_oop->next; - memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), - 0, rte_pktmbuf_tailroom(buf_oop)); - rte_pktmbuf_append(buf_oop, to_trn); + return 0; - trn_data += to_trn; - } - ut_params->obuf->nb_segs = segs; - } +} - ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; +static int +test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void) +{ + return test_authenticated_encryption_sessionless( + &gcm_test_case_5); +} - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg; - ut_params->cipher_xform.cipher.op = opc; - ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i]; - ut_params->cipher_xform.cipher.key.length = - pdcp_test_params[i].cipher_key_len; - ut_params->cipher_xform.cipher.iv.length = 0; +static int +test_authenticated_decryption_sessionless( + const struct aead_test_data *tdata) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; - /* Setup HMAC Parameters if ICV header is required */ - if (pdcp_test_params[i].auth_alg != 0) { - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = NULL; - ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg; - ut_params->auth_xform.auth.op = opa; - ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i]; - ut_params->auth_xform.auth.key.length = - pdcp_test_params[i].auth_key_len; + int retval; + uint8_t *plaintext; + uint8_t key[tdata->key.len + 1]; - ut_params->cipher_xform.next = &ut_params->auth_xform; - } else { - ut_params->cipher_xform.next = NULL; - } + /* 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; - struct rte_security_session_conf sess_conf = { - .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, - .protocol = RTE_SECURITY_PROTOCOL_PDCP, - {.pdcp = { - .bearer = pdcp_test_bearer[i], - .domain = pdcp_test_params[i].domain, - .pkt_dir = pdcp_test_packet_direction[i], - .sn_size = pdcp_test_data_sn_size[i], - .hfn = pdcp_test_hfn[i], - .hfn_threshold = pdcp_test_hfn_threshold[i], - } }, - .crypto_xform = &ut_params->cipher_xform - }; + /* not supported with CPU crypto */ + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; - struct rte_security_ctx *ctx = (struct rte_security_ctx *) - rte_cryptodev_get_sec_ctx( - ts_params->valid_devs[0]); + /* 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; - /* Create security session */ - ut_params->sec_session = rte_security_session_create(ctx, - &sess_conf, ts_params->session_priv_mpool); + /* alloc mbuf and set payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - if (!ut_params->sec_session) { - printf("TestCase %s()-%d line %d failed %s: ", - __func__, i, __LINE__, "Failed to allocate session"); - ret = TEST_FAILED; - goto on_err; - } + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - /* Generate crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - if (!ut_params->op) { - printf("TestCase %s()-%d line %d failed %s: ", - __func__, i, __LINE__, - "Failed to allocate symmetric crypto operation struct"); - ret = TEST_FAILED; - goto on_err; - } + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); + if (retval < 0) + return retval; - rte_security_attach_session(ut_params->op, ut_params->sec_session); + /* Create AEAD xform */ + memcpy(key, tdata->key.data, tdata->key.len); + retval = create_aead_xform(ut_params->op, + tdata->algo, + RTE_CRYPTO_AEAD_OP_DECRYPT, + key, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len, + tdata->iv.len); + if (retval < 0) + return retval; - /* set crypto operation source mbuf */ ut_params->op->sym->m_src = ut_params->ibuf; - if (oop) - ut_params->op->sym->m_dst = ut_params->obuf; + + TEST_ASSERT_EQUAL(ut_params->op->sess_type, + RTE_CRYPTO_OP_SESSIONLESS, + "crypto op session type not sessionless"); /* Process crypto operation */ - if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) - == NULL) { - printf("TestCase %s()-%d line %d failed %s: ", - __func__, i, __LINE__, - "failed to process sym crypto op"); - ret = TEST_FAILED; - goto on_err; - } + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); - if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { - printf("TestCase %s()-%d line %d failed %s: ", - __func__, i, __LINE__, "crypto op processing failed"); - ret = TEST_FAILED; - goto on_err; - } + TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op status not success"); + + plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, + ut_params->op->sym->cipher.data.offset); + + debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); /* Validate obuf */ - uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src, - uint8_t *); - if (oop) { - ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, - uint8_t *); - } - if (fragsz_oop) - fragsz = frag_size_oop; - if (memcmp(ciphertext, output_vec, fragsz)) { - printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); - rte_hexdump(stdout, "encrypted", ciphertext, fragsz); - rte_hexdump(stdout, "reference", output_vec, fragsz); - ret = TEST_FAILED; - goto on_err; - } + TEST_ASSERT_BUFFERS_ARE_EQUAL( + plaintext, + tdata->plaintext.data, + tdata->plaintext.len, + "Plaintext data not as expected"); - buf = ut_params->op->sym->m_src->next; - if (oop) - buf = ut_params->op->sym->m_dst->next; + TEST_ASSERT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, + "Authentication failed"); + return 0; +} - unsigned int off = fragsz; +static int +test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void) +{ + return test_authenticated_decryption_sessionless( + &gcm_test_case_5); +} - ecx = 0; - while (buf) { - ciphertext = rte_pktmbuf_mtod(buf, - uint8_t *); - if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) { - printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); - rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]); - rte_hexdump(stdout, "reference", output_vec + off, - to_trn_tbl[ecx]); - ret = TEST_FAILED; - goto on_err; - } - off += to_trn_tbl[ecx++]; - buf = buf->next; - } -on_err: - rte_crypto_op_free(ut_params->op); - ut_params->op = NULL; - - if (ut_params->sec_session) - rte_security_session_destroy(ctx, ut_params->sec_session); - ut_params->sec_session = NULL; - - rte_pktmbuf_free(ut_params->ibuf); - ut_params->ibuf = NULL; - if (oop) { - rte_pktmbuf_free(ut_params->obuf); - ut_params->obuf = NULL; - } - - return ret; -} - -int -test_pdcp_proto_cplane_encap(int i) -{ - return test_pdcp_proto(i, 0, - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_AUTH_OP_GENERATE, - pdcp_test_data_in[i], - pdcp_test_data_in_len[i], - pdcp_test_data_out[i], - pdcp_test_data_in_len[i]+4); -} - -int -test_pdcp_proto_uplane_encap(int i) -{ - return test_pdcp_proto(i, 0, - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_AUTH_OP_GENERATE, - pdcp_test_data_in[i], - pdcp_test_data_in_len[i], - pdcp_test_data_out[i], - pdcp_test_data_in_len[i]); - -} - -int -test_pdcp_proto_uplane_encap_with_int(int i) -{ - return test_pdcp_proto(i, 0, - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_AUTH_OP_GENERATE, - pdcp_test_data_in[i], - pdcp_test_data_in_len[i], - pdcp_test_data_out[i], - pdcp_test_data_in_len[i] + 4); -} - -int -test_pdcp_proto_cplane_decap(int i) -{ - return test_pdcp_proto(i, 0, - RTE_CRYPTO_CIPHER_OP_DECRYPT, - RTE_CRYPTO_AUTH_OP_VERIFY, - pdcp_test_data_out[i], - pdcp_test_data_in_len[i] + 4, - pdcp_test_data_in[i], - pdcp_test_data_in_len[i]); -} - -int -test_pdcp_proto_uplane_decap(int i) -{ - return test_pdcp_proto(i, 0, - RTE_CRYPTO_CIPHER_OP_DECRYPT, - RTE_CRYPTO_AUTH_OP_VERIFY, - pdcp_test_data_out[i], - pdcp_test_data_in_len[i], - pdcp_test_data_in[i], - pdcp_test_data_in_len[i]); -} - -int -test_pdcp_proto_uplane_decap_with_int(int i) -{ - return test_pdcp_proto(i, 0, - RTE_CRYPTO_CIPHER_OP_DECRYPT, - RTE_CRYPTO_AUTH_OP_VERIFY, - pdcp_test_data_out[i], - pdcp_test_data_in_len[i] + 4, - pdcp_test_data_in[i], - pdcp_test_data_in_len[i]); -} - -static int -test_PDCP_PROTO_SGL_in_place_32B(void) -{ - /* i can be used for running any PDCP case - * In this case it is uplane 12-bit AES-SNOW DL encap - */ - int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK; - return test_pdcp_proto_SGL(i, IN_PLACE, - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_AUTH_OP_GENERATE, - pdcp_test_data_in[i], - pdcp_test_data_in_len[i], - pdcp_test_data_out[i], - pdcp_test_data_in_len[i]+4, - 32, 0); -} -static int -test_PDCP_PROTO_SGL_oop_32B_128B(void) -{ - /* i can be used for running any PDCP case - * In this case it is uplane 18-bit NULL-NULL DL encap - */ - int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK; - return test_pdcp_proto_SGL(i, OUT_OF_PLACE, - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_AUTH_OP_GENERATE, - pdcp_test_data_in[i], - pdcp_test_data_in_len[i], - pdcp_test_data_out[i], - pdcp_test_data_in_len[i]+4, - 32, 128); -} -static int -test_PDCP_PROTO_SGL_oop_32B_40B(void) -{ - /* i can be used for running any PDCP case - * In this case it is uplane 18-bit AES DL encap - */ - int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET - + DOWNLINK; - return test_pdcp_proto_SGL(i, OUT_OF_PLACE, - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_AUTH_OP_GENERATE, - pdcp_test_data_in[i], - pdcp_test_data_in_len[i], - pdcp_test_data_out[i], - pdcp_test_data_in_len[i], - 32, 40); -} static int -test_PDCP_PROTO_SGL_oop_128B_32B(void) +test_AES_CCM_authenticated_encryption_test_case_128_1(void) { - /* i can be used for running any PDCP case - * In this case it is cplane 12-bit AES-ZUC DL encap - */ - int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK; - return test_pdcp_proto_SGL(i, OUT_OF_PLACE, - RTE_CRYPTO_CIPHER_OP_ENCRYPT, - RTE_CRYPTO_AUTH_OP_GENERATE, - pdcp_test_data_in[i], - pdcp_test_data_in_len[i], - pdcp_test_data_out[i], - pdcp_test_data_in_len[i]+4, - 128, 32); + return test_authenticated_encryption(&ccm_test_case_128_1); } -#endif static int -test_AES_GCM_authenticated_encryption_test_case_1(void) +test_AES_CCM_authenticated_encryption_test_case_128_2(void) { - return test_authenticated_encryption(&gcm_test_case_1); + return test_authenticated_encryption(&ccm_test_case_128_2); } static int -test_AES_GCM_authenticated_encryption_test_case_2(void) +test_AES_CCM_authenticated_encryption_test_case_128_3(void) { - return test_authenticated_encryption(&gcm_test_case_2); + return test_authenticated_encryption(&ccm_test_case_128_3); } static int -test_AES_GCM_authenticated_encryption_test_case_3(void) +test_AES_CCM_authenticated_decryption_test_case_128_1(void) { - return test_authenticated_encryption(&gcm_test_case_3); + return test_authenticated_decryption(&ccm_test_case_128_1); } static int -test_AES_GCM_authenticated_encryption_test_case_4(void) +test_AES_CCM_authenticated_decryption_test_case_128_2(void) { - return test_authenticated_encryption(&gcm_test_case_4); + return test_authenticated_decryption(&ccm_test_case_128_2); } static int -test_AES_GCM_authenticated_encryption_test_case_5(void) +test_AES_CCM_authenticated_decryption_test_case_128_3(void) { - return test_authenticated_encryption(&gcm_test_case_5); + return test_authenticated_decryption(&ccm_test_case_128_3); } static int -test_AES_GCM_authenticated_encryption_test_case_6(void) +test_AES_CCM_authenticated_encryption_test_case_192_1(void) { - return test_authenticated_encryption(&gcm_test_case_6); + return test_authenticated_encryption(&ccm_test_case_192_1); } static int -test_AES_GCM_authenticated_encryption_test_case_7(void) +test_AES_CCM_authenticated_encryption_test_case_192_2(void) { - return test_authenticated_encryption(&gcm_test_case_7); + return test_authenticated_encryption(&ccm_test_case_192_2); } static int -test_AES_GCM_authenticated_encryption_test_case_8(void) +test_AES_CCM_authenticated_encryption_test_case_192_3(void) { - return test_authenticated_encryption(&gcm_test_case_8); + return test_authenticated_encryption(&ccm_test_case_192_3); } static int -test_AES_GCM_auth_encryption_test_case_192_1(void) +test_AES_CCM_authenticated_decryption_test_case_192_1(void) { - return test_authenticated_encryption(&gcm_test_case_192_1); + return test_authenticated_decryption(&ccm_test_case_192_1); } static int -test_AES_GCM_auth_encryption_test_case_192_2(void) +test_AES_CCM_authenticated_decryption_test_case_192_2(void) { - return test_authenticated_encryption(&gcm_test_case_192_2); + return test_authenticated_decryption(&ccm_test_case_192_2); } static int -test_AES_GCM_auth_encryption_test_case_192_3(void) +test_AES_CCM_authenticated_decryption_test_case_192_3(void) { - return test_authenticated_encryption(&gcm_test_case_192_3); + return test_authenticated_decryption(&ccm_test_case_192_3); } static int -test_AES_GCM_auth_encryption_test_case_192_4(void) +test_AES_CCM_authenticated_encryption_test_case_256_1(void) { - return test_authenticated_encryption(&gcm_test_case_192_4); + return test_authenticated_encryption(&ccm_test_case_256_1); } static int -test_AES_GCM_auth_encryption_test_case_192_5(void) +test_AES_CCM_authenticated_encryption_test_case_256_2(void) { - return test_authenticated_encryption(&gcm_test_case_192_5); + return test_authenticated_encryption(&ccm_test_case_256_2); } static int -test_AES_GCM_auth_encryption_test_case_192_6(void) +test_AES_CCM_authenticated_encryption_test_case_256_3(void) { - return test_authenticated_encryption(&gcm_test_case_192_6); + return test_authenticated_encryption(&ccm_test_case_256_3); } static int -test_AES_GCM_auth_encryption_test_case_192_7(void) +test_AES_CCM_authenticated_decryption_test_case_256_1(void) { - return test_authenticated_encryption(&gcm_test_case_192_7); + return test_authenticated_decryption(&ccm_test_case_256_1); } static int -test_AES_GCM_auth_encryption_test_case_256_1(void) +test_AES_CCM_authenticated_decryption_test_case_256_2(void) { - return test_authenticated_encryption(&gcm_test_case_256_1); + return test_authenticated_decryption(&ccm_test_case_256_2); } static int -test_AES_GCM_auth_encryption_test_case_256_2(void) +test_AES_CCM_authenticated_decryption_test_case_256_3(void) { - return test_authenticated_encryption(&gcm_test_case_256_2); + return test_authenticated_decryption(&ccm_test_case_256_3); } static int -test_AES_GCM_auth_encryption_test_case_256_3(void) +test_stats(void) { - return test_authenticated_encryption(&gcm_test_case_256_3); -} + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct rte_cryptodev_stats stats; + struct rte_cryptodev *dev; + cryptodev_stats_get_t temp_pfn; -static int -test_AES_GCM_auth_encryption_test_case_256_4(void) -{ - return test_authenticated_encryption(&gcm_test_case_256_4); -} + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; -static int -test_AES_GCM_auth_encryption_test_case_256_5(void) -{ - return test_authenticated_encryption(&gcm_test_case_256_5); -} - -static int -test_AES_GCM_auth_encryption_test_case_256_6(void) -{ - return test_authenticated_encryption(&gcm_test_case_256_6); -} - -static int -test_AES_GCM_auth_encryption_test_case_256_7(void) -{ - return test_authenticated_encryption(&gcm_test_case_256_7); -} - -static int -test_AES_GCM_auth_encryption_test_case_aad_1(void) -{ - return test_authenticated_encryption(&gcm_test_case_aad_1); -} - -static int -test_AES_GCM_auth_encryption_test_case_aad_2(void) -{ - return test_authenticated_encryption(&gcm_test_case_aad_2); -} - -static int -test_AES_GCM_auth_encryption_fail_iv_corrupt(void) -{ - struct aead_test_data tdata; - int res; + /* 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_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); - TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); - return TEST_SUCCESS; -} + rte_cryptodev_stats_reset(ts_params->valid_devs[0]); + TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600, + &stats) == -ENODEV), + "rte_cryptodev_stats_get invalid dev failed"); + TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0), + "rte_cryptodev_stats_get invalid Param failed"); + dev = &rte_cryptodevs[ts_params->valid_devs[0]]; + temp_pfn = dev->dev_ops->stats_get; + dev->dev_ops->stats_get = (cryptodev_stats_get_t)0; + TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats) + == -ENOTSUP), + "rte_cryptodev_stats_get invalid Param failed"); + dev->dev_ops->stats_get = temp_pfn; -static int -test_AES_GCM_auth_encryption_fail_in_data_corrupt(void) -{ - struct aead_test_data tdata; - int res; + /* Test expected values */ + ut_setup(); + test_AES_CBC_HMAC_SHA1_encrypt_digest(); + ut_teardown(); + TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], + &stats), + "rte_cryptodev_stats_get failed"); + TEST_ASSERT((stats.enqueued_count == 1), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.dequeued_count == 1), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.enqueue_err_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.dequeue_err_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); - 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); - TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); - return TEST_SUCCESS; -} + /* invalid device but should ignore and not reset device stats*/ + rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300); + TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], + &stats), + "rte_cryptodev_stats_get failed"); + TEST_ASSERT((stats.enqueued_count == 1), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); -static int -test_AES_GCM_auth_encryption_fail_out_data_corrupt(void) -{ - struct aead_test_data tdata; - int res; + /* check that a valid reset clears stats */ + rte_cryptodev_stats_reset(ts_params->valid_devs[0]); + TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], + &stats), + "rte_cryptodev_stats_get failed"); + TEST_ASSERT((stats.enqueued_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); + TEST_ASSERT((stats.dequeued_count == 0), + "rte_cryptodev_stats_get returned unexpected enqueued stat"); - 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); - TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); return TEST_SUCCESS; } -static int -test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void) +static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + enum rte_crypto_auth_operation op, + const struct HMAC_MD5_vector *test_case) { - 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); - TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); - return TEST_SUCCESS; -} + uint8_t key[64]; -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; + memcpy(key, test_case->key.data, test_case->key.len); - RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); - memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); - 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); - TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); - return TEST_SUCCESS; -} + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + ut_params->auth_xform.auth.op = op; -static int -test_AES_GCM_auth_encryption_fail_tag_corrupt(void) -{ - struct aead_test_data tdata; - int res; + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC; - 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); - TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); - return TEST_SUCCESS; -} + ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN; + ut_params->auth_xform.auth.key.length = test_case->key.len; + ut_params->auth_xform.auth.key.data = key; -static int -test_authenticated_decryption(const struct aead_test_data *tdata) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - int retval; - uint8_t *plaintext; - uint32_t i; + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + ut_params->sess, &ut_params->auth_xform, + ts_params->session_priv_mpool); - /* Create AEAD session */ - retval = create_aead_session(ts_params->valid_devs[0], - tdata->algo, - RTE_CRYPTO_AEAD_OP_DECRYPT, - tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->auth_tag.len, - tdata->iv.len); - if (retval < 0) - return retval; + if (ut_params->sess == NULL) + return TEST_FAILED; - /* alloc mbuf and set payload */ - if (tdata->aad.len > MBUF_SIZE) { - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); - /* Populate full size of add data */ - for (i = 32; i < MAX_AAD_LENGTH; i += 32) - memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); - } else - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->ibuf)); - /* Create AEAD operation */ - retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); - if (retval < 0) - return retval; + return 0; +} - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); +static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params, + const struct HMAC_MD5_vector *test_case, + uint8_t **plaintext) +{ + uint16_t plaintext_pad_len; - ut_params->op->sym->m_src = ut_params->ibuf; + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); + plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, + 16); - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing failed"); + *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + memcpy(*plaintext, test_case->plaintext.data, + test_case->plaintext.len); - if (ut_params->op->sym->m_dst) - plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, - uint8_t *); - else - plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, - uint8_t *, - ut_params->op->sym->cipher.data.offset); + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, MD5_DIGEST_LEN); + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append digest"); + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( + ut_params->ibuf, plaintext_pad_len); - debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); + if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) { + rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data, + test_case->auth_tag.len); + } - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - plaintext, - tdata->plaintext.data, - tdata->plaintext.len, - "Plaintext data not as expected"); + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = test_case->plaintext.len; - TEST_ASSERT_EQUAL(ut_params->op->status, - RTE_CRYPTO_OP_STATUS_SUCCESS, - "Authentication failed"); + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + ut_params->op->sym->m_src = ut_params->ibuf; return 0; } static int -test_AES_GCM_authenticated_decryption_test_case_1(void) +test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case) { - return test_authenticated_decryption(&gcm_test_case_1); -} + uint16_t plaintext_pad_len; + uint8_t *plaintext, *auth_tag; -static int -test_AES_GCM_authenticated_decryption_test_case_2(void) -{ - return test_authenticated_decryption(&gcm_test_case_2); -} + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; -static int -test_AES_GCM_authenticated_decryption_test_case_3(void) -{ - return test_authenticated_decryption(&gcm_test_case_3); -} + /* 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; -static int -test_AES_GCM_authenticated_decryption_test_case_4(void) -{ - return test_authenticated_decryption(&gcm_test_case_4); -} + if (MD5_HMAC_create_session(ts_params, ut_params, + RTE_CRYPTO_AUTH_OP_GENERATE, test_case)) + return TEST_FAILED; -static int -test_AES_GCM_authenticated_decryption_test_case_5(void) -{ - return test_authenticated_decryption(&gcm_test_case_5); -} + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); -static int -test_AES_GCM_authenticated_decryption_test_case_6(void) -{ - return test_authenticated_decryption(&gcm_test_case_6); -} + plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, + 16); -static int -test_AES_GCM_authenticated_decryption_test_case_7(void) -{ - return test_authenticated_decryption(&gcm_test_case_7); -} + if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) + return TEST_FAILED; -static int -test_AES_GCM_authenticated_decryption_test_case_8(void) -{ - return test_authenticated_decryption(&gcm_test_case_8); -} + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_crypt_auth_op(ts_params->valid_devs[0], + ut_params->op); + else + TEST_ASSERT_NOT_NULL( + process_crypto_request(ts_params->valid_devs[0], + ut_params->op), + "failed to process sym crypto op"); -static int -test_AES_GCM_auth_decryption_test_case_192_1(void) -{ - return test_authenticated_decryption(&gcm_test_case_192_1); -} + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); -static int -test_AES_GCM_auth_decryption_test_case_192_2(void) -{ - return test_authenticated_decryption(&gcm_test_case_192_2); -} + if (ut_params->op->sym->m_dst) { + auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, + uint8_t *, plaintext_pad_len); + } else { + auth_tag = plaintext + plaintext_pad_len; + } -static int -test_AES_GCM_auth_decryption_test_case_192_3(void) -{ - return test_authenticated_decryption(&gcm_test_case_192_3); -} + TEST_ASSERT_BUFFERS_ARE_EQUAL( + auth_tag, + test_case->auth_tag.data, + test_case->auth_tag.len, + "HMAC_MD5 generated tag not as expected"); -static int -test_AES_GCM_auth_decryption_test_case_192_4(void) -{ - return test_authenticated_decryption(&gcm_test_case_192_4); + return TEST_SUCCESS; } static int -test_AES_GCM_auth_decryption_test_case_192_5(void) +test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case) { - return test_authenticated_decryption(&gcm_test_case_192_5); -} + uint8_t *plaintext; -static int -test_AES_GCM_auth_decryption_test_case_192_6(void) -{ - return test_authenticated_decryption(&gcm_test_case_192_6); -} + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; -static int -test_AES_GCM_auth_decryption_test_case_192_7(void) -{ - return test_authenticated_decryption(&gcm_test_case_192_7); -} + /* 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; -static int -test_AES_GCM_auth_decryption_test_case_256_1(void) -{ - return test_authenticated_decryption(&gcm_test_case_256_1); -} + if (MD5_HMAC_create_session(ts_params, ut_params, + RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) { + return TEST_FAILED; + } -static int -test_AES_GCM_auth_decryption_test_case_256_2(void) -{ - return test_authenticated_decryption(&gcm_test_case_256_2); -} + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); -static int -test_AES_GCM_auth_decryption_test_case_256_3(void) -{ - return test_authenticated_decryption(&gcm_test_case_256_3); -} + if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) + return TEST_FAILED; -static int -test_AES_GCM_auth_decryption_test_case_256_4(void) -{ - return test_authenticated_decryption(&gcm_test_case_256_4); -} + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_crypt_auth_op(ts_params->valid_devs[0], + ut_params->op); + else + TEST_ASSERT_NOT_NULL( + process_crypto_request(ts_params->valid_devs[0], + ut_params->op), + "failed to process sym crypto op"); -static int -test_AES_GCM_auth_decryption_test_case_256_5(void) -{ - return test_authenticated_decryption(&gcm_test_case_256_5); + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "HMAC_MD5 crypto op processing failed"); + + return TEST_SUCCESS; } static int -test_AES_GCM_auth_decryption_test_case_256_6(void) +test_MD5_HMAC_generate_case_1(void) { - return test_authenticated_decryption(&gcm_test_case_256_6); + return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1); } static int -test_AES_GCM_auth_decryption_test_case_256_7(void) +test_MD5_HMAC_verify_case_1(void) { - return test_authenticated_decryption(&gcm_test_case_256_7); + return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1); } static int -test_AES_GCM_auth_decryption_test_case_aad_1(void) +test_MD5_HMAC_generate_case_2(void) { - return test_authenticated_decryption(&gcm_test_case_aad_1); + return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2); } static int -test_AES_GCM_auth_decryption_test_case_aad_2(void) +test_MD5_HMAC_verify_case_2(void) { - return test_authenticated_decryption(&gcm_test_case_aad_2); + return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2); } static int -test_AES_GCM_auth_decryption_fail_iv_corrupt(void) +test_multi_session(void) { - struct aead_test_data tdata; - int res; + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; - memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); - tdata.iv.data[0] += 1; - res = test_authenticated_decryption(&tdata); - TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); - return TEST_SUCCESS; -} + struct rte_cryptodev_info dev_info; + struct rte_cryptodev_sym_session **sessions; -static int -test_AES_GCM_auth_decryption_fail_in_data_corrupt(void) -{ - struct aead_test_data tdata; - int res; + uint16_t i; - 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); - TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); - return TEST_SUCCESS; -} + /* 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; -static int -test_AES_GCM_auth_decryption_fail_out_data_corrupt(void) -{ - struct aead_test_data tdata; - int res; + test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params, + aes_cbc_key, hmac_sha512_key); - memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); - tdata.ciphertext.data[0] += 1; - res = test_authenticated_decryption(&tdata); - 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; + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); - tdata.aad.len += 1; - res = test_authenticated_decryption(&tdata); - TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); - return TEST_SUCCESS; -} + sessions = rte_malloc(NULL, + (sizeof(struct rte_cryptodev_sym_session *) * + MAX_NB_SESSIONS) + 1, 0); -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; + /* Create multiple crypto sessions*/ + for (i = 0; i < MAX_NB_SESSIONS; i++) { - 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); - TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); - return TEST_SUCCESS; -} + sessions[i] = rte_cryptodev_sym_session_create( + ts_params->session_mpool); -static int -test_AES_GCM_auth_decryption_fail_tag_corrupt(void) -{ - struct aead_test_data tdata; - int res; + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + sessions[i], &ut_params->auth_xform, + ts_params->session_priv_mpool); + TEST_ASSERT_NOT_NULL(sessions[i], + "Session creation failed at session number %u", + i); + + /* Attempt to send a request on each session */ + TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform( + sessions[i], + ut_params, + ts_params, + catch_22_quote_2_512_bytes_AES_CBC_ciphertext, + catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, + aes_cbc_iv), + "Failed to perform decrypt on request number %u.", i); + /* free crypto operation structure */ + if (ut_params->op) + rte_crypto_op_free(ut_params->op); + + /* + * free mbuf - both obuf and ibuf are usually the same, + * so check if they point at the same address is necessary, + * to avoid freeing the mbuf twice. + */ + if (ut_params->obuf) { + rte_pktmbuf_free(ut_params->obuf); + if (ut_params->ibuf == ut_params->obuf) + ut_params->ibuf = 0; + ut_params->obuf = 0; + } + if (ut_params->ibuf) { + rte_pktmbuf_free(ut_params->ibuf); + ut_params->ibuf = 0; + } + } + + /* Next session create should fail */ + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + sessions[i], &ut_params->auth_xform, + ts_params->session_priv_mpool); + TEST_ASSERT_NULL(sessions[i], + "Session creation succeeded unexpectedly!"); + + for (i = 0; i < MAX_NB_SESSIONS; i++) { + rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], + sessions[i]); + rte_cryptodev_sym_session_free(sessions[i]); + } + + rte_free(sessions); - memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); - tdata.auth_tag.data[0] += 1; - res = test_authenticated_decryption(&tdata); - TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed"); return TEST_SUCCESS; } +struct multi_session_params { + struct crypto_unittest_params ut_params; + uint8_t *cipher_key; + uint8_t *hmac_key; + const uint8_t *cipher; + const uint8_t *digest; + uint8_t *iv; +}; + +#define MB_SESSION_NUMBER 3 + static int -test_authenticated_encryption_oop(const struct aead_test_data *tdata) +test_multi_session_random_usage(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_cryptodev_info dev_info; + struct rte_cryptodev_sym_session **sessions; + uint32_t i, j; + struct multi_session_params ut_paramz[] = { - int retval; - uint8_t *ciphertext, *auth_tag; - uint16_t plaintext_pad_len; + { + .cipher_key = ms_aes_cbc_key0, + .hmac_key = ms_hmac_key0, + .cipher = ms_aes_cbc_cipher0, + .digest = ms_hmac_digest0, + .iv = ms_aes_cbc_iv0 + }, + { + .cipher_key = ms_aes_cbc_key1, + .hmac_key = ms_hmac_key1, + .cipher = ms_aes_cbc_cipher1, + .digest = ms_hmac_digest1, + .iv = ms_aes_cbc_iv1 + }, + { + .cipher_key = ms_aes_cbc_key2, + .hmac_key = ms_hmac_key2, + .cipher = ms_aes_cbc_cipher2, + .digest = ms_hmac_digest2, + .iv = ms_aes_cbc_iv2 + }, - /* Create AEAD session */ - retval = create_aead_session(ts_params->valid_devs[0], - tdata->algo, - RTE_CRYPTO_AEAD_OP_ENCRYPT, - tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->auth_tag.len, - tdata->iv.len); - if (retval < 0) - return retval; + }; - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + /* 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; - /* clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); - memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->obuf)); + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - /* Create AEAD operation */ - retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); - if (retval < 0) - return retval; + sessions = rte_malloc(NULL, + (sizeof(struct rte_cryptodev_sym_session *) + * MAX_NB_SESSIONS) + 1, 0); - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + for (i = 0; i < MB_SESSION_NUMBER; i++) { + sessions[i] = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - ut_params->op->sym->m_src = ut_params->ibuf; - ut_params->op->sym->m_dst = ut_params->obuf; + rte_memcpy(&ut_paramz[i].ut_params, &unittest_params, + sizeof(struct crypto_unittest_params)); - /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); + test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( + &ut_paramz[i].ut_params, + ut_paramz[i].cipher_key, ut_paramz[i].hmac_key); - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing failed"); + /* Create multiple crypto sessions*/ + rte_cryptodev_sym_session_init( + ts_params->valid_devs[0], + sessions[i], + &ut_paramz[i].ut_params.auth_xform, + ts_params->session_priv_mpool); - plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); + TEST_ASSERT_NOT_NULL(sessions[i], + "Session creation failed at session number %u", + i); - ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, - ut_params->op->sym->cipher.data.offset); - auth_tag = ciphertext + plaintext_pad_len; + } - debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); - debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); + srand(time(NULL)); + for (i = 0; i < 40000; i++) { - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ciphertext, - tdata->ciphertext.data, - tdata->ciphertext.len, - "Ciphertext data not as expected"); + j = rand() % MB_SESSION_NUMBER; - TEST_ASSERT_BUFFERS_ARE_EQUAL( - auth_tag, - tdata->auth_tag.data, - tdata->auth_tag.len, - "Generated auth tag not as expected"); + TEST_ASSERT_SUCCESS( + test_AES_CBC_HMAC_SHA512_decrypt_perform( + sessions[j], + &ut_paramz[j].ut_params, + ts_params, ut_paramz[j].cipher, + ut_paramz[j].digest, + ut_paramz[j].iv), + "Failed to perform decrypt on request number %u.", i); - return 0; + if (ut_paramz[j].ut_params.op) + rte_crypto_op_free(ut_paramz[j].ut_params.op); -} + /* + * free mbuf - both obuf and ibuf are usually the same, + * so check if they point at the same address is necessary, + * to avoid freeing the mbuf twice. + */ + if (ut_paramz[j].ut_params.obuf) { + rte_pktmbuf_free(ut_paramz[j].ut_params.obuf); + if (ut_paramz[j].ut_params.ibuf + == ut_paramz[j].ut_params.obuf) + ut_paramz[j].ut_params.ibuf = 0; + ut_paramz[j].ut_params.obuf = 0; + } + if (ut_paramz[j].ut_params.ibuf) { + rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf); + ut_paramz[j].ut_params.ibuf = 0; + } + } -static int -test_AES_GCM_authenticated_encryption_oop_test_case_1(void) -{ - return test_authenticated_encryption_oop(&gcm_test_case_5); + for (i = 0; i < MB_SESSION_NUMBER; i++) { + rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], + sessions[i]); + rte_cryptodev_sym_session_free(sessions[i]); + } + + rte_free(sessions); + + return TEST_SUCCESS; } static int -test_authenticated_decryption_oop(const struct aead_test_data *tdata) +test_null_cipher_only_operation(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - int retval; - uint8_t *plaintext; + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_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; - /* Create AEAD session */ - retval = create_aead_session(ts_params->valid_devs[0], - tdata->algo, - RTE_CRYPTO_AEAD_OP_DECRYPT, - tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->auth_tag.len, - tdata->iv.len); - if (retval < 0) - return retval; + /* 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); - /* alloc mbuf and set payload */ - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); - memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->obuf)); + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; - /* Create AEAD operation */ - retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); - if (retval < 0) - return retval; + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); + + /* Create Crypto session*/ + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + ut_params->sess, + &ut_params->cipher_xform, + ts_params->session_priv_mpool); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); + /* Set crypto operation data parameters */ rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - ut_params->op->sym->m_src = ut_params->ibuf; - ut_params->op->sym->m_dst = ut_params->obuf; + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing failed"); + sym_op->cipher.data.offset = 0; + sym_op->cipher.data.length = QUOTE_512_BYTES; - plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, - ut_params->op->sym->cipher.data.offset); + /* Process crypto operation */ + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); - debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto operation processing failed"); /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( - plaintext, - tdata->plaintext.data, - tdata->plaintext.len, - "Plaintext data not as expected"); - - TEST_ASSERT_EQUAL(ut_params->op->status, - RTE_CRYPTO_OP_STATUS_SUCCESS, - "Authentication failed"); - return 0; -} + rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), + catch_22_quote, + QUOTE_512_BYTES, + "Ciphertext data not as expected"); -static int -test_AES_GCM_authenticated_decryption_oop_test_case_1(void) -{ - return test_authenticated_decryption_oop(&gcm_test_case_5); + return TEST_SUCCESS; } - +uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab, + 0xab, 0xab, 0xab, 0xab, + 0xab, 0xab, 0xab, 0xab, + 0xab, 0xab, 0xab, 0xab}; static int -test_authenticated_encryption_sessionless( - const struct aead_test_data *tdata) +test_null_auth_only_operation(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + uint8_t *digest; - int retval; - uint8_t *ciphertext, *auth_tag; - uint16_t plaintext_pad_len; - uint8_t key[tdata->key.len + 1]; - - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + /* 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; - /* clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + /* 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); - /* Create AEAD operation */ - retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); - if (retval < 0) - return retval; + /* create a pointer for digest, but don't expect anything to be written + * here in a NULL auth algo so no mbuf append done. + */ + digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, + QUOTE_512_BYTES); + /* prefill the memory pointed to by digest */ + memcpy(digest, orig_data, sizeof(orig_data)); - /* Create GCM xform */ - memcpy(key, tdata->key.data, tdata->key.len); - retval = create_aead_xform(ut_params->op, - tdata->algo, - RTE_CRYPTO_AEAD_OP_ENCRYPT, - key, tdata->key.len, - tdata->aad.len, tdata->auth_tag.len, - tdata->iv.len); - if (retval < 0) - return retval; + /* Setup HMAC Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; - ut_params->op->sym->m_src = ut_params->ibuf; + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; - TEST_ASSERT_EQUAL(ut_params->op->sess_type, - RTE_CRYPTO_OP_SESSIONLESS, - "crypto op session type not sessionless"); + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); + /* Create Crypto session*/ + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + ut_params->sess, &ut_params->auth_xform, + ts_params->session_priv_mpool); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op status not success"); + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, - ut_params->op->sym->cipher.data.offset); - auth_tag = ciphertext + plaintext_pad_len; + sym_op->m_src = ut_params->ibuf; - debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); - debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = QUOTE_512_BYTES; + sym_op->auth.digest.data = digest; + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf, + QUOTE_512_BYTES); - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ciphertext, - tdata->ciphertext.data, - tdata->ciphertext.len, - "Ciphertext data not as expected"); + /* Process crypto operation */ + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto operation processing failed"); + /* Make sure memory pointed to by digest hasn't been overwritten */ TEST_ASSERT_BUFFERS_ARE_EQUAL( - auth_tag, - tdata->auth_tag.data, - tdata->auth_tag.len, - "Generated auth tag not as expected"); - - return 0; + orig_data, + digest, + sizeof(orig_data), + "Memory at digest ptr overwritten unexpectedly"); + return TEST_SUCCESS; } -static int -test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void) -{ - return test_authenticated_encryption_sessionless( - &gcm_test_case_5); -} static int -test_authenticated_decryption_sessionless( - const struct aead_test_data *tdata) +test_null_cipher_auth_operation(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + uint8_t *digest; - int retval; - uint8_t *plaintext; - uint8_t key[tdata->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 = 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; - /* alloc mbuf and set payload */ - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + /* 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); - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + /* create a pointer for digest, but don't expect anything to be written + * here in a NULL auth algo so no mbuf append done. + */ + digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, + QUOTE_512_BYTES); + /* prefill the memory pointed to by digest */ + memcpy(digest, orig_data, sizeof(orig_data)); - /* Create AEAD operation */ - retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); - if (retval < 0) - return retval; + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = &ut_params->auth_xform; - /* Create AEAD xform */ - memcpy(key, tdata->key.data, tdata->key.len); - retval = create_aead_xform(ut_params->op, - tdata->algo, - RTE_CRYPTO_AEAD_OP_DECRYPT, - key, tdata->key.len, - tdata->aad.len, tdata->auth_tag.len, - tdata->iv.len); - if (retval < 0) - return retval; + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; - ut_params->op->sym->m_src = ut_params->ibuf; + /* Setup HMAC Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; - TEST_ASSERT_EQUAL(ut_params->op->sess_type, - RTE_CRYPTO_OP_SESSIONLESS, - "crypto op session type not sessionless"); + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; - /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); + /* Create Crypto session*/ + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + ut_params->sess, &ut_params->cipher_xform, + ts_params->session_priv_mpool); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op status not success"); + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); - plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, - ut_params->op->sym->cipher.data.offset); + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + sym_op->m_src = ut_params->ibuf; + + sym_op->cipher.data.offset = 0; + sym_op->cipher.data.length = QUOTE_512_BYTES; + + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = QUOTE_512_BYTES; + sym_op->auth.digest.data = digest; + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf, + QUOTE_512_BYTES); + + /* Process crypto operation */ + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto operation processing failed"); /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( - plaintext, - tdata->plaintext.data, - tdata->plaintext.len, - "Plaintext data not as expected"); + rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), + catch_22_quote, + QUOTE_512_BYTES, + "Ciphertext data not as expected"); + /* Make sure memory pointed to by digest hasn't been overwritten */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + orig_data, + digest, + sizeof(orig_data), + "Memory at digest ptr overwritten unexpectedly"); - TEST_ASSERT_EQUAL(ut_params->op->status, - RTE_CRYPTO_OP_STATUS_SUCCESS, - "Authentication failed"); - return 0; + return TEST_SUCCESS; } static int -test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void) +test_null_auth_cipher_operation(void) { - return test_authenticated_decryption_sessionless( - &gcm_test_case_5); -} + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + uint8_t *digest; -static int -test_AES_CCM_authenticated_encryption_test_case_128_1(void) -{ - return test_authenticated_encryption(&ccm_test_case_128_1); -} + /* 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; -static int -test_AES_CCM_authenticated_encryption_test_case_128_2(void) -{ - return test_authenticated_encryption(&ccm_test_case_128_2); -} + /* Generate test mbuf data */ + ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, + catch_22_quote, QUOTE_512_BYTES, 0); -static int -test_AES_CCM_authenticated_encryption_test_case_128_3(void) -{ - return test_authenticated_encryption(&ccm_test_case_128_3); -} + /* create a pointer for digest, but don't expect anything to be written + * here in a NULL auth algo so no mbuf append done. + */ + digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, + QUOTE_512_BYTES); + /* prefill the memory pointed to by digest */ + memcpy(digest, orig_data, sizeof(orig_data)); -static int -test_AES_CCM_authenticated_decryption_test_case_128_1(void) -{ - return test_authenticated_decryption(&ccm_test_case_128_1); -} + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; -static int -test_AES_CCM_authenticated_decryption_test_case_128_2(void) -{ - return test_authenticated_decryption(&ccm_test_case_128_2); -} + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; -static int -test_AES_CCM_authenticated_decryption_test_case_128_3(void) -{ - return test_authenticated_decryption(&ccm_test_case_128_3); -} + /* Setup HMAC Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = &ut_params->cipher_xform; -static int -test_AES_CCM_authenticated_encryption_test_case_192_1(void) -{ - return test_authenticated_encryption(&ccm_test_case_192_1); -} + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; -static int -test_AES_CCM_authenticated_encryption_test_case_192_2(void) -{ - return test_authenticated_encryption(&ccm_test_case_192_2); -} + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); -static int -test_AES_CCM_authenticated_encryption_test_case_192_3(void) -{ - return test_authenticated_encryption(&ccm_test_case_192_3); -} + /* Create Crypto session*/ + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + ut_params->sess, &ut_params->cipher_xform, + ts_params->session_priv_mpool); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); -static int -test_AES_CCM_authenticated_decryption_test_case_192_1(void) -{ - return test_authenticated_decryption(&ccm_test_case_192_1); -} + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); -static int -test_AES_CCM_authenticated_decryption_test_case_192_2(void) -{ - return test_authenticated_decryption(&ccm_test_case_192_2); -} + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); -static int -test_AES_CCM_authenticated_decryption_test_case_192_3(void) -{ - return test_authenticated_decryption(&ccm_test_case_192_3); -} + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; -static int -test_AES_CCM_authenticated_encryption_test_case_256_1(void) -{ - return test_authenticated_encryption(&ccm_test_case_256_1); -} + sym_op->m_src = ut_params->ibuf; -static int -test_AES_CCM_authenticated_encryption_test_case_256_2(void) -{ - return test_authenticated_encryption(&ccm_test_case_256_2); -} + sym_op->cipher.data.offset = 0; + sym_op->cipher.data.length = QUOTE_512_BYTES; -static int -test_AES_CCM_authenticated_encryption_test_case_256_3(void) -{ - return test_authenticated_encryption(&ccm_test_case_256_3); -} + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = QUOTE_512_BYTES; + sym_op->auth.digest.data = digest; + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf, + QUOTE_512_BYTES); -static int -test_AES_CCM_authenticated_decryption_test_case_256_1(void) -{ - return test_authenticated_decryption(&ccm_test_case_256_1); -} + /* Process crypto operation */ + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); -static int -test_AES_CCM_authenticated_decryption_test_case_256_2(void) -{ - return test_authenticated_decryption(&ccm_test_case_256_2); -} + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto operation processing failed"); -static int -test_AES_CCM_authenticated_decryption_test_case_256_3(void) -{ - return test_authenticated_decryption(&ccm_test_case_256_3); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), + catch_22_quote, + QUOTE_512_BYTES, + "Ciphertext data not as expected"); + /* Make sure memory pointed to by digest hasn't been overwritten */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + orig_data, + digest, + sizeof(orig_data), + "Memory at digest ptr overwritten unexpectedly"); + + return TEST_SUCCESS; } + static int -test_stats(void) +test_null_invalid_operation(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; - struct rte_cryptodev_stats stats; - struct rte_cryptodev *dev; - cryptodev_stats_get_t temp_pfn; + struct crypto_unittest_params *ut_params = &unittest_params; + int ret; - rte_cryptodev_stats_reset(ts_params->valid_devs[0]); - TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600, - &stats) == -ENODEV), - "rte_cryptodev_stats_get invalid dev failed"); - TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0), - "rte_cryptodev_stats_get invalid Param failed"); - dev = &rte_cryptodevs[ts_params->valid_devs[0]]; - temp_pfn = dev->dev_ops->stats_get; - dev->dev_ops->stats_get = (cryptodev_stats_get_t)0; - TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats) - == -ENOTSUP), - "rte_cryptodev_stats_get invalid Param failed"); - dev->dev_ops->stats_get = temp_pfn; + /* This test is for NULL PMD only */ + if (gbl_driver_id != rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_NULL_PMD))) + return -ENOTSUP; - /* Test expected values */ - ut_setup(); - test_AES_CBC_HMAC_SHA1_encrypt_digest(); - ut_teardown(); - TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], - &stats), - "rte_cryptodev_stats_get failed"); - TEST_ASSERT((stats.enqueued_count == 1), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.dequeued_count == 1), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.enqueue_err_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.dequeue_err_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; - /* invalid device but should ignore and not reset device stats*/ - rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300); - TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], - &stats), - "rte_cryptodev_stats_get failed"); - TEST_ASSERT((stats.enqueued_count == 1), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; - /* check that a valid reset clears stats */ - rte_cryptodev_stats_reset(ts_params->valid_devs[0]); - TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], - &stats), - "rte_cryptodev_stats_get failed"); - TEST_ASSERT((stats.enqueued_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); - TEST_ASSERT((stats.dequeued_count == 0), - "rte_cryptodev_stats_get returned unexpected enqueued stat"); + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); + + /* Create Crypto session*/ + ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + ut_params->sess, &ut_params->cipher_xform, + ts_params->session_priv_mpool); + TEST_ASSERT(ret < 0, + "Session creation succeeded unexpectedly"); + + + /* Setup HMAC Parameters */ + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); + + /* Create Crypto session*/ + ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + ut_params->sess, &ut_params->auth_xform, + ts_params->session_priv_mpool); + TEST_ASSERT(ret < 0, + "Session creation succeeded unexpectedly"); return TEST_SUCCESS; } -static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - enum rte_crypto_auth_operation op, - const struct HMAC_MD5_vector *test_case) + +#define NULL_BURST_LENGTH (32) + +static int +test_null_burst_operation(void) { - uint8_t key[64]; + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; - memcpy(key, test_case->key.data, test_case->key.len); + unsigned i, burst_len = NULL_BURST_LENGTH; + + struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL }; + struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL }; + + /* This test is for NULL PMD only */ + if (gbl_driver_id != rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_NULL_PMD))) + return -ENOTSUP; + + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = &ut_params->auth_xform; + + ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; + ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + /* Setup HMAC Parameters */ ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; ut_params->auth_xform.next = NULL; - ut_params->auth_xform.auth.op = op; - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC; - - ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN; - ut_params->auth_xform.auth.key.length = test_case->key.len; - ut_params->auth_xform.auth.key.data = key; + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; ut_params->sess = rte_cryptodev_sym_session_create( ts_params->session_mpool); + /* Create Crypto session*/ rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - ut_params->sess, &ut_params->auth_xform, + ut_params->sess, &ut_params->cipher_xform, ts_params->session_priv_mpool); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); - if (ut_params->sess == NULL) - return TEST_FAILED; + TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len), + burst_len, "failed to generate burst of crypto ops"); - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + /* Generate an operation for each mbuf in burst */ + for (i = 0; i < burst_len; i++) { + struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool); - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf"); - return 0; -} + unsigned *data = (unsigned *)rte_pktmbuf_append(m, + sizeof(unsigned)); + *data = i; -static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params, - const struct HMAC_MD5_vector *test_case, - uint8_t **plaintext) -{ - uint16_t plaintext_pad_len; + rte_crypto_op_attach_sym_session(burst[i], ut_params->sess); - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + burst[i]->sym->m_src = m; + } - plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, - 16); + /* Process crypto operation */ + TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0], + 0, burst, burst_len), + burst_len, + "Error enqueuing burst"); - *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); - memcpy(*plaintext, test_case->plaintext.data, - test_case->plaintext.len); + TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0], + 0, burst_dequeued, burst_len), + burst_len, + "Error dequeuing burst"); - sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( - ut_params->ibuf, MD5_DIGEST_LEN); - TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, - "no room to append digest"); - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( - ut_params->ibuf, plaintext_pad_len); - if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) { - rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data, - test_case->auth_tag.len); + for (i = 0; i < burst_len; i++) { + TEST_ASSERT_EQUAL( + *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *), + *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src, + uint32_t *), + "data not as expected"); + + rte_pktmbuf_free(burst[i]->sym->m_src); + rte_crypto_op_free(burst[i]); } - sym_op->auth.data.offset = 0; - sym_op->auth.data.length = test_case->plaintext.len; + return TEST_SUCCESS; +} - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - ut_params->op->sym->m_src = ut_params->ibuf; +static void +generate_gmac_large_plaintext(uint8_t *data) +{ + uint16_t i; - return 0; + for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32) + memcpy(&data[i], &data[0], 32); } static int -test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case) +create_gmac_operation(enum rte_crypto_auth_operation op, + const struct gmac_test_data *tdata) { - uint16_t plaintext_pad_len; - uint8_t *plaintext, *auth_tag; - struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_crypto_sym_op *sym_op; - if (MD5_HMAC_create_session(ts_params, ut_params, - RTE_CRYPTO_AUTH_OP_GENERATE, test_case)) - return TEST_FAILED; + uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, @@ -9559,3373 +9769,1995 @@ test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case) TEST_ASSERT_NOT_NULL(ut_params->op, "Failed to allocate symmetric crypto operation struct"); - plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, - 16); - - if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) - return TEST_FAILED; + sym_op = ut_params->op->sym; - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, tdata->gmac_tag.len); + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append digest"); - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing failed"); + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( + ut_params->ibuf, plaintext_pad_len); - if (ut_params->op->sym->m_dst) { - auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, - uint8_t *, plaintext_pad_len); - } else { - auth_tag = plaintext + plaintext_pad_len; + if (op == RTE_CRYPTO_AUTH_OP_VERIFY) { + rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data, + tdata->gmac_tag.len); + debug_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + tdata->gmac_tag.len); } - TEST_ASSERT_BUFFERS_ARE_EQUAL( - auth_tag, - test_case->auth_tag.data, - test_case->auth_tag.len, - "HMAC_MD5 generated tag not as expected"); + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); - return TEST_SUCCESS; + rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); + + debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len); + + sym_op->cipher.data.length = 0; + sym_op->cipher.data.offset = 0; + + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = tdata->plaintext.len; + + return 0; } -static int -test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case) +static int create_gmac_session(uint8_t dev_id, + const struct gmac_test_data *tdata, + enum rte_crypto_auth_operation auth_op) { - uint8_t *plaintext; + uint8_t auth_key[tdata->key.len]; struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - if (MD5_HMAC_create_session(ts_params, ut_params, - RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) { - return TEST_FAILED; - } + memcpy(auth_key, tdata->key.data, tdata->key.len); - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate symmetric crypto operation struct"); + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; - if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) - return TEST_FAILED; + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC; + ut_params->auth_xform.auth.op = auth_op; + ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len; + ut_params->auth_xform.auth.key.length = tdata->key.len; + ut_params->auth_xform.auth.key.data = auth_key; + ut_params->auth_xform.auth.iv.offset = IV_OFFSET; + ut_params->auth_xform.auth.iv.length = tdata->iv.len; - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "HMAC_MD5 crypto op processing failed"); + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - return TEST_SUCCESS; -} + rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->auth_xform, + ts_params->session_priv_mpool); -static int -test_MD5_HMAC_generate_case_1(void) -{ - return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + + return 0; } static int -test_MD5_HMAC_verify_case_1(void) +test_AES_GMAC_authentication(const struct gmac_test_data *tdata) { - return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1); -} + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; -static int -test_MD5_HMAC_generate_case_2(void) -{ - return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2); -} + int retval; -static int -test_MD5_HMAC_verify_case_2(void) -{ - return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2); -} + uint8_t *auth_tag, *plaintext; + uint16_t plaintext_pad_len; -static int -test_multi_session(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, + "No GMAC length in the source data"); - struct rte_cryptodev_info dev_info; - struct rte_cryptodev_sym_session **sessions; + /* 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; - uint16_t i; + retval = create_gmac_session(ts_params->valid_devs[0], + tdata, RTE_CRYPTO_AUTH_OP_GENERATE); - test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params, - aes_cbc_key, hmac_sha512_key); + if (retval < 0) + return retval; + if (tdata->plaintext.len > MBUF_SIZE) + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); + else + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - sessions = rte_malloc(NULL, - (sizeof(struct rte_cryptodev_sym_session *) * - MAX_NB_SESSIONS) + 1, 0); + plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); + /* + * Runtime generate the large plain text instead of use hard code + * plain text vector. It is done to avoid create huge source file + * with the test vector. + */ + if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH) + generate_gmac_large_plaintext(tdata->plaintext.data); - /* Create multiple crypto sessions*/ - for (i = 0; i < MAX_NB_SESSIONS; i++) { + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); - sessions[i] = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); + debug_hexdump(stdout, "plaintext:", plaintext, + tdata->plaintext.len); - rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - sessions[i], &ut_params->auth_xform, - ts_params->session_priv_mpool); - TEST_ASSERT_NOT_NULL(sessions[i], - "Session creation failed at session number %u", - i); + retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE, + tdata); - /* Attempt to send a request on each session */ - TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform( - sessions[i], - ut_params, - ts_params, - catch_22_quote_2_512_bytes_AES_CBC_ciphertext, - catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, - aes_cbc_iv), - "Failed to perform decrypt on request number %u.", i); - /* free crypto operation structure */ - if (ut_params->op) - rte_crypto_op_free(ut_params->op); + if (retval < 0) + return retval; - /* - * free mbuf - both obuf and ibuf are usually the same, - * so check if they point at the same address is necessary, - * to avoid freeing the mbuf twice. - */ - if (ut_params->obuf) { - rte_pktmbuf_free(ut_params->obuf); - if (ut_params->ibuf == ut_params->obuf) - ut_params->ibuf = 0; - ut_params->obuf = 0; - } - if (ut_params->ibuf) { - rte_pktmbuf_free(ut_params->ibuf); - ut_params->ibuf = 0; - } - } + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - /* Next session create should fail */ - rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - sessions[i], &ut_params->auth_xform, - ts_params->session_priv_mpool); - TEST_ASSERT_NULL(sessions[i], - "Session creation succeeded unexpectedly!"); + ut_params->op->sym->m_src = ut_params->ibuf; - for (i = 0; i < MAX_NB_SESSIONS; i++) { - rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], - sessions[i]); - rte_cryptodev_sym_session_free(sessions[i]); + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_crypt_auth_op(ts_params->valid_devs[0], + ut_params->op); + else + TEST_ASSERT_NOT_NULL( + process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + if (ut_params->op->sym->m_dst) { + auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, + uint8_t *, plaintext_pad_len); + } else { + auth_tag = plaintext + plaintext_pad_len; } - rte_free(sessions); + debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len); - return TEST_SUCCESS; -} + TEST_ASSERT_BUFFERS_ARE_EQUAL( + auth_tag, + tdata->gmac_tag.data, + tdata->gmac_tag.len, + "GMAC Generated auth tag not as expected"); -struct multi_session_params { - struct crypto_unittest_params ut_params; - uint8_t *cipher_key; - uint8_t *hmac_key; - const uint8_t *cipher; - const uint8_t *digest; - uint8_t *iv; -}; + return 0; +} -#define MB_SESSION_NUMBER 3 +static int +test_AES_GMAC_authentication_test_case_1(void) +{ + return test_AES_GMAC_authentication(&gmac_test_case_1); +} static int -test_multi_session_random_usage(void) +test_AES_GMAC_authentication_test_case_2(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct rte_cryptodev_info dev_info; - struct rte_cryptodev_sym_session **sessions; - uint32_t i, j; - struct multi_session_params ut_paramz[] = { + return test_AES_GMAC_authentication(&gmac_test_case_2); +} - { - .cipher_key = ms_aes_cbc_key0, - .hmac_key = ms_hmac_key0, - .cipher = ms_aes_cbc_cipher0, - .digest = ms_hmac_digest0, - .iv = ms_aes_cbc_iv0 - }, - { - .cipher_key = ms_aes_cbc_key1, - .hmac_key = ms_hmac_key1, - .cipher = ms_aes_cbc_cipher1, - .digest = ms_hmac_digest1, - .iv = ms_aes_cbc_iv1 - }, - { - .cipher_key = ms_aes_cbc_key2, - .hmac_key = ms_hmac_key2, - .cipher = ms_aes_cbc_cipher2, - .digest = ms_hmac_digest2, - .iv = ms_aes_cbc_iv2 - }, +static int +test_AES_GMAC_authentication_test_case_3(void) +{ + return test_AES_GMAC_authentication(&gmac_test_case_3); +} - }; +static int +test_AES_GMAC_authentication_test_case_4(void) +{ + return test_AES_GMAC_authentication(&gmac_test_case_4); +} - rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); +static int +test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + int retval; + uint32_t plaintext_pad_len; + uint8_t *plaintext; - sessions = rte_malloc(NULL, - (sizeof(struct rte_cryptodev_sym_session *) - * MAX_NB_SESSIONS) + 1, 0); + TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, + "No GMAC length in the source data"); - for (i = 0; i < MB_SESSION_NUMBER; i++) { - sessions[i] = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + /* 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; - rte_memcpy(&ut_paramz[i].ut_params, &unittest_params, - sizeof(struct crypto_unittest_params)); + retval = create_gmac_session(ts_params->valid_devs[0], + tdata, RTE_CRYPTO_AUTH_OP_VERIFY); - test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( - &ut_paramz[i].ut_params, - ut_paramz[i].cipher_key, ut_paramz[i].hmac_key); + if (retval < 0) + return retval; - /* Create multiple crypto sessions*/ - rte_cryptodev_sym_session_init( - ts_params->valid_devs[0], - sessions[i], - &ut_paramz[i].ut_params.auth_xform, - ts_params->session_priv_mpool); + if (tdata->plaintext.len > MBUF_SIZE) + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); + else + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); - TEST_ASSERT_NOT_NULL(sessions[i], - "Session creation failed at session number %u", - i); + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); - } + plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); - srand(time(NULL)); - for (i = 0; i < 40000; i++) { + /* + * Runtime generate the large plain text instead of use hard code + * plain text vector. It is done to avoid create huge source file + * with the test vector. + */ + if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH) + generate_gmac_large_plaintext(tdata->plaintext.data); - j = rand() % MB_SESSION_NUMBER; - - TEST_ASSERT_SUCCESS( - test_AES_CBC_HMAC_SHA512_decrypt_perform( - sessions[j], - &ut_paramz[j].ut_params, - ts_params, ut_paramz[j].cipher, - ut_paramz[j].digest, - ut_paramz[j].iv), - "Failed to perform decrypt on request number %u.", i); - - if (ut_paramz[j].ut_params.op) - rte_crypto_op_free(ut_paramz[j].ut_params.op); - - /* - * free mbuf - both obuf and ibuf are usually the same, - * so check if they point at the same address is necessary, - * to avoid freeing the mbuf twice. - */ - if (ut_paramz[j].ut_params.obuf) { - rte_pktmbuf_free(ut_paramz[j].ut_params.obuf); - if (ut_paramz[j].ut_params.ibuf - == ut_paramz[j].ut_params.obuf) - ut_paramz[j].ut_params.ibuf = 0; - ut_paramz[j].ut_params.obuf = 0; - } - if (ut_paramz[j].ut_params.ibuf) { - rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf); - ut_paramz[j].ut_params.ibuf = 0; - } - } - - for (i = 0; i < MB_SESSION_NUMBER; i++) { - rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], - sessions[i]); - rte_cryptodev_sym_session_free(sessions[i]); - } - - rte_free(sessions); - - return TEST_SUCCESS; -} - -static int -test_null_cipher_only_operation(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - - /* Generate test mbuf data and space for digest */ - ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, - catch_22_quote, QUOTE_512_BYTES, 0); - - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = NULL; - - ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; - ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_pad_len); + TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); + debug_hexdump(stdout, "plaintext:", plaintext, + tdata->plaintext.len); - /* Create Crypto session*/ - rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - ut_params->sess, - &ut_params->cipher_xform, - ts_params->session_priv_mpool); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY, + tdata); - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate symmetric crypto operation struct"); + if (retval < 0) + return retval; - /* Set crypto operation data parameters */ rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - - /* set crypto operation source mbuf */ - sym_op->m_src = ut_params->ibuf; - - sym_op->cipher.data.offset = 0; - sym_op->cipher.data.length = QUOTE_512_BYTES; + ut_params->op->sym->m_src = ut_params->ibuf; - /* Process crypto operation */ - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_crypt_auth_op(ts_params->valid_devs[0], ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); + else + TEST_ASSERT_NOT_NULL( + process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto operation processing failed"); + "crypto op processing failed"); - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), - catch_22_quote, - QUOTE_512_BYTES, - "Ciphertext data not as expected"); + return 0; - return TEST_SUCCESS; } -uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab, - 0xab, 0xab, 0xab, 0xab, - 0xab, 0xab, 0xab, 0xab, - 0xab, 0xab, 0xab, 0xab}; + static int -test_null_auth_only_operation(void) +test_AES_GMAC_authentication_verify_test_case_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - uint8_t *digest; - - /* 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); - - /* create a pointer for digest, but don't expect anything to be written - * here in a NULL auth algo so no mbuf append done. - */ - digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, - QUOTE_512_BYTES); - /* prefill the memory pointed to by digest */ - memcpy(digest, orig_data, sizeof(orig_data)); - - /* Setup HMAC Parameters */ - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = NULL; - - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; - ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; - - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); - - /* Create Crypto session*/ - rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - ut_params->sess, &ut_params->auth_xform, - ts_params->session_priv_mpool); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); - - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate symmetric crypto operation struct"); - - /* Set crypto operation data parameters */ - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - - sym_op->m_src = ut_params->ibuf; - - sym_op->auth.data.offset = 0; - sym_op->auth.data.length = QUOTE_512_BYTES; - sym_op->auth.digest.data = digest; - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf, - QUOTE_512_BYTES); - - /* Process crypto operation */ - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); - - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto operation processing failed"); - /* Make sure memory pointed to by digest hasn't been overwritten */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - orig_data, - digest, - sizeof(orig_data), - "Memory at digest ptr overwritten unexpectedly"); + return test_AES_GMAC_authentication_verify(&gmac_test_case_1); +} - return TEST_SUCCESS; +static int +test_AES_GMAC_authentication_verify_test_case_2(void) +{ + return test_AES_GMAC_authentication_verify(&gmac_test_case_2); } +static int +test_AES_GMAC_authentication_verify_test_case_3(void) +{ + return test_AES_GMAC_authentication_verify(&gmac_test_case_3); +} static int -test_null_cipher_auth_operation(void) +test_AES_GMAC_authentication_verify_test_case_4(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - uint8_t *digest; + return test_AES_GMAC_authentication_verify(&gmac_test_case_4); +} - /* 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); +struct test_crypto_vector { + enum rte_crypto_cipher_algorithm crypto_algo; + unsigned int cipher_offset; + unsigned int cipher_len; - /* create a pointer for digest, but don't expect anything to be written - * here in a NULL auth algo so no mbuf append done. - */ - digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, - QUOTE_512_BYTES); - /* prefill the memory pointed to by digest */ - memcpy(digest, orig_data, sizeof(orig_data)); + struct { + uint8_t data[64]; + unsigned int len; + } cipher_key; - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = &ut_params->auth_xform; + struct { + uint8_t data[64]; + unsigned int len; + } iv; - ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; - ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + struct { + const uint8_t *data; + unsigned int len; + } plaintext; - /* Setup HMAC Parameters */ - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = NULL; + struct { + const uint8_t *data; + unsigned int len; + } ciphertext; - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; - ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + enum rte_crypto_auth_algorithm auth_algo; + unsigned int auth_offset; - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + struct { + uint8_t data[128]; + unsigned int len; + } auth_key; - /* Create Crypto session*/ - rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - ut_params->sess, &ut_params->cipher_xform, - ts_params->session_priv_mpool); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + struct { + const uint8_t *data; + unsigned int len; + } aad; - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate symmetric crypto operation struct"); - - /* Set crypto operation data parameters */ - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - - sym_op->m_src = ut_params->ibuf; + struct { + uint8_t data[128]; + unsigned int len; + } digest; +}; - sym_op->cipher.data.offset = 0; - sym_op->cipher.data.length = QUOTE_512_BYTES; +static const struct test_crypto_vector +hmac_sha1_test_crypto_vector = { + .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC, + .plaintext = { + .data = plaintext_hash, + .len = 512 + }, + .auth_key = { + .data = { + 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, + 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, + 0xDE, 0xF4, 0xDE, 0xAD + }, + .len = 20 + }, + .digest = { + .data = { + 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77, + 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17, + 0x3F, 0x91, 0x64, 0x59 + }, + .len = 20 + } +}; - sym_op->auth.data.offset = 0; - sym_op->auth.data.length = QUOTE_512_BYTES; - sym_op->auth.digest.data = digest; - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf, - QUOTE_512_BYTES); +static const struct test_crypto_vector +aes128_gmac_test_vector = { + .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC, + .plaintext = { + .data = plaintext_hash, + .len = 512 + }, + .iv = { + .data = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B + }, + .len = 12 + }, + .auth_key = { + .data = { + 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, + 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA + }, + .len = 16 + }, + .digest = { + .data = { + 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56, + 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A + }, + .len = 16 + } +}; - /* Process crypto operation */ - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); +static const struct test_crypto_vector +aes128cbc_hmac_sha1_test_vector = { + .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC, + .cipher_offset = 0, + .cipher_len = 512, + .cipher_key = { + .data = { + 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, + 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A + }, + .len = 16 + }, + .iv = { + .data = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F + }, + .len = 16 + }, + .plaintext = { + .data = plaintext_hash, + .len = 512 + }, + .ciphertext = { + .data = ciphertext512_aes128cbc, + .len = 512 + }, + .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC, + .auth_offset = 0, + .auth_key = { + .data = { + 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, + 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, + 0xDE, 0xF4, 0xDE, 0xAD + }, + .len = 20 + }, + .digest = { + .data = { + 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60, + 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, + 0x18, 0x8C, 0x1D, 0x32 + }, + .len = 20 + } +}; - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto operation processing failed"); +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 + } +}; - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), - catch_22_quote, - QUOTE_512_BYTES, - "Ciphertext data not as expected"); - /* Make sure memory pointed to by digest hasn't been overwritten */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - orig_data, - digest, - sizeof(orig_data), - "Memory at digest ptr overwritten unexpectedly"); +static void +data_corruption(uint8_t *data) +{ + data[0] += 1; +} - return TEST_SUCCESS; +static void +tag_corruption(uint8_t *data, unsigned int tag_offset) +{ + data[tag_offset] += 1; } static int -test_null_auth_cipher_operation(void) +create_auth_session(struct crypto_unittest_params *ut_params, + uint8_t dev_id, + const struct test_crypto_vector *reference, + enum rte_crypto_auth_operation auth_op) { struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - uint8_t *digest; - - /* Generate test mbuf data */ - ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, - catch_22_quote, QUOTE_512_BYTES, 0); - - /* create a pointer for digest, but don't expect anything to be written - * here in a NULL auth algo so no mbuf append done. - */ - digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, - QUOTE_512_BYTES); - /* prefill the memory pointed to by digest */ - memcpy(digest, orig_data, sizeof(orig_data)); - - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = NULL; + uint8_t auth_key[reference->auth_key.len + 1]; - ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; - ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); - /* Setup HMAC Parameters */ + /* Setup Authentication Parameters */ ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = &ut_params->cipher_xform; - - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; - ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + ut_params->auth_xform.auth.op = auth_op; + ut_params->auth_xform.next = NULL; + ut_params->auth_xform.auth.algo = reference->auth_algo; + ut_params->auth_xform.auth.key.length = reference->auth_key.len; + ut_params->auth_xform.auth.key.data = auth_key; + ut_params->auth_xform.auth.digest_length = reference->digest.len; + /* Create Crypto session*/ ut_params->sess = rte_cryptodev_sym_session_create( ts_params->session_mpool); - /* Create Crypto session*/ - rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - ut_params->sess, &ut_params->cipher_xform, - ts_params->session_priv_mpool); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); - - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate symmetric crypto operation struct"); - - /* Set crypto operation data parameters */ - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->auth_xform, + ts_params->session_priv_mpool); - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - - sym_op->m_src = ut_params->ibuf; - - sym_op->cipher.data.offset = 0; - sym_op->cipher.data.length = QUOTE_512_BYTES; - - sym_op->auth.data.offset = 0; - sym_op->auth.data.length = QUOTE_512_BYTES; - sym_op->auth.digest.data = digest; - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf, - QUOTE_512_BYTES); - - /* Process crypto operation */ - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); - TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); - - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto operation processing failed"); - - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), - catch_22_quote, - QUOTE_512_BYTES, - "Ciphertext data not as expected"); - /* Make sure memory pointed to by digest hasn't been overwritten */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - orig_data, - digest, - sizeof(orig_data), - "Memory at digest ptr overwritten unexpectedly"); - - return TEST_SUCCESS; -} + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + return 0; +} static int -test_null_invalid_operation(void) +create_auth_cipher_session(struct crypto_unittest_params *ut_params, + uint8_t dev_id, + const struct test_crypto_vector *reference, + enum rte_crypto_auth_operation auth_op, + enum rte_crypto_cipher_operation cipher_op) { struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - int ret; - - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = NULL; - - ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; - ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; - - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); - - /* Create Crypto session*/ - ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - ut_params->sess, &ut_params->cipher_xform, - ts_params->session_priv_mpool); - TEST_ASSERT(ret < 0, - "Session creation succeeded unexpectedly"); + uint8_t cipher_key[reference->cipher_key.len + 1]; + uint8_t auth_key[reference->auth_key.len + 1]; + memcpy(cipher_key, reference->cipher_key.data, + reference->cipher_key.len); + memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); - /* Setup HMAC Parameters */ + /* 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 = auth_op; + ut_params->auth_xform.auth.algo = reference->auth_algo; + ut_params->auth_xform.auth.key.length = reference->auth_key.len; + ut_params->auth_xform.auth.key.data = auth_key; + ut_params->auth_xform.auth.digest_length = reference->digest.len; - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; - ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) { + ut_params->auth_xform.auth.iv.offset = IV_OFFSET; + ut_params->auth_xform.auth.iv.length = reference->iv.len; + } else { + ut_params->auth_xform.next = &ut_params->cipher_xform; - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.next = NULL; + ut_params->cipher_xform.cipher.algo = reference->crypto_algo; + ut_params->cipher_xform.cipher.op = cipher_op; + ut_params->cipher_xform.cipher.key.data = cipher_key; + ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len; + ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; + ut_params->cipher_xform.cipher.iv.length = reference->iv.len; + } /* Create Crypto session*/ - ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - ut_params->sess, &ut_params->auth_xform, - ts_params->session_priv_mpool); - TEST_ASSERT(ret < 0, - "Session creation succeeded unexpectedly"); + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - return TEST_SUCCESS; -} + rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->auth_xform, + ts_params->session_priv_mpool); + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); -#define NULL_BURST_LENGTH (32) + return 0; +} static int -test_null_burst_operation(void) +create_auth_operation(struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference, + unsigned int auth_generate) { - 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"); - unsigned i, burst_len = NULL_BURST_LENGTH; + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL }; - struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL }; + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = &ut_params->auth_xform; + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; - ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + /* digest */ + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, reference->digest.len); - /* Setup HMAC Parameters */ - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = NULL; + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append auth tag"); - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; - ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( + ut_params->ibuf, reference->plaintext.len); - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + if (auth_generate) + memset(sym_op->auth.digest.data, 0, reference->digest.len); + else + memcpy(sym_op->auth.digest.data, + reference->digest.data, + reference->digest.len); - /* Create Crypto session*/ - rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - ut_params->sess, &ut_params->cipher_xform, - ts_params->session_priv_mpool); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + debug_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + reference->digest.len); - TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len), - burst_len, "failed to generate burst of crypto ops"); + sym_op->auth.data.length = reference->plaintext.len; + sym_op->auth.data.offset = 0; - /* Generate an operation for each mbuf in burst */ - for (i = 0; i < burst_len; i++) { - struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool); + return 0; +} - TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf"); +static int +create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference, + unsigned int auth_generate) +{ + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate pktmbuf offload"); - unsigned *data = (unsigned *)rte_pktmbuf_append(m, - sizeof(unsigned)); - *data = i; + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - rte_crypto_op_attach_sym_session(burst[i], ut_params->sess); + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - burst[i]->sym->m_src = m; - } + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; - /* Process crypto operation */ - TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0], - 0, burst, burst_len), - burst_len, - "Error enqueuing burst"); + /* digest */ + sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + ut_params->ibuf, reference->digest.len); - TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0], - 0, burst_dequeued, burst_len), - burst_len, - "Error dequeuing burst"); + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append auth tag"); + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( + ut_params->ibuf, reference->ciphertext.len); - for (i = 0; i < burst_len; i++) { - TEST_ASSERT_EQUAL( - *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *), - *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src, - uint32_t *), - "data not as expected"); + if (auth_generate) + memset(sym_op->auth.digest.data, 0, reference->digest.len); + else + memcpy(sym_op->auth.digest.data, + reference->digest.data, + reference->digest.len); - rte_pktmbuf_free(burst[i]->sym->m_src); - rte_crypto_op_free(burst[i]); - } + debug_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + reference->digest.len); - return TEST_SUCCESS; -} + rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), + reference->iv.data, reference->iv.len); -static void -generate_gmac_large_plaintext(uint8_t *data) -{ - uint16_t i; + sym_op->cipher.data.length = 0; + sym_op->cipher.data.offset = 0; - for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32) - memcpy(&data[i], &data[0], 32); + sym_op->auth.data.length = reference->plaintext.len; + sym_op->auth.data.offset = 0; + + return 0; } static int -create_gmac_operation(enum rte_crypto_auth_operation op, - const struct gmac_test_data *tdata) +create_cipher_auth_operation(struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference, + unsigned int auth_generate) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - struct rte_crypto_sym_op *sym_op; - - uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); - /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate symmetric crypto operation struct"); + "Failed to allocate pktmbuf offload"); - sym_op = ut_params->op->sym; + /* Set crypto operation data parameters */ + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + + /* set crypto operation source mbuf */ + sym_op->m_src = ut_params->ibuf; + /* digest */ sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( - ut_params->ibuf, tdata->gmac_tag.len); + ut_params->ibuf, reference->digest.len); + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, - "no room to append digest"); + "no room to append auth tag"); sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( - ut_params->ibuf, plaintext_pad_len); - - if (op == RTE_CRYPTO_AUTH_OP_VERIFY) { - rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data, - tdata->gmac_tag.len); - debug_hexdump(stdout, "digest:", - sym_op->auth.digest.data, - tdata->gmac_tag.len); - } + ut_params->ibuf, reference->ciphertext.len); - uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, - uint8_t *, IV_OFFSET); + if (auth_generate) + memset(sym_op->auth.digest.data, 0, reference->digest.len); + else + memcpy(sym_op->auth.digest.data, + reference->digest.data, + reference->digest.len); - rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); + debug_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + reference->digest.len); - debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len); + rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), + reference->iv.data, reference->iv.len); - sym_op->cipher.data.length = 0; - sym_op->cipher.data.offset = 0; + sym_op->cipher.data.length = reference->cipher_len; + sym_op->cipher.data.offset = reference->cipher_offset; - sym_op->auth.data.offset = 0; - sym_op->auth.data.length = tdata->plaintext.len; + sym_op->auth.data.length = reference->plaintext.len; + sym_op->auth.data.offset = reference->auth_offset; return 0; } -static int create_gmac_session(uint8_t dev_id, - const struct gmac_test_data *tdata, - enum rte_crypto_auth_operation auth_op) +static int +create_auth_verify_operation(struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference) { - uint8_t auth_key[tdata->key.len]; - - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - - memcpy(auth_key, tdata->key.data, tdata->key.len); - - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.next = NULL; - - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC; - ut_params->auth_xform.auth.op = auth_op; - ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len; - ut_params->auth_xform.auth.key.length = tdata->key.len; - ut_params->auth_xform.auth.key.data = auth_key; - ut_params->auth_xform.auth.iv.offset = IV_OFFSET; - ut_params->auth_xform.auth.iv.length = tdata->iv.len; - - - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); - - rte_cryptodev_sym_session_init(dev_id, ut_params->sess, - &ut_params->auth_xform, - ts_params->session_priv_mpool); - - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + return create_auth_operation(ts_params, ut_params, reference, 0); +} - return 0; +static int +create_auth_verify_GMAC_operation( + struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference) +{ + return create_auth_GMAC_operation(ts_params, ut_params, reference, 0); } static int -test_AES_GMAC_authentication(const struct gmac_test_data *tdata) +create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; + return create_cipher_auth_operation(ts_params, ut_params, reference, 0); +} +static int +test_authentication_verify_fail_when_data_corruption( + struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference, + unsigned int data_corrupted) +{ int retval; - uint8_t *auth_tag, *plaintext; - uint16_t plaintext_pad_len; - - TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, - "No GMAC length in the source data"); + uint8_t *plaintext; - retval = create_gmac_session(ts_params->valid_devs[0], - tdata, RTE_CRYPTO_AUTH_OP_GENERATE); + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = reference->auth_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + /* Create session */ + retval = create_auth_session(ut_params, + ts_params->valid_devs[0], + reference, + RTE_CRYPTO_AUTH_OP_VERIFY); if (retval < 0) return retval; - if (tdata->plaintext.len > MBUF_SIZE) - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); - else - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + 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_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); - /* - * Runtime generate the large plain text instead of use hard code - * plain text vector. It is done to avoid create huge source file - * with the test vector. - */ - if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH) - generate_gmac_large_plaintext(tdata->plaintext.data); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); + reference->plaintext.len); TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); + memcpy(plaintext, reference->plaintext.data, reference->plaintext.len); - memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); debug_hexdump(stdout, "plaintext:", plaintext, - tdata->plaintext.len); + reference->plaintext.len); - retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE, - tdata); + /* Create operation */ + retval = create_auth_verify_operation(ts_params, ut_params, reference); if (retval < 0) return retval; - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - - ut_params->op->sym->m_src = ut_params->ibuf; - - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); - - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing failed"); + if (data_corrupted) + data_corruption(plaintext); + else + tag_corruption(plaintext, reference->plaintext.len); - if (ut_params->op->sym->m_dst) { - auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, - uint8_t *, plaintext_pad_len); + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) { + process_cpu_crypt_auth_op(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, + "authentication not failed"); } else { - auth_tag = plaintext + plaintext_pad_len; + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); } - debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len); - - TEST_ASSERT_BUFFERS_ARE_EQUAL( - auth_tag, - tdata->gmac_tag.data, - tdata->gmac_tag.len, - "GMAC Generated auth tag not as expected"); - return 0; } static int -test_AES_GMAC_authentication_test_case_1(void) -{ - return test_AES_GMAC_authentication(&gmac_test_case_1); -} - -static int -test_AES_GMAC_authentication_test_case_2(void) -{ - return test_AES_GMAC_authentication(&gmac_test_case_2); -} - -static int -test_AES_GMAC_authentication_test_case_3(void) -{ - return test_AES_GMAC_authentication(&gmac_test_case_3); -} - -static int -test_AES_GMAC_authentication_test_case_4(void) -{ - return test_AES_GMAC_authentication(&gmac_test_case_4); -} - -static int -test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata) +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) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; int retval; - uint32_t plaintext_pad_len; uint8_t *plaintext; - TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, - "No GMAC length in the source data"); - - retval = create_gmac_session(ts_params->valid_devs[0], - tdata, RTE_CRYPTO_AUTH_OP_VERIFY); + /* 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; - if (tdata->plaintext.len > MBUF_SIZE) - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); - else - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + 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_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); - - /* - * Runtime generate the large plain text instead of use hard code - * plain text vector. It is done to avoid create huge source file - * with the test vector. - */ - if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH) - generate_gmac_large_plaintext(tdata->plaintext.data); - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - plaintext_pad_len); + reference->plaintext.len); TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); + memcpy(plaintext, reference->plaintext.data, reference->plaintext.len); - memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); debug_hexdump(stdout, "plaintext:", plaintext, - tdata->plaintext.len); + reference->plaintext.len); - retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY, - tdata); + /* Create operation */ + retval = create_auth_verify_GMAC_operation(ts_params, + ut_params, + reference); if (retval < 0) return retval; - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - - ut_params->op->sym->m_src = ut_params->ibuf; - - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); + if (data_corrupted) + data_corruption(plaintext); + else + tag_corruption(plaintext, reference->aad.len); - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing failed"); + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) { + process_cpu_crypt_auth_op(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, + "authentication not failed"); + } else { + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); + } return 0; - } static int -test_AES_GMAC_authentication_verify_test_case_1(void) +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) { - return test_AES_GMAC_authentication_verify(&gmac_test_case_1); -} + int retval; -static int -test_AES_GMAC_authentication_verify_test_case_2(void) -{ - return test_AES_GMAC_authentication_verify(&gmac_test_case_2); -} + uint8_t *ciphertext; -static int -test_AES_GMAC_authentication_verify_test_case_3(void) -{ - return test_AES_GMAC_authentication_verify(&gmac_test_case_3); + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = reference->auth_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + cap_idx.algo.cipher = reference->crypto_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + + /* Create session */ + retval = create_auth_cipher_session(ut_params, + ts_params->valid_devs[0], + reference, + RTE_CRYPTO_AUTH_OP_VERIFY, + RTE_CRYPTO_CIPHER_OP_DECRYPT); + if (retval < 0) + return retval; + + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); + + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + reference->ciphertext.len); + TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext"); + memcpy(ciphertext, reference->ciphertext.data, + reference->ciphertext.len); + + /* Create operation */ + retval = create_cipher_auth_verify_operation(ts_params, + ut_params, + reference); + + if (retval < 0) + return retval; + + if (data_corrupted) + data_corruption(ciphertext); + else + tag_corruption(ciphertext, reference->ciphertext.len); + + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) { + process_cpu_crypt_auth_op(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NOT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, + "authentication not failed"); + } else { + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); + } + + return 0; } static int -test_AES_GMAC_authentication_verify_test_case_4(void) +test_authenticated_encryt_with_esn( + struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference) { - return test_AES_GMAC_authentication_verify(&gmac_test_case_4); -} + int retval; -struct test_crypto_vector { - enum rte_crypto_cipher_algorithm crypto_algo; - unsigned int cipher_offset; - unsigned int cipher_len; + 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]; - struct { - uint8_t data[64]; - unsigned int len; - } cipher_key; + /* Verify the capabilities */ + struct rte_cryptodev_sym_capability_idx cap_idx; + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = reference->auth_algo; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; + 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; - struct { - uint8_t data[64]; - unsigned int len; - } iv; + /* Create session */ + memcpy(cipher_key, reference->cipher_key.data, + reference->cipher_key.len); + memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); - struct { - const uint8_t *data; - unsigned int len; - } plaintext; + /* 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; - struct { - const uint8_t *data; - unsigned int len; - } ciphertext; + ut_params->cipher_xform.next = &ut_params->auth_xform; - enum rte_crypto_auth_algorithm auth_algo; - unsigned int auth_offset; + /* 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; - struct { - uint8_t data[128]; - unsigned int len; - } auth_key; + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - struct { - const uint8_t *data; - unsigned int len; - } aad; + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + ut_params->sess, + &ut_params->cipher_xform, + ts_params->session_priv_mpool); - struct { - uint8_t data[128]; - unsigned int len; - } digest; -}; + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); -static const struct test_crypto_vector -hmac_sha1_test_crypto_vector = { - .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC, - .plaintext = { - .data = plaintext_hash, - .len = 512 - }, - .auth_key = { - .data = { - 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, - 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, - 0xDE, 0xF4, 0xDE, 0xAD - }, - .len = 20 - }, - .digest = { - .data = { - 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77, - 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17, - 0x3F, 0x91, 0x64, 0x59 - }, - .len = 20 - } -}; + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); -static const struct test_crypto_vector -aes128_gmac_test_vector = { - .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC, - .plaintext = { - .data = plaintext_hash, - .len = 512 - }, - .iv = { - .data = { - 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, - 0x08, 0x09, 0x0A, 0x0B - }, - .len = 12 - }, - .auth_key = { - .data = { - 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, - 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA - }, - .len = 16 - }, - .digest = { - .data = { - 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56, - 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A - }, - .len = 16 - } -}; + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); -static const struct test_crypto_vector -aes128cbc_hmac_sha1_test_vector = { - .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_offset = 0, - .cipher_len = 512, - .cipher_key = { - .data = { - 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, - 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A - }, - .len = 16 - }, - .iv = { - .data = { - 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, - 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F - }, - .len = 16 - }, - .plaintext = { - .data = plaintext_hash, - .len = 512 - }, - .ciphertext = { - .data = ciphertext512_aes128cbc, - .len = 512 - }, - .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC, - .auth_offset = 0, - .auth_key = { - .data = { - 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, - 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, - 0xDE, 0xF4, 0xDE, 0xAD - }, - .len = 20 - }, - .digest = { - .data = { - 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60, - 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, - 0x18, 0x8C, 0x1D, 0x32 - }, - .len = 20 - } -}; + 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); -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 - } -}; + /* Create operation */ + retval = create_cipher_auth_operation(ts_params, + ut_params, + reference, 0); -static void -data_corruption(uint8_t *data) -{ - data[0] += 1; -} + if (retval < 0) + return retval; -static void -tag_corruption(uint8_t *data, unsigned int tag_offset) -{ - data[tag_offset] += 1; -} + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_crypt_auth_op(ts_params->valid_devs[0], + ut_params->op); + else + ut_params->op = process_crypto_request( + ts_params->valid_devs[0], ut_params->op); -static int -create_auth_session(struct crypto_unittest_params *ut_params, - uint8_t dev_id, - const struct test_crypto_vector *reference, - enum rte_crypto_auth_operation auth_op) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - uint8_t auth_key[reference->auth_key.len + 1]; + TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); - memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); - /* Setup Authentication Parameters */ - ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - ut_params->auth_xform.auth.op = auth_op; - ut_params->auth_xform.next = NULL; - ut_params->auth_xform.auth.algo = reference->auth_algo; - ut_params->auth_xform.auth.key.length = reference->auth_key.len; - ut_params->auth_xform.auth.key.data = auth_key; - ut_params->auth_xform.auth.digest_length = reference->digest.len; + plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16); - /* Create Crypto session*/ - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + 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); - rte_cryptodev_sym_session_init(dev_id, ut_params->sess, - &ut_params->auth_xform, - ts_params->session_priv_mpool); + /* Validate obuf */ + TEST_ASSERT_BUFFERS_ARE_EQUAL( + authciphertext, + reference->ciphertext.data, + reference->ciphertext.len, + "Ciphertext data not as expected"); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + 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 -create_auth_cipher_session(struct crypto_unittest_params *ut_params, - uint8_t dev_id, - const struct test_crypto_vector *reference, - enum rte_crypto_auth_operation auth_op, - enum rte_crypto_cipher_operation cipher_op) +test_authenticated_decrypt_with_esn( + struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + 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 */ 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 = auth_op; + 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; - if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) { - ut_params->auth_xform.auth.iv.offset = IV_OFFSET; - ut_params->auth_xform.auth.iv.length = reference->iv.len; - } else { - ut_params->auth_xform.next = &ut_params->cipher_xform; - - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = NULL; - ut_params->cipher_xform.cipher.algo = reference->crypto_algo; - ut_params->cipher_xform.cipher.op = cipher_op; - ut_params->cipher_xform.cipher.key.data = cipher_key; - ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len; - ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; - ut_params->cipher_xform.cipher.iv.length = reference->iv.len; - } + /* 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(dev_id, ut_params->sess, + 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, + "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 (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + process_cpu_crypt_auth_op(ts_params->valid_devs[0], + ut_params->op); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + + TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); + TEST_ASSERT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing passed"); + + ut_params->obuf = ut_params->op->sym->m_src; + TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); + return 0; } static int -create_auth_operation(struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference, - unsigned int auth_generate) +create_aead_operation_SGL(enum rte_crypto_aead_operation op, + const struct aead_test_data *tdata, + void *digest_mem, uint64_t digest_phys) { + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + 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, 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); + "Failed to allocate symmetric crypto operation struct"); struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - /* set crypto operation source mbuf */ - sym_op->m_src = ut_params->ibuf; + sym_op->aead.digest.data = digest_mem; - /* digest */ - sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( - ut_params->ibuf, reference->digest.len); + TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, + "no room to append digest"); - TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, - "no room to append auth tag"); - - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( - ut_params->ibuf, reference->plaintext.len); - - if (auth_generate) - memset(sym_op->auth.digest.data, 0, reference->digest.len); - else - memcpy(sym_op->auth.digest.data, - reference->digest.data, - reference->digest.len); - - debug_hexdump(stdout, "digest:", - sym_op->auth.digest.data, - reference->digest.len); - - sym_op->auth.data.length = reference->plaintext.len; - sym_op->auth.data.offset = 0; + sym_op->aead.digest.phys_addr = digest_phys; - return 0; -} + if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) { + rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data, + auth_tag_len); + debug_hexdump(stdout, "digest:", + sym_op->aead.digest.data, + auth_tag_len); + } -static int -create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference, - unsigned int auth_generate) -{ - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate pktmbuf offload"); + /* Append aad data */ + if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) { + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); - /* Set crypto operation data parameters */ - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + /* Copy IV 1 byte after the IV pointer, according to the API */ + rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len); - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; + aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16); - /* set crypto operation source mbuf */ - sym_op->m_src = ut_params->ibuf; + sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend( + ut_params->ibuf, aad_len); + TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data, + "no room to prepend aad"); + sym_op->aead.aad.phys_addr = rte_pktmbuf_iova( + ut_params->ibuf); - /* digest */ - sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( - ut_params->ibuf, reference->digest.len); + memset(sym_op->aead.aad.data, 0, aad_len); + /* Copy AAD 18 bytes after the AAD pointer, according to the API */ + rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len); - TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, - "no room to append auth tag"); + debug_hexdump(stdout, "iv:", iv_ptr, iv_len); + debug_hexdump(stdout, "aad:", + sym_op->aead.aad.data, aad_len); + } else { + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( - ut_params->ibuf, reference->ciphertext.len); + rte_memcpy(iv_ptr, tdata->iv.data, iv_len); - if (auth_generate) - memset(sym_op->auth.digest.data, 0, reference->digest.len); - else - memcpy(sym_op->auth.digest.data, - reference->digest.data, - reference->digest.len); + aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16); - debug_hexdump(stdout, "digest:", - sym_op->auth.digest.data, - reference->digest.len); + sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend( + 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( + ut_params->ibuf); - rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), - reference->iv.data, reference->iv.len); + memset(sym_op->aead.aad.data, 0, aad_len); + rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len); - sym_op->cipher.data.length = 0; - sym_op->cipher.data.offset = 0; + debug_hexdump(stdout, "iv:", iv_ptr, iv_len); + debug_hexdump(stdout, "aad:", + sym_op->aead.aad.data, aad_len); + } - sym_op->auth.data.length = reference->plaintext.len; - sym_op->auth.data.offset = 0; + sym_op->aead.data.length = tdata->plaintext.len; + sym_op->aead.data.offset = aad_len_pad; return 0; } +#define SGL_MAX_NO 16 + static int -create_cipher_auth_operation(struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference, - unsigned int auth_generate) +test_authenticated_encryption_SGL(const struct aead_test_data *tdata, + const int oop, uint32_t fragsz, uint32_t fragsz_oop) { - /* Generate Crypto op data structure */ - ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate pktmbuf offload"); - - /* Set crypto operation data parameters */ - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - - /* set crypto operation source mbuf */ - sym_op->m_src = ut_params->ibuf; - - /* digest */ - sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( - ut_params->ibuf, reference->digest.len); - - TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, - "no room to append auth tag"); - - sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( - ut_params->ibuf, reference->ciphertext.len); - - if (auth_generate) - memset(sym_op->auth.digest.data, 0, reference->digest.len); - else - memcpy(sym_op->auth.digest.data, - reference->digest.data, - reference->digest.len); + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL; + int retval; + int to_trn = 0; + int to_trn_tbl[SGL_MAX_NO]; + int segs = 1; + unsigned int trn_data = 0; + uint8_t *plaintext, *ciphertext, *auth_tag; + struct rte_cryptodev_info dev_info; - debug_hexdump(stdout, "digest:", - sym_op->auth.digest.data, - reference->digest.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; - rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), - reference->iv.data, reference->iv.len); + /* OOP not supported with CPU crypto */ + if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return -ENOTSUP; - sym_op->cipher.data.length = reference->cipher_len; - sym_op->cipher.data.offset = reference->cipher_offset; + /* 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; + } + } - sym_op->auth.data.length = reference->plaintext.len; - sym_op->auth.data.offset = reference->auth_offset; + if (fragsz > tdata->plaintext.len) + fragsz = tdata->plaintext.len; - return 0; -} + uint16_t plaintext_len = fragsz; + uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz; -static int -create_auth_verify_operation(struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference) -{ - return create_auth_operation(ts_params, ut_params, reference, 0); -} + if (fragsz_oop > tdata->plaintext.len) + frag_size_oop = tdata->plaintext.len; -static int -create_auth_verify_GMAC_operation( - struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference) -{ - return create_auth_GMAC_operation(ts_params, ut_params, reference, 0); -} + int ecx = 0; + void *digest_mem = NULL; -static int -create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference) -{ - return create_cipher_auth_operation(ts_params, ut_params, reference, 0); -} + uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); -static int -test_authentication_verify_fail_when_data_corruption( - struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference, - unsigned int data_corrupted) -{ - int retval; + if (tdata->plaintext.len % fragsz != 0) { + if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO) + return 1; + } else { + if (tdata->plaintext.len / fragsz > SGL_MAX_NO) + return 1; + } - uint8_t *plaintext; + /* + * For out-op-place we need to alloc another mbuf + */ + if (oop) { + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + rte_pktmbuf_append(ut_params->obuf, + frag_size_oop + prepend_len); + buf_oop = ut_params->obuf; + } - /* Create session */ - retval = create_auth_session(ut_params, - ts_params->valid_devs[0], - reference, - RTE_CRYPTO_AUTH_OP_VERIFY); + /* Create AEAD session */ + retval = create_aead_session(ts_params->valid_devs[0], + tdata->algo, + RTE_CRYPTO_AEAD_OP_ENCRYPT, + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len, + tdata->iv.len); if (retval < 0) return retval; ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - 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); + plaintext_len); - debug_hexdump(stdout, "plaintext:", plaintext, - reference->plaintext.len); + memcpy(plaintext, tdata->plaintext.data, plaintext_len); - /* Create operation */ - retval = create_auth_verify_operation(ts_params, ut_params, reference); + trn_data += plaintext_len; - if (retval < 0) - return retval; + buf = ut_params->ibuf; - 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); + /* + * Loop until no more fragments + */ - TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); + while (trn_data < tdata->plaintext.len) { + ++segs; + to_trn = (tdata->plaintext.len - trn_data < fragsz) ? + (tdata->plaintext.len - trn_data) : fragsz; - return 0; -} + to_trn_tbl[ecx++] = to_trn; -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; + buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf = buf->next; - /* 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; + memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, + rte_pktmbuf_tailroom(buf)); - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - TEST_ASSERT_NOT_NULL(ut_params->ibuf, - "Failed to allocate input buffer in mempool"); + /* OOP */ + if (oop && !fragsz_oop) { + buf_last_oop = buf_oop->next = + rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf_oop = buf_oop->next; + memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), + 0, rte_pktmbuf_tailroom(buf_oop)); + rte_pktmbuf_append(buf_oop, to_trn); + } - /* 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(buf, + to_trn); - 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); + memcpy(plaintext, tdata->plaintext.data + trn_data, + to_trn); + trn_data += to_trn; + if (trn_data == tdata->plaintext.len) { + if (oop) { + if (!fragsz_oop) + digest_mem = rte_pktmbuf_append(buf_oop, + tdata->auth_tag.len); + } else + digest_mem = (uint8_t *)rte_pktmbuf_append(buf, + tdata->auth_tag.len); + } + } - debug_hexdump(stdout, "plaintext:", plaintext, - reference->plaintext.len); + uint64_t digest_phys = 0; - /* Create operation */ - retval = create_auth_verify_GMAC_operation(ts_params, - ut_params, - reference); + ut_params->ibuf->nb_segs = segs; - if (retval < 0) - return retval; + segs = 1; + if (fragsz_oop && oop) { + to_trn = 0; + ecx = 0; - if (data_corrupted) - data_corruption(plaintext); - else - tag_corruption(plaintext, reference->aad.len); + if (frag_size_oop == tdata->plaintext.len) { + digest_mem = rte_pktmbuf_append(ut_params->obuf, + tdata->auth_tag.len); - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + digest_phys = rte_pktmbuf_iova_offset( + ut_params->obuf, + tdata->plaintext.len + prepend_len); + } - TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); + trn_data = frag_size_oop; + while (trn_data < tdata->plaintext.len) { + ++segs; + to_trn = + (tdata->plaintext.len - trn_data < + frag_size_oop) ? + (tdata->plaintext.len - trn_data) : + frag_size_oop; - return 0; -} + to_trn_tbl[ecx++] = to_trn; -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; + buf_last_oop = buf_oop->next = + rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf_oop = buf_oop->next; + memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), + 0, rte_pktmbuf_tailroom(buf_oop)); + rte_pktmbuf_append(buf_oop, to_trn); - uint8_t *ciphertext; + trn_data += to_trn; - /* 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; + if (trn_data == tdata->plaintext.len) { + digest_mem = rte_pktmbuf_append(buf_oop, + tdata->auth_tag.len); + } + } - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - TEST_ASSERT_NOT_NULL(ut_params->ibuf, - "Failed to allocate input buffer in mempool"); + ut_params->obuf->nb_segs = segs; + } - /* clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + /* + * Place digest at the end of the last buffer + */ + if (!digest_phys) + digest_phys = rte_pktmbuf_iova(buf) + to_trn; + if (oop && buf_last_oop) + digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn; - 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); + if (!digest_mem && !oop) { + digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + + tdata->auth_tag.len); + digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf, + tdata->plaintext.len); + } - /* Create operation */ - retval = create_cipher_auth_verify_operation(ts_params, - ut_params, - reference); + /* Create AEAD operation */ + retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT, + tdata, digest_mem, digest_phys); 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); + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); + ut_params->op->sym->m_src = ut_params->ibuf; + if (oop) + ut_params->op->sym->m_dst = ut_params->obuf; - return 0; -} + /* Process crypto operation */ + 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"); -static int -test_authenticated_encryt_with_esn( - struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference) -{ - int retval; + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); - 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]; - /* Create session */ - memcpy(cipher_key, reference->cipher_key.data, - reference->cipher_key.len); - memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); + ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, + uint8_t *, prepend_len); + if (oop) { + ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, + uint8_t *, prepend_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; + if (fragsz_oop) + fragsz = fragsz_oop; - ut_params->cipher_xform.next = &ut_params->auth_xform; + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ciphertext, + tdata->ciphertext.data, + fragsz, + "Ciphertext data not as expected"); - /* 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; + buf = ut_params->op->sym->m_src->next; + if (oop) + buf = ut_params->op->sym->m_dst->next; - /* Create Crypto session*/ - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + unsigned int off = fragsz; - rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - ut_params->sess, - &ut_params->cipher_xform, - ts_params->session_priv_mpool); + ecx = 0; + while (buf) { + ciphertext = rte_pktmbuf_mtod(buf, + uint8_t *); - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + TEST_ASSERT_BUFFERS_ARE_EQUAL( + ciphertext, + tdata->ciphertext.data + off, + to_trn_tbl[ecx], + "Ciphertext data not as expected"); - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - TEST_ASSERT_NOT_NULL(ut_params->ibuf, - "Failed to allocate input buffer in mempool"); - - /* clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); - - plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - reference->plaintext.len); - TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); - memcpy(plaintext, reference->plaintext.data, reference->plaintext.len); - - /* Create operation */ - retval = create_cipher_auth_operation(ts_params, - ut_params, - reference, 0); + off += to_trn_tbl[ecx++]; + buf = buf->next; + } - if (retval < 0) - return retval; + auth_tag = digest_mem; + TEST_ASSERT_BUFFERS_ARE_EQUAL( + auth_tag, + tdata->auth_tag.data, + tdata->auth_tag.len, + "Generated auth tag not as expected"); - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + return 0; +} - TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); +static int +test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void) +{ + return test_authenticated_encryption_SGL( + &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400); +} - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing failed"); +static int +test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void) +{ + return test_authenticated_encryption_SGL( + &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000); +} - plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16); +static int +test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void) +{ + return test_authenticated_encryption_SGL( + &gcm_test_case_8, OUT_OF_PLACE, 400, + gcm_test_case_8.plaintext.len); +} - 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); +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; - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL( - authciphertext, - reference->ciphertext.data, - reference->ciphertext.len, - "Ciphertext data not as expected"); + return test_authenticated_encryption_SGL( + &gcm_test_case_SGL_1, IN_PLACE, 1500, 0); +} - TEST_ASSERT_BUFFERS_ARE_EQUAL( - auth_tag, - reference->digest.data, - reference->digest.len, - "Generated digest not as expected"); +static int +test_authentication_verify_fail_when_data_corrupted( + struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference) +{ + return test_authentication_verify_fail_when_data_corruption( + ts_params, ut_params, reference, 1); +} - return TEST_SUCCESS; +static int +test_authentication_verify_fail_when_tag_corrupted( + struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference) +{ + return test_authentication_verify_fail_when_data_corruption( + ts_params, ut_params, reference, 0); +} +static int +test_authentication_verify_GMAC_fail_when_data_corrupted( + struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference) +{ + return test_authentication_verify_GMAC_fail_when_corruption( + ts_params, ut_params, reference, 1); } static int -test_authenticated_decrypt_with_esn( +test_authentication_verify_GMAC_fail_when_tag_corrupted( struct crypto_testsuite_params *ts_params, struct crypto_unittest_params *ut_params, const struct test_crypto_vector *reference) { - int retval; + return test_authentication_verify_GMAC_fail_when_corruption( + ts_params, ut_params, reference, 0); +} - uint8_t *ciphertext; - uint8_t cipher_key[reference->cipher_key.len + 1]; - uint8_t auth_key[reference->auth_key.len + 1]; +static int +test_authenticated_decryption_fail_when_data_corrupted( + struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference) +{ + return test_authenticated_decryption_fail_when_corruption( + ts_params, ut_params, reference, 1); +} - /* Create session */ - memcpy(cipher_key, reference->cipher_key.data, - reference->cipher_key.len); - memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); +static int +test_authenticated_decryption_fail_when_tag_corrupted( + struct crypto_testsuite_params *ts_params, + struct crypto_unittest_params *ut_params, + const struct test_crypto_vector *reference) +{ + return test_authenticated_decryption_fail_when_corruption( + ts_params, ut_params, reference, 0); +} - /* 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; +static int +authentication_verify_HMAC_SHA1_fail_data_corrupt(void) +{ + return test_authentication_verify_fail_when_data_corrupted( + &testsuite_params, &unittest_params, + &hmac_sha1_test_crypto_vector); +} - /* 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; +static int +authentication_verify_HMAC_SHA1_fail_tag_corrupt(void) +{ + return test_authentication_verify_fail_when_tag_corrupted( + &testsuite_params, &unittest_params, + &hmac_sha1_test_crypto_vector); +} - /* Create Crypto session*/ - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); +static int +authentication_verify_AES128_GMAC_fail_data_corrupt(void) +{ + return test_authentication_verify_GMAC_fail_when_data_corrupted( + &testsuite_params, &unittest_params, + &aes128_gmac_test_vector); +} - rte_cryptodev_sym_session_init(ts_params->valid_devs[0], - ut_params->sess, - &ut_params->auth_xform, - ts_params->session_priv_mpool); +static int +authentication_verify_AES128_GMAC_fail_tag_corrupt(void) +{ + return test_authentication_verify_GMAC_fail_when_tag_corrupted( + &testsuite_params, &unittest_params, + &aes128_gmac_test_vector); +} - TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); +static int +auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void) +{ + return test_authenticated_decryption_fail_when_data_corrupted( + &testsuite_params, + &unittest_params, + &aes128cbc_hmac_sha1_test_vector); +} - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - TEST_ASSERT_NOT_NULL(ut_params->ibuf, - "Failed to allocate input buffer in mempool"); +static int +auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void) +{ + return test_authenticated_decryption_fail_when_tag_corrupted( + &testsuite_params, + &unittest_params, + &aes128cbc_hmac_sha1_test_vector); +} - /* clear mbuf payload */ - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); +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); +} - 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); +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); +} - /* Create operation */ - retval = create_cipher_auth_verify_operation(ts_params, - ut_params, - reference); +#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER - if (retval < 0) - return retval; +/* global AESNI slave IDs for the scheduler test */ +uint8_t aesni_ids[2]; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); +static int +test_scheduler_attach_slave_op(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + uint8_t sched_id = ts_params->valid_devs[0]; + uint32_t nb_devs, i, nb_devs_attached = 0; + int ret; + char vdev_name[32]; - TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - TEST_ASSERT_EQUAL(ut_params->op->status, - RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing passed"); - - ut_params->obuf = ut_params->op->sym->m_src; - TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); - - return 0; -} - -static int -create_aead_operation_SGL(enum rte_crypto_aead_operation op, - const struct aead_test_data *tdata, - void *digest_mem, uint64_t digest_phys) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - - 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, - RTE_CRYPTO_OP_TYPE_SYMMETRIC); - TEST_ASSERT_NOT_NULL(ut_params->op, - "Failed to allocate symmetric crypto operation struct"); - - struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - - sym_op->aead.digest.data = digest_mem; - - TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, - "no room to append digest"); - - sym_op->aead.digest.phys_addr = digest_phys; + /* create 2 AESNI_MB if necessary */ + nb_devs = rte_cryptodev_device_count_by_driver( + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))); + if (nb_devs < 2) { + for (i = nb_devs; i < 2; i++) { + snprintf(vdev_name, sizeof(vdev_name), "%s_%u", + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), + i); + ret = rte_vdev_init(vdev_name, NULL); - if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) { - rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data, - auth_tag_len); - debug_hexdump(stdout, "digest:", - sym_op->aead.digest.data, - auth_tag_len); + TEST_ASSERT(ret == 0, + "Failed to create instance %u of" + " pmd : %s", + i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); + } } - /* Append aad data */ - if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) { - uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, - uint8_t *, IV_OFFSET); + /* attach 2 AESNI_MB cdevs */ + for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2; + i++) { + struct rte_cryptodev_info info; + unsigned int session_size; - /* Copy IV 1 byte after the IV pointer, according to the API */ - rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len); + rte_cryptodev_info_get(i, &info); + if (info.driver_id != rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) + continue; - aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16); + session_size = rte_cryptodev_sym_get_private_session_size(i); + /* + * Create the session mempool again, since now there are new devices + * to use the mempool. + */ + if (ts_params->session_mpool) { + rte_mempool_free(ts_params->session_mpool); + ts_params->session_mpool = NULL; + } + if (ts_params->session_priv_mpool) { + rte_mempool_free(ts_params->session_priv_mpool); + ts_params->session_priv_mpool = NULL; + } - sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, aad_len); - TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data, - "no room to prepend aad"); - sym_op->aead.aad.phys_addr = rte_pktmbuf_iova( - ut_params->ibuf); + if (info.sym.max_nb_sessions != 0 && + info.sym.max_nb_sessions < MAX_NB_SESSIONS) { + RTE_LOG(ERR, USER1, + "Device does not support " + "at least %u sessions\n", + MAX_NB_SESSIONS); + return TEST_FAILED; + } + /* + * Create mempool with maximum number of sessions, + * to include the session headers + */ + if (ts_params->session_mpool == NULL) { + ts_params->session_mpool = + rte_cryptodev_sym_session_pool_create( + "test_sess_mp", + MAX_NB_SESSIONS, 0, 0, 0, + SOCKET_ID_ANY); + TEST_ASSERT_NOT_NULL(ts_params->session_mpool, + "session mempool allocation failed"); + } - memset(sym_op->aead.aad.data, 0, aad_len); - /* Copy AAD 18 bytes after the AAD pointer, according to the API */ - rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len); + /* + * Create mempool with maximum number of sessions, + * to include device specific session private data + */ + if (ts_params->session_priv_mpool == NULL) { + ts_params->session_priv_mpool = rte_mempool_create( + "test_sess_mp_priv", + MAX_NB_SESSIONS, + session_size, + 0, 0, NULL, NULL, NULL, + NULL, SOCKET_ID_ANY, + 0); - debug_hexdump(stdout, "iv:", iv_ptr, iv_len); - debug_hexdump(stdout, "aad:", - sym_op->aead.aad.data, aad_len); - } else { - uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, - uint8_t *, IV_OFFSET); + TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool, + "session mempool allocation failed"); + } - rte_memcpy(iv_ptr, tdata->iv.data, iv_len); + ts_params->qp_conf.mp_session = ts_params->session_mpool; + ts_params->qp_conf.mp_session_private = + ts_params->session_priv_mpool; - aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16); + ret = rte_cryptodev_scheduler_slave_attach(sched_id, + (uint8_t)i); - sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend( - 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( - ut_params->ibuf); + TEST_ASSERT(ret == 0, + "Failed to attach device %u of pmd : %s", i, + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); - memset(sym_op->aead.aad.data, 0, aad_len); - rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len); + aesni_ids[nb_devs_attached] = (uint8_t)i; - debug_hexdump(stdout, "iv:", iv_ptr, iv_len); - debug_hexdump(stdout, "aad:", - sym_op->aead.aad.data, aad_len); + nb_devs_attached++; } - sym_op->aead.data.length = tdata->plaintext.len; - sym_op->aead.data.offset = aad_len_pad; - return 0; } -#define SGL_MAX_NO 16 - static int -test_authenticated_encryption_SGL(const struct aead_test_data *tdata, - const int oop, uint32_t fragsz, uint32_t fragsz_oop) +test_scheduler_detach_slave_op(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; - struct crypto_unittest_params *ut_params = &unittest_params; - struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL; - int retval; - int to_trn = 0; - int to_trn_tbl[SGL_MAX_NO]; - int segs = 1; - unsigned int trn_data = 0; - uint8_t *plaintext, *ciphertext, *auth_tag; - - if (fragsz > tdata->plaintext.len) - fragsz = tdata->plaintext.len; - - uint16_t plaintext_len = fragsz; - uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz; - - if (fragsz_oop > tdata->plaintext.len) - frag_size_oop = tdata->plaintext.len; - - int ecx = 0; - void *digest_mem = NULL; - - 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) - return 1; - } else { - if (tdata->plaintext.len / fragsz > SGL_MAX_NO) - return 1; - } + uint8_t sched_id = ts_params->valid_devs[0]; + uint32_t i; + int ret; - /* - * For out-op-place we need to alloc another mbuf - */ - if (oop) { - ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - rte_pktmbuf_append(ut_params->obuf, - frag_size_oop + prepend_len); - buf_oop = ut_params->obuf; + for (i = 0; i < 2; i++) { + ret = rte_cryptodev_scheduler_slave_detach(sched_id, + aesni_ids[i]); + TEST_ASSERT(ret == 0, + "Failed to detach device %u", aesni_ids[i]); } - /* Create AEAD session */ - retval = create_aead_session(ts_params->valid_devs[0], - tdata->algo, - RTE_CRYPTO_AEAD_OP_ENCRYPT, - tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->auth_tag.len, - tdata->iv.len); - if (retval < 0) - return retval; - - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); - - /* 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, - plaintext_len); - - memcpy(plaintext, tdata->plaintext.data, plaintext_len); - - trn_data += plaintext_len; - - buf = ut_params->ibuf; - - /* - * Loop until no more fragments - */ + return 0; +} - while (trn_data < tdata->plaintext.len) { - ++segs; - to_trn = (tdata->plaintext.len - trn_data < fragsz) ? - (tdata->plaintext.len - trn_data) : fragsz; - - to_trn_tbl[ecx++] = to_trn; - - buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); - buf = buf->next; - - memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, - rte_pktmbuf_tailroom(buf)); - - /* OOP */ - if (oop && !fragsz_oop) { - buf_last_oop = buf_oop->next = - rte_pktmbuf_alloc(ts_params->mbuf_pool); - buf_oop = buf_oop->next; - memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), - 0, rte_pktmbuf_tailroom(buf_oop)); - rte_pktmbuf_append(buf_oop, to_trn); - } - - plaintext = (uint8_t *)rte_pktmbuf_append(buf, - to_trn); - - memcpy(plaintext, tdata->plaintext.data + trn_data, - to_trn); - trn_data += to_trn; - if (trn_data == tdata->plaintext.len) { - if (oop) { - if (!fragsz_oop) - digest_mem = rte_pktmbuf_append(buf_oop, - tdata->auth_tag.len); - } else - digest_mem = (uint8_t *)rte_pktmbuf_append(buf, - tdata->auth_tag.len); - } - } - - uint64_t digest_phys = 0; - - ut_params->ibuf->nb_segs = segs; - - segs = 1; - if (fragsz_oop && oop) { - to_trn = 0; - ecx = 0; - - if (frag_size_oop == tdata->plaintext.len) { - digest_mem = rte_pktmbuf_append(ut_params->obuf, - tdata->auth_tag.len); - - digest_phys = rte_pktmbuf_iova_offset( - ut_params->obuf, - tdata->plaintext.len + prepend_len); - } - - trn_data = frag_size_oop; - while (trn_data < tdata->plaintext.len) { - ++segs; - to_trn = - (tdata->plaintext.len - trn_data < - frag_size_oop) ? - (tdata->plaintext.len - trn_data) : - frag_size_oop; - - to_trn_tbl[ecx++] = to_trn; - - buf_last_oop = buf_oop->next = - rte_pktmbuf_alloc(ts_params->mbuf_pool); - buf_oop = buf_oop->next; - memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), - 0, rte_pktmbuf_tailroom(buf_oop)); - rte_pktmbuf_append(buf_oop, to_trn); - - trn_data += to_trn; - - if (trn_data == tdata->plaintext.len) { - digest_mem = rte_pktmbuf_append(buf_oop, - tdata->auth_tag.len); - } - } - - ut_params->obuf->nb_segs = segs; - } - - /* - * Place digest at the end of the last buffer - */ - if (!digest_phys) - digest_phys = rte_pktmbuf_iova(buf) + to_trn; - if (oop && buf_last_oop) - digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn; - - if (!digest_mem && !oop) { - digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - + tdata->auth_tag.len); - digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf, - tdata->plaintext.len); - } - - /* Create AEAD operation */ - retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT, - tdata, digest_mem, digest_phys); - - if (retval < 0) - return retval; - - rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); - - ut_params->op->sym->m_src = ut_params->ibuf; - if (oop) - ut_params->op->sym->m_dst = ut_params->obuf; - - /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); - - TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "crypto op processing failed"); - - - ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, - uint8_t *, prepend_len); - if (oop) { - ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, - uint8_t *, prepend_len); - } - - if (fragsz_oop) - fragsz = fragsz_oop; - - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ciphertext, - tdata->ciphertext.data, - fragsz, - "Ciphertext data not as expected"); - - buf = ut_params->op->sym->m_src->next; - if (oop) - buf = ut_params->op->sym->m_dst->next; - - unsigned int off = fragsz; - - ecx = 0; - while (buf) { - ciphertext = rte_pktmbuf_mtod(buf, - uint8_t *); - - TEST_ASSERT_BUFFERS_ARE_EQUAL( - ciphertext, - tdata->ciphertext.data + off, - to_trn_tbl[ecx], - "Ciphertext data not as expected"); - - off += to_trn_tbl[ecx++]; - buf = buf->next; - } - - auth_tag = digest_mem; - TEST_ASSERT_BUFFERS_ARE_EQUAL( - auth_tag, - tdata->auth_tag.data, - tdata->auth_tag.len, - "Generated auth tag not as expected"); - - return 0; -} - -static int -test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void) -{ - return test_authenticated_encryption_SGL( - &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400); -} - -static int -test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void) -{ - return test_authenticated_encryption_SGL( - &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000); -} - -static int -test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void) -{ - return test_authenticated_encryption_SGL( - &gcm_test_case_8, OUT_OF_PLACE, 400, - gcm_test_case_8.plaintext.len); -} - -static int -test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void) -{ - - return test_authenticated_encryption_SGL( - &gcm_test_case_SGL_1, IN_PLACE, 1500, 0); -} - -static int -test_authentication_verify_fail_when_data_corrupted( - struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference) -{ - return test_authentication_verify_fail_when_data_corruption( - ts_params, ut_params, reference, 1); -} - -static int -test_authentication_verify_fail_when_tag_corrupted( - struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference) -{ - return test_authentication_verify_fail_when_data_corruption( - ts_params, ut_params, reference, 0); -} - -static int -test_authentication_verify_GMAC_fail_when_data_corrupted( - struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference) -{ - return test_authentication_verify_GMAC_fail_when_corruption( - ts_params, ut_params, reference, 1); -} - -static int -test_authentication_verify_GMAC_fail_when_tag_corrupted( - struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference) -{ - return test_authentication_verify_GMAC_fail_when_corruption( - ts_params, ut_params, reference, 0); -} - -static int -test_authenticated_decryption_fail_when_data_corrupted( - struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference) -{ - return test_authenticated_decryption_fail_when_corruption( - ts_params, ut_params, reference, 1); -} - -static int -test_authenticated_decryption_fail_when_tag_corrupted( - struct crypto_testsuite_params *ts_params, - struct crypto_unittest_params *ut_params, - const struct test_crypto_vector *reference) -{ - return test_authenticated_decryption_fail_when_corruption( - ts_params, ut_params, reference, 0); -} +static int +test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + uint8_t sched_id = ts_params->valid_devs[0]; + /* set mode */ + return rte_cryptodev_scheduler_mode_set(sched_id, + scheduler_mode); +} static int -authentication_verify_HMAC_SHA1_fail_data_corrupt(void) -{ - return test_authentication_verify_fail_when_data_corrupted( - &testsuite_params, &unittest_params, - &hmac_sha1_test_crypto_vector); -} - -static int -authentication_verify_HMAC_SHA1_fail_tag_corrupt(void) -{ - return test_authentication_verify_fail_when_tag_corrupted( - &testsuite_params, &unittest_params, - &hmac_sha1_test_crypto_vector); -} - -static int -authentication_verify_AES128_GMAC_fail_data_corrupt(void) -{ - return test_authentication_verify_GMAC_fail_when_data_corrupted( - &testsuite_params, &unittest_params, - &aes128_gmac_test_vector); -} - -static int -authentication_verify_AES128_GMAC_fail_tag_corrupt(void) -{ - return test_authentication_verify_GMAC_fail_when_tag_corrupted( - &testsuite_params, &unittest_params, - &aes128_gmac_test_vector); -} - -static int -auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void) -{ - return test_authenticated_decryption_fail_when_data_corrupted( - &testsuite_params, - &unittest_params, - &aes128cbc_hmac_sha1_test_vector); -} - -static int -auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void) -{ - return test_authenticated_decryption_fail_when_tag_corrupted( - &testsuite_params, - &unittest_params, - &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 */ -uint8_t aesni_ids[2]; - -static int -test_scheduler_attach_slave_op(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - uint8_t sched_id = ts_params->valid_devs[0]; - uint32_t nb_devs, i, nb_devs_attached = 0; - int ret; - char vdev_name[32]; - - /* create 2 AESNI_MB if necessary */ - nb_devs = rte_cryptodev_device_count_by_driver( - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))); - if (nb_devs < 2) { - for (i = nb_devs; i < 2; i++) { - snprintf(vdev_name, sizeof(vdev_name), "%s_%u", - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), - i); - ret = rte_vdev_init(vdev_name, NULL); - - TEST_ASSERT(ret == 0, - "Failed to create instance %u of" - " pmd : %s", - i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); - } - } - - /* attach 2 AESNI_MB cdevs */ - for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2; - i++) { - struct rte_cryptodev_info info; - unsigned int session_size; - - rte_cryptodev_info_get(i, &info); - if (info.driver_id != rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) - continue; - - session_size = rte_cryptodev_sym_get_private_session_size(i); - /* - * Create the session mempool again, since now there are new devices - * to use the mempool. - */ - if (ts_params->session_mpool) { - rte_mempool_free(ts_params->session_mpool); - ts_params->session_mpool = NULL; - } - if (ts_params->session_priv_mpool) { - rte_mempool_free(ts_params->session_priv_mpool); - ts_params->session_priv_mpool = NULL; - } - - if (info.sym.max_nb_sessions != 0 && - info.sym.max_nb_sessions < MAX_NB_SESSIONS) { - RTE_LOG(ERR, USER1, - "Device does not support " - "at least %u sessions\n", - MAX_NB_SESSIONS); - return TEST_FAILED; - } - /* - * Create mempool with maximum number of sessions, - * to include the session headers - */ - if (ts_params->session_mpool == NULL) { - ts_params->session_mpool = - rte_cryptodev_sym_session_pool_create( - "test_sess_mp", - MAX_NB_SESSIONS, 0, 0, 0, - SOCKET_ID_ANY); - TEST_ASSERT_NOT_NULL(ts_params->session_mpool, - "session mempool allocation failed"); - } - - /* - * Create mempool with maximum number of sessions, - * to include device specific session private data - */ - if (ts_params->session_priv_mpool == NULL) { - ts_params->session_priv_mpool = rte_mempool_create( - "test_sess_mp_priv", - MAX_NB_SESSIONS, - session_size, - 0, 0, NULL, NULL, NULL, - NULL, SOCKET_ID_ANY, - 0); - - TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool, - "session mempool allocation failed"); - } - - ts_params->qp_conf.mp_session = ts_params->session_mpool; - ts_params->qp_conf.mp_session_private = - ts_params->session_priv_mpool; - - ret = rte_cryptodev_scheduler_slave_attach(sched_id, - (uint8_t)i); - - TEST_ASSERT(ret == 0, - "Failed to attach device %u of pmd : %s", i, - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); - - aesni_ids[nb_devs_attached] = (uint8_t)i; - - nb_devs_attached++; - } - - return 0; -} - -static int -test_scheduler_detach_slave_op(void) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - uint8_t sched_id = ts_params->valid_devs[0]; - uint32_t i; - int ret; - - for (i = 0; i < 2; i++) { - ret = rte_cryptodev_scheduler_slave_detach(sched_id, - aesni_ids[i]); - TEST_ASSERT(ret == 0, - "Failed to detach device %u", aesni_ids[i]); - } - - return 0; -} - -static int -test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - uint8_t sched_id = ts_params->valid_devs[0]; - /* set mode */ - return rte_cryptodev_scheduler_mode_set(sched_id, - scheduler_mode); -} - -static int -test_scheduler_mode_roundrobin_op(void) -{ - TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) == - 0, "Failed to set roundrobin mode"); - return 0; - -} - -static int -test_scheduler_mode_multicore_op(void) -{ - TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) == - 0, "Failed to set multicore mode"); - - return 0; -} - -static int -test_scheduler_mode_failover_op(void) -{ - TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) == - 0, "Failed to set failover mode"); - - return 0; -} - -static int -test_scheduler_mode_pkt_size_distr_op(void) -{ - TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) == - 0, "Failed to set pktsize mode"); - - return 0; -} - -static struct unit_test_suite cryptodev_scheduler_testsuite = { - .suite_name = "Crypto Device Scheduler Unit Test Suite", - .setup = testsuite_setup, - .teardown = testsuite_teardown, - .unit_test_cases = { - /* 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(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(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(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(NULL, NULL, test_scheduler_detach_slave_op), - - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; - -#endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */ - -static struct unit_test_suite cryptodev_qat_testsuite = { - .suite_name = "Crypto QAT Unit Test Suite", - .setup = testsuite_setup, - .teardown = testsuite_teardown, - .unit_test_cases = { - TEST_CASE_ST(ut_setup, ut_teardown, - test_device_configure_invalid_dev_id), - TEST_CASE_ST(ut_setup, ut_teardown, - test_device_configure_invalid_queue_pair_ids), - TEST_CASE_ST(ut_setup, ut_teardown, - test_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_CASE_ST(ut_setup, ut_teardown, - test_AES_docsis_qat_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_docsis_qat_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_qat_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_stats), - - /** AES CCM Authenticated Encryption 128 bits key */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_3), - - /** AES CCM Authenticated Decryption 128 bits key*/ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_3), - - /** AES GCM Authenticated Encryption */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_in_place_1500B), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_5), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_6), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_7), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_test_case_8), - - /** AES GCM Authenticated Decryption */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_5), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_6), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_7), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_test_case_8), - - /** AES GCM Authenticated Encryption 192 bits key */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_5), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_6), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_192_7), - - /** AES GCM Authenticated Decryption 192 bits key */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_5), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_6), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_192_7), - - /** AES GCM Authenticated Encryption 256 bits key */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_5), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_6), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_7), - - /** AES GCM Authenticated Decryption 256 bits key */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_5), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_6), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_7), - - /** AES GMAC Authentication */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_3), - - /** SNOW 3G encrypt only (UEA2) */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_5), - - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_1_oop), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_1_oop), - - /** SNOW 3G generate auth, then encrypt (UEA2) */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_test_case_2_oop), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_part_digest_enc), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_part_digest_enc_oop), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_test_case_3_sgl), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_test_case_3_oop_sgl), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_part_digest_enc_sgl), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_part_digest_enc_oop_sgl), - - /** SNOW 3G decrypt (UEA2), then verify auth */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_test_case_2_oop), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_part_digest_enc), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_part_digest_enc_oop), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_test_case_3_sgl), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_test_case_3_oop_sgl), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_part_digest_enc_sgl), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl), - - /** SNOW 3G decrypt only (UEA2) */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_5), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_with_digest_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_generate_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_generate_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_generate_test_case_3), - 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), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_cipher_auth_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_with_digest_test_case_1), - - /** ZUC encrypt only (EEA3) */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_encryption_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_encryption_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_encryption_test_case_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_encryption_test_case_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_encryption_test_case_5), - - /** 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, - 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_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), - - /** Mixed CIPHER + HASH algorithms */ - /** AUTH AES CMAC + CIPHER AES CTR */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_aes_cmac_aes_ctr_digest_enc_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop), - TEST_CASE_ST(ut_setup, ut_teardown, - test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl), - TEST_CASE_ST(ut_setup, ut_teardown, - test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop), - TEST_CASE_ST(ut_setup, ut_teardown, - 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), - - /** AUTH ZUC + CIPHER SNOW3G */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_zuc_cipher_snow_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_zuc_cipher_snow_test_case_1), - /** AUTH AES CMAC + CIPHER SNOW3G */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_aes_cmac_cipher_snow_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_aes_cmac_cipher_snow_test_case_1), - /** AUTH ZUC + CIPHER AES CTR */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_zuc_cipher_aes_ctr_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_zuc_cipher_aes_ctr_test_case_1), - /** AUTH SNOW3G + CIPHER AES CTR */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_snow_cipher_aes_ctr_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_snow_cipher_aes_ctr_test_case_1), - /** AUTH SNOW3G + CIPHER ZUC */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_snow_cipher_zuc_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_snow_cipher_zuc_test_case_1), - /** AUTH AES CMAC + CIPHER ZUC */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_aes_cmac_cipher_zuc_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_aes_cmac_cipher_zuc_test_case_1), - - /** AUTH NULL + CIPHER SNOW3G */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_null_cipher_snow_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_null_cipher_snow_test_case_1), - /** AUTH NULL + CIPHER ZUC */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_null_cipher_zuc_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_null_cipher_zuc_test_case_1), - /** AUTH SNOW3G + CIPHER NULL */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_snow_cipher_null_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_snow_cipher_null_test_case_1), - /** AUTH ZUC + CIPHER NULL */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_zuc_cipher_null_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_zuc_cipher_null_test_case_1), - /** AUTH NULL + CIPHER AES CTR */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_null_cipher_aes_ctr_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_null_cipher_aes_ctr_test_case_1), - /** AUTH AES CMAC + CIPHER NULL */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_auth_aes_cmac_cipher_null_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_verify_auth_aes_cmac_cipher_null_test_case_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_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_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), +test_scheduler_mode_roundrobin_op(void) +{ + TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) == + 0, "Failed to set roundrobin mode"); + return 0; - /** 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), +static int +test_scheduler_mode_multicore_op(void) +{ + TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) == + 0, "Failed to set multicore mode"); - /** 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), + return 0; +} - /** 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), +static int +test_scheduler_mode_failover_op(void) +{ + TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) == + 0, "Failed to set failover mode"); - /** AES GMAC Authentication */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_3), -#endif /* IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0) */ + return 0; +} - 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_CASE_ST(ut_setup, ut_teardown, - test_DES_docsis_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_3), +static int +test_scheduler_mode_pkt_size_distr_op(void) +{ + TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) == + 0, "Failed to set pktsize mode"); - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; + return 0; +} -static struct unit_test_suite cryptodev_openssl_testsuite = { - .suite_name = "Crypto Device OPENSSL Unit Test Suite", +static struct unit_test_suite cryptodev_scheduler_testsuite = { + .suite_name = "Crypto Device Scheduler Unit Test Suite", .setup = testsuite_setup, .teardown = testsuite_teardown, .unit_test_cases = { - TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session), - TEST_CASE_ST(ut_setup, ut_teardown, - test_multi_session_random_usage), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_cipheronly_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_docsis_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_openssl_all), + /* 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_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), - /** AES GCM Authenticated Encryption */ - 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), + /* 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_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), - /** 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), + /* 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_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_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), - /** 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), + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; - /** 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), +#endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */ - /** 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), +static struct unit_test_suite cryptodev_testsuite = { + .suite_name = "Crypto Unit Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_5), + test_device_configure_invalid_dev_id), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_6), + test_device_configure_invalid_queue_pair_ids), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encryption_test_case_256_7), + test_queue_pair_descriptor_setup), - /** 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_multi_session), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_decryption_test_case_256_7), + test_multi_session_random_usage), - /** AES GMAC Authentication */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_4), + test_null_invalid_operation), + TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation), + + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_stats), /** AES CCM Authenticated Encryption 128 bits key */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -12965,51 +11797,25 @@ static struct unit_test_suite cryptodev_openssl_testsuite = { 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), - - /** Scatter-Gather */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg), - - /** 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_AES_CCM_authenticated_encryption_test_case_256_3), - /* ESN Testcase */ + /** AES CCM Authenticated Decryption 256 bits key*/ TEST_CASE_ST(ut_setup, ut_teardown, - auth_encrypt_AES128CBC_HMAC_SHA1_esn_check), - + test_AES_CCM_authenticated_decryption_test_case_256_1), TEST_CASE_ST(ut_setup, ut_teardown, - auth_decrypt_AES128CBC_HMAC_SHA1_esn_check), - - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; + 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), -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_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, @@ -13024,6 +11830,10 @@ 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), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_J0_authenticated_encryption_test_case_1), /** AES GCM Authenticated Decryption */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -13040,6 +11850,10 @@ 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), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_J0_authenticated_decryption_test_case_1), /** AES GCM Authenticated Encryption 192 bits key */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -13117,11 +11931,27 @@ static struct unit_test_suite cryptodev_aesni_gcm_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_auth_decryption_test_case_aad_2), + /** Out of place tests */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_oop_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_oop_test_case_1), + + /** Session-less tests */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_sessionless_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_sessionless_test_case_1), + /** AES GMAC Authentication */ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GMAC_authentication_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GMAC_authentication_verify_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_verify_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GMAC_authentication_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, @@ -13131,72 +11961,178 @@ static struct unit_test_suite cryptodev_aesni_gcm_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GMAC_authentication_verify_test_case_4), - /** Negative tests */ + /** SNOW 3G encrypt only (UEA2) */ TEST_CASE_ST(ut_setup, ut_teardown, - authentication_verify_AES128_GMAC_fail_data_corrupt), + test_snow3g_encryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - authentication_verify_AES128_GMAC_fail_tag_corrupt), + test_snow3g_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_5), - /** Out of place tests */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_oop_test_case_1), + test_snow3g_encryption_test_case_1_oop), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_oop_test_case_1), + 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), - /** Session-less tests */ + /** SNOW 3G generate auth, then encrypt (UEA2) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_encryption_sessionless_test_case_1), + test_snow3g_auth_cipher_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_authenticated_decryption_sessionless_test_case_1), + 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), - /** Scatter-Gather */ + /** SNOW 3G decrypt (UEA2), then verify auth */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_in_place_1500B), + test_snow3g_auth_cipher_verify_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg), + test_snow3g_auth_cipher_verify_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_auth_cipher_verify_test_case_2_oop), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_auth_cipher_verify_part_digest_enc), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_auth_cipher_verify_part_digest_enc_oop), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_auth_cipher_verify_test_case_3_sgl), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_auth_cipher_verify_test_case_3_oop_sgl), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_auth_cipher_verify_part_digest_enc_sgl), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl), - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; + /** SNOW 3G decrypt only (UEA2) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_with_digest_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_3), + /* Tests with buffers which length is not byte-aligned */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_3), + /* Tests with buffers which length is not byte-aligned */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_cipher_auth_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_auth_cipher_with_digest_test_case_1), -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) */ + /** ZUC encrypt only (EEA3) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_encryption_test_case_1), + test_zuc_encryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_encryption_test_case_1_sgl), + test_zuc_encryption_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_encryption_test_case_2), + test_zuc_encryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_encryption_test_case_3), + test_zuc_encryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_encryption_test_case_4), + test_zuc_encryption_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_encryption_test_case_5), - /** KASUMI decrypt only (UEA1) */ + test_zuc_encryption_test_case_6_sgl), + + /** ZUC authenticate (EIA3) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_decryption_test_case_1), + test_zuc_hash_generate_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_decryption_test_case_2), + test_zuc_hash_generate_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_decryption_test_case_3), + test_zuc_hash_generate_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_decryption_test_case_4), + test_zuc_hash_generate_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_decryption_test_case_5), + test_zuc_hash_generate_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_7), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_8), + /** ZUC alg-chain (EEA3/EIA3) */ TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_encryption_test_case_1_oop), + test_zuc_cipher_auth_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_encryption_test_case_1_oop_sgl), + 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_kasumi_decryption_test_case_1_oop), + test_zuc_auth_cipher_verify_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_auth_cipher_verify_test_case_1_oop), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_auth_cipher_verify_test_case_1_sgl), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_auth_cipher_verify_test_case_1_oop_sgl), + + /** HMAC_MD5 Authentication */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_MD5_HMAC_generate_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_MD5_HMAC_verify_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_MD5_HMAC_generate_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_MD5_HMAC_verify_case_2), /** KASUMI hash only (UIA1) */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -13211,16 +12147,50 @@ static struct unit_test_suite cryptodev_sw_kasumi_testsuite = { test_kasumi_hash_generate_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, test_kasumi_hash_generate_test_case_6), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_verify_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_verify_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_verify_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_verify_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_verify_test_case_5), + + /** KASUMI encrypt only (UEA1) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_1_sgl), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_1_oop), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_1_oop_sgl), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_5), + + /** KASUMI decrypt only (UEA1) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_decryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_hash_verify_test_case_1), + test_kasumi_decryption_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_hash_verify_test_case_2), + test_kasumi_decryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_hash_verify_test_case_3), + test_kasumi_decryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_hash_verify_test_case_4), + test_kasumi_decryption_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_kasumi_hash_verify_test_case_5), + test_kasumi_decryption_test_case_1_oop), + TEST_CASE_ST(ut_setup, ut_teardown, test_kasumi_cipher_auth_test_case_1), @@ -13247,152 +12217,143 @@ static struct unit_test_suite cryptodev_sw_kasumi_testsuite = { 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), + + /** ESN Testcase */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_2), + auth_encrypt_AES128CBC_HMAC_SHA1_esn_check), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_3), + auth_decrypt_AES128CBC_HMAC_SHA1_esn_check), + + /** Negative tests */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_4), + authentication_verify_HMAC_SHA1_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_5), + authentication_verify_HMAC_SHA1_fail_tag_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_with_digest_test_case_1), - + test_AES_GCM_auth_encryption_fail_iv_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_1_oop), + test_AES_GCM_auth_encryption_fail_in_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_1_oop_sgl), + test_AES_GCM_auth_encryption_fail_out_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_1_oop), - + test_AES_GCM_auth_encryption_fail_aad_len_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_1_offset_oop), - - /** SNOW 3G decrypt only (UEA2) */ + test_AES_GCM_auth_encryption_fail_aad_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_1), + test_AES_GCM_auth_encryption_fail_tag_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_2), + test_AES_GCM_auth_decryption_fail_iv_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_3), + test_AES_GCM_auth_decryption_fail_in_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_4), + test_AES_GCM_auth_decryption_fail_out_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_test_case_5), + test_AES_GCM_auth_decryption_fail_aad_len_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_decryption_with_digest_test_case_1), + test_AES_GCM_auth_decryption_fail_aad_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_generate_test_case_1), + test_AES_GCM_auth_decryption_fail_tag_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_generate_test_case_2), + authentication_verify_AES128_GMAC_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_generate_test_case_3), - /* Tests with buffers which length is not byte-aligned */ + authentication_verify_AES128_GMAC_fail_tag_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_generate_test_case_4), + auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_generate_test_case_5), + auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), + + /** Mixed CIPHER + HASH algorithms */ + /** AUTH AES CMAC + CIPHER AES CTR */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_generate_test_case_6), + test_aes_cmac_aes_ctr_digest_enc_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_verify_test_case_1), + test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_verify_test_case_2), + test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_verify_test_case_3), - /* Tests with buffers which length is not byte-aligned */ + test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_verify_test_case_4), + test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_verify_test_case_5), + test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_hash_verify_test_case_6), + test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_cipher_auth_test_case_1), + test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl), - /** SNOW 3G generate auth, then encrypt (UEA2) */ + /** AUTH ZUC + CIPHER SNOW3G */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_test_case_1), + test_auth_zuc_cipher_snow_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_test_case_2), + test_verify_auth_zuc_cipher_snow_test_case_1), + /** AUTH AES CMAC + CIPHER SNOW3G */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_test_case_2_oop), + test_auth_aes_cmac_cipher_snow_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_part_digest_enc), + test_verify_auth_aes_cmac_cipher_snow_test_case_1), + /** AUTH ZUC + CIPHER AES CTR */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_part_digest_enc_oop), + test_auth_zuc_cipher_aes_ctr_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_test_case_3_sgl), + test_verify_auth_zuc_cipher_aes_ctr_test_case_1), + /** AUTH SNOW3G + CIPHER AES CTR */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_test_case_3_oop_sgl), + test_auth_snow_cipher_aes_ctr_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_part_digest_enc_sgl), + test_verify_auth_snow_cipher_aes_ctr_test_case_1), + /** AUTH SNOW3G + CIPHER ZUC */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_part_digest_enc_oop_sgl), + test_auth_snow_cipher_zuc_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_verify_auth_snow_cipher_zuc_test_case_1), + /** AUTH AES CMAC + CIPHER ZUC */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_auth_aes_cmac_cipher_zuc_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_verify_auth_aes_cmac_cipher_zuc_test_case_1), - /** SNOW 3G decrypt (UEA2), then verify auth */ + /** AUTH NULL + CIPHER SNOW3G */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_test_case_1), + test_auth_null_cipher_snow_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_test_case_2), + test_verify_auth_null_cipher_snow_test_case_1), + /** AUTH NULL + CIPHER ZUC */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_test_case_2_oop), + test_auth_null_cipher_zuc_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_part_digest_enc), + test_verify_auth_null_cipher_zuc_test_case_1), + /** AUTH SNOW3G + CIPHER NULL */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_part_digest_enc_oop), + test_auth_snow_cipher_null_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_test_case_3_sgl), + test_verify_auth_snow_cipher_null_test_case_1), + /** AUTH ZUC + CIPHER NULL */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_test_case_3_oop_sgl), + test_auth_zuc_cipher_null_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_part_digest_enc_sgl), + test_verify_auth_zuc_cipher_null_test_case_1), + /** AUTH NULL + CIPHER AES CTR */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl), + test_auth_null_cipher_aes_ctr_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_verify_auth_null_cipher_aes_ctr_test_case_1), + /** AUTH AES CMAC + CIPHER NULL */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_auth_aes_cmac_cipher_null_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_verify_auth_aes_cmac_cipher_null_test_case_1), TEST_CASES_END() /**< NULL terminate unit test array */ } }; -static struct unit_test_suite cryptodev_sw_zuc_testsuite = { - .suite_name = "Crypto Device SW ZUC Unit Test Suite", +static struct unit_test_suite cryptodev_virtio_testsuite = { + .suite_name = "Crypto VIRTIO 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), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_encryption_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_encryption_test_case_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_encryption_test_case_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_encryption_test_case_5), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_4), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_hash_generate_test_case_5), - TEST_CASE_ST(ut_setup, ut_teardown, - test_zuc_encryption_test_case_6_sgl), + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all), + TEST_CASES_END() /**< NULL terminate unit test array */ } }; @@ -13407,16 +12368,11 @@ static struct unit_test_suite cryptodev_caam_jr_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_caam_jr_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_caam_jr_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_caam_jr_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_caam_jr_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_caam_jr_all), + 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 */ } @@ -13432,16 +12388,11 @@ static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { 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_CASE_ST(ut_setup, ut_teardown, - test_authonly_dpaa_sec_all), + 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, @@ -13696,16 +12647,11 @@ static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { 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_dpaa2_sec_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_dpaa2_sec_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_dpaa2_sec_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_dpaa2_sec_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_dpaa2_sec_all), + 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, @@ -13962,32 +12908,12 @@ static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { } }; -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_CASE_ST(ut_setup, ut_teardown, - test_null_invalid_operation), - TEST_CASE_ST(ut_setup, ut_teardown, - test_null_burst_operation), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_null_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_null_all), - 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), + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all), /** Negative tests */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -14007,16 +12933,11 @@ static struct unit_test_suite cryptodev_mrvl_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session), TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session_random_usage), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_mrvl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_mrvl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_mrvl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_mrvl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_mrvl_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(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, @@ -14040,16 +12961,11 @@ static struct unit_test_suite cryptodev_ccp_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session), TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session_random_usage), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_ccp_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_ccp_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_ccp_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_ccp_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_ccp_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_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, @@ -14070,16 +12986,11 @@ static struct unit_test_suite cryptodev_octeontx_testsuite = { .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_CASE_ST(ut_setup, ut_teardown, - test_authonly_octeontx_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_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, @@ -14286,8 +13197,8 @@ static struct unit_test_suite cryptodev_nitrox_testsuite = { test_device_configure_invalid_dev_id), TEST_CASE_ST(ut_setup, ut_teardown, test_device_configure_invalid_queue_pair_ids), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_nitrox_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all), TEST_CASES_END() /**< NULL terminate unit test array */ } @@ -14298,16 +13209,11 @@ static struct unit_test_suite cryptodev_octeontx2_testsuite = { .setup = testsuite_setup, .teardown = testsuite_teardown, .unit_test_cases = { - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_octeontx2_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_octeontx2_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_octeontx2_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_octeontx2_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_octeontx2_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_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, @@ -14518,7 +13424,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 @@ -14550,7 +13456,30 @@ 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 +test_cryptodev_cpu_aesni_mb(void) +{ + int32_t rc; + enum rte_security_session_action_type at; + + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_AESNI_MB 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 @@ -14566,7 +13495,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 @@ -14582,7 +13511,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 @@ -14598,7 +13550,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 @@ -14614,7 +13566,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 @@ -14630,7 +13582,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 @@ -14646,7 +13598,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 @@ -14821,8 +13773,12 @@ test_cryptodev_nitrox(void) REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat); REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb); +REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest, + test_cryptodev_cpu_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);