X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=test%2Ftest%2Ftest_cryptodev.c;h=46036795449571ac415d4ad46075ab18d7ab8825;hb=fd01a9be38d5105ad74ff56e9789a7e624cb0d9f;hp=6fe5362f2a12455e457da68e0e7b009585ae341b;hpb=c281019bfb01fdd1865a3ac029497184ac72dfc8;p=dpdk.git diff --git a/test/test/test_cryptodev.c b/test/test/test_cryptodev.c index 6fe5362f2a..4603679544 100644 --- a/test/test/test_cryptodev.c +++ b/test/test/test_cryptodev.c @@ -35,6 +35,7 @@ #include #include #include +#include #include #include @@ -57,7 +58,6 @@ #include "test_cryptodev_snow3g_test_vectors.h" #include "test_cryptodev_snow3g_hash_test_vectors.h" #include "test_cryptodev_zuc_test_vectors.h" -#include "test_cryptodev_zuc_hash_test_vectors.h" #include "test_cryptodev_gcm_test_vectors.h" #include "test_cryptodev_hmac_test_vectors.h" @@ -203,14 +203,15 @@ testsuite_setup(void) RTE_CRYPTO_OP_TYPE_SYMMETRIC, NUM_MBUFS, MBUF_CACHE_SIZE, DEFAULT_NUM_XFORMS * - sizeof(struct rte_crypto_sym_xform), + sizeof(struct rte_crypto_sym_xform) + + MAXIMUM_IV_LENGTH, rte_socket_id()); if (ts_params->op_mpool == NULL) { RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n"); return TEST_FAILED; } - /* Create 2 AESNI MB devices if required */ + /* Create an AESNI MB device if required */ if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) { #ifndef RTE_LIBRTE_PMD_AESNI_MB RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be" @@ -219,20 +220,18 @@ testsuite_setup(void) #endif nb_devs = rte_cryptodev_count_devtype( RTE_CRYPTODEV_AESNI_MB_PMD); - if (nb_devs < 2) { - for (i = nb_devs; i < 2; i++) { - ret = rte_eal_vdev_init( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL); - - TEST_ASSERT(ret == 0, - "Failed to create instance %u of" - " pmd : %s", - i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); - } + if (nb_devs < 1) { + ret = rte_vdev_init( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL); + + TEST_ASSERT(ret == 0, + "Failed to create instance of" + " pmd : %s", + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); } } - /* Create 2 AESNI GCM devices if required */ + /* Create an AESNI GCM device if required */ if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) { #ifndef RTE_LIBRTE_PMD_AESNI_GCM RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be" @@ -241,18 +240,16 @@ testsuite_setup(void) #endif nb_devs = rte_cryptodev_count_devtype( RTE_CRYPTODEV_AESNI_GCM_PMD); - if (nb_devs < 2) { - for (i = nb_devs; i < 2; i++) { - TEST_ASSERT_SUCCESS(rte_eal_vdev_init( - RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL), - "Failed to create instance %u of" - " pmd : %s", - i, RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)); - } + if (nb_devs < 1) { + TEST_ASSERT_SUCCESS(rte_vdev_init( + RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL), + "Failed to create instance of" + " pmd : %s", + RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)); } } - /* Create 2 SNOW 3G devices if required */ + /* Create a SNOW 3G device if required */ if (gbl_cryptodev_type == RTE_CRYPTODEV_SNOW3G_PMD) { #ifndef RTE_LIBRTE_PMD_SNOW3G RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_SNOW3G must be" @@ -260,18 +257,16 @@ testsuite_setup(void) return TEST_FAILED; #endif nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD); - if (nb_devs < 2) { - for (i = nb_devs; i < 2; i++) { - TEST_ASSERT_SUCCESS(rte_eal_vdev_init( - RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL), - "Failed to create instance %u of" - " pmd : %s", - i, RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)); - } + if (nb_devs < 1) { + TEST_ASSERT_SUCCESS(rte_vdev_init( + RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL), + "Failed to create instance of" + " pmd : %s", + RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)); } } - /* Create 2 KASUMI devices if required */ + /* Create a KASUMI device if required */ if (gbl_cryptodev_type == RTE_CRYPTODEV_KASUMI_PMD) { #ifndef RTE_LIBRTE_PMD_KASUMI RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_KASUMI must be" @@ -279,18 +274,16 @@ testsuite_setup(void) return TEST_FAILED; #endif nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD); - if (nb_devs < 2) { - for (i = nb_devs; i < 2; i++) { - TEST_ASSERT_SUCCESS(rte_eal_vdev_init( - RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL), - "Failed to create instance %u of" - " pmd : %s", - i, RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)); - } + if (nb_devs < 1) { + TEST_ASSERT_SUCCESS(rte_vdev_init( + RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL), + "Failed to create instance of" + " pmd : %s", + RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)); } } - /* Create 2 ZUC devices if required */ + /* Create a ZUC device if required */ if (gbl_cryptodev_type == RTE_CRYPTODEV_ZUC_PMD) { #ifndef RTE_LIBRTE_PMD_ZUC RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ZUC must be" @@ -298,18 +291,16 @@ testsuite_setup(void) return TEST_FAILED; #endif nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_ZUC_PMD); - if (nb_devs < 2) { - for (i = nb_devs; i < 2; i++) { - TEST_ASSERT_SUCCESS(rte_eal_vdev_init( - RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL), - "Failed to create instance %u of" - " pmd : %s", - i, RTE_STR(CRYPTODEV_NAME_ZUC_PMD)); - } + if (nb_devs < 1) { + TEST_ASSERT_SUCCESS(rte_vdev_init( + RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL), + "Failed to create instance of" + " pmd : %s", + RTE_STR(CRYPTODEV_NAME_ZUC_PMD)); } } - /* Create 2 NULL devices if required */ + /* Create a NULL device if required */ if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) { #ifndef RTE_LIBRTE_PMD_NULL_CRYPTO RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_NULL_CRYPTO must be" @@ -318,20 +309,18 @@ testsuite_setup(void) #endif nb_devs = rte_cryptodev_count_devtype( RTE_CRYPTODEV_NULL_PMD); - if (nb_devs < 2) { - for (i = nb_devs; i < 2; i++) { - int dev_id = rte_eal_vdev_init( - RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL); - - TEST_ASSERT(dev_id >= 0, - "Failed to create instance %u of" - " pmd : %s", - i, RTE_STR(CRYPTODEV_NAME_NULL_PMD)); - } + if (nb_devs < 1) { + ret = rte_vdev_init( + RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL); + + TEST_ASSERT(ret == 0, + "Failed to create instance of" + " pmd : %s", + RTE_STR(CRYPTODEV_NAME_NULL_PMD)); } } - /* Create 2 OPENSSL devices if required */ + /* Create an OPENSSL device if required */ if (gbl_cryptodev_type == RTE_CRYPTODEV_OPENSSL_PMD) { #ifndef RTE_LIBRTE_PMD_OPENSSL RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be" @@ -340,20 +329,18 @@ testsuite_setup(void) #endif nb_devs = rte_cryptodev_count_devtype( RTE_CRYPTODEV_OPENSSL_PMD); - if (nb_devs < 2) { - for (i = nb_devs; i < 2; i++) { - ret = rte_eal_vdev_init( - RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD), - NULL); - - TEST_ASSERT(ret == 0, "Failed to create " - "instance %u of pmd : %s", i, - RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)); - } + if (nb_devs < 1) { + ret = rte_vdev_init( + RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD), + NULL); + + TEST_ASSERT(ret == 0, "Failed to create " + "instance of pmd : %s", + RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)); } } - /* Create 2 ARMv8 devices if required */ + /* Create a ARMv8 device if required */ if (gbl_cryptodev_type == RTE_CRYPTODEV_ARMV8_PMD) { #ifndef RTE_LIBRTE_PMD_ARMV8_CRYPTO RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO must be" @@ -362,16 +349,14 @@ testsuite_setup(void) #endif nb_devs = rte_cryptodev_count_devtype( RTE_CRYPTODEV_ARMV8_PMD); - if (nb_devs < 2) { - for (i = nb_devs; i < 2; i++) { - ret = rte_eal_vdev_init( - RTE_STR(CRYPTODEV_NAME_ARMV8_PMD), - NULL); - - TEST_ASSERT(ret == 0, "Failed to create " - "instance %u of pmd : %s", i, - RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)); - } + if (nb_devs < 1) { + ret = rte_vdev_init( + RTE_STR(CRYPTODEV_NAME_ARMV8_PMD), + NULL); + + TEST_ASSERT(ret == 0, "Failed to create " + "instance of pmd : %s", + RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)); } } @@ -386,7 +371,7 @@ testsuite_setup(void) nb_devs = rte_cryptodev_count_devtype( RTE_CRYPTODEV_SCHEDULER_PMD); if (nb_devs < 1) { - ret = rte_eal_vdev_init( + ret = rte_vdev_init( RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD), NULL); @@ -1323,19 +1308,19 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void) ut_params->ibuf, QUOTE_512_BYTES); sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1; - sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.offset = 0; sym_op->auth.data.length = QUOTE_512_BYTES; /* Set crypto operation cipher parameters */ - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, - CIPHER_IV_LENGTH_AES_CBC); - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; - rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, - CIPHER_IV_LENGTH_AES_CBC); + rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC); - sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.offset = 0; sym_op->cipher.data.length = QUOTE_512_BYTES; /* Process crypto operation */ @@ -1346,8 +1331,8 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void) "crypto op processing failed"); /* Validate obuf */ - uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, - uint8_t *, CIPHER_IV_LENGTH_AES_CBC); + uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src, + uint8_t *); TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext, catch_22_quote_2_512_bytes_AES_CBC_ciphertext, @@ -1477,19 +1462,18 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, ut_params->ibuf, QUOTE_512_BYTES); sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512; - sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->auth.data.offset = 0; sym_op->auth.data.length = QUOTE_512_BYTES; - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset( - ut_params->ibuf, 0); + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; - rte_memcpy(sym_op->cipher.iv.data, iv, - CIPHER_IV_LENGTH_AES_CBC); + rte_memcpy(sym_op->cipher.iv.data, iv, CIPHER_IV_LENGTH_AES_CBC); - sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + sym_op->cipher.data.offset = 0; sym_op->cipher.data.length = QUOTE_512_BYTES; /* Process crypto operation */ @@ -1503,8 +1487,8 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( - rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + - CIPHER_IV_LENGTH_AES_CBC, catch_22_quote, + rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), + catch_22_quote, QUOTE_512_BYTES, "Plaintext data not as expected"); @@ -1531,6 +1515,54 @@ test_AES_cipheronly_mb_all(void) return TEST_SUCCESS; } +static int +test_AES_docsis_mb_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->valid_devs[0], + RTE_CRYPTODEV_AESNI_MB_PMD, + BLKCIPHER_AES_DOCSIS_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_AES_docsis_qat_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->valid_devs[0], + RTE_CRYPTODEV_QAT_SYM_PMD, + BLKCIPHER_AES_DOCSIS_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_DES_docsis_qat_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->valid_devs[0], + RTE_CRYPTODEV_QAT_SYM_PMD, + BLKCIPHER_DES_DOCSIS_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + static int test_authonly_mb_all(void) { @@ -1679,6 +1711,38 @@ test_AES_cipheronly_qat_all(void) return TEST_SUCCESS; } +static int +test_AES_chain_dpaa2_sec_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->valid_devs[0], + RTE_CRYPTODEV_DPAA2_SEC_PMD, + BLKCIPHER_AES_CHAIN_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_AES_cipheronly_dpaa2_sec_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->valid_devs[0], + RTE_CRYPTODEV_DPAA2_SEC_PMD, + BLKCIPHER_AES_CIPHERONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + static int test_authonly_openssl_all(void) { @@ -1775,14 +1839,12 @@ create_wireless_algo_cipher_session(uint8_t dev_id, } static int -create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len, - const unsigned cipher_len, - const unsigned cipher_offset, - enum rte_crypto_cipher_algorithm algo) +create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len, + unsigned int cipher_len, + unsigned int cipher_offset) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - unsigned iv_pad_len = 0; /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, @@ -1799,19 +1861,11 @@ create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len, sym_op->m_src = ut_params->ibuf; /* iv */ - if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8) - iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); - else - iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); - - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf - , iv_pad_len); - - TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); - - memset(sym_op->cipher.iv.data, 0, iv_pad_len); - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - sym_op->cipher.iv.length = iv_pad_len; + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); + sym_op->cipher.iv.length = iv_len; rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); sym_op->cipher.data.length = cipher_len; @@ -1820,14 +1874,12 @@ create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len, } static int -create_wireless_algo_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len, - const unsigned cipher_len, - const unsigned cipher_offset, - enum rte_crypto_cipher_algorithm algo) +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; struct crypto_unittest_params *ut_params = &unittest_params; - unsigned iv_pad_len = 0; /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, @@ -1845,22 +1897,11 @@ create_wireless_algo_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_le sym_op->m_dst = ut_params->obuf; /* iv */ - if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8) - iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); - else - iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, - iv_pad_len); - - TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); - - /* For OOP operation both buffers must have the same size */ - if (ut_params->obuf) - rte_pktmbuf_prepend(ut_params->obuf, iv_pad_len); - - memset(sym_op->cipher.iv.data, 0, iv_pad_len); - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - sym_op->cipher.iv.length = iv_pad_len; + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); + sym_op->cipher.iv.length = iv_len; rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); sym_op->cipher.data.length = cipher_len; @@ -1915,6 +1956,65 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id, return 0; } +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) +{ + const uint8_t key_len = tdata->key.len; + uint8_t cipher_auth_key[key_len]; + + struct crypto_unittest_params *ut_params = &unittest_params; + const uint8_t *key = tdata->key.data; + const uint8_t aad_len = tdata->aad.len; + const uint8_t auth_len = tdata->digest.len; + + memcpy(cipher_auth_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 = 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; + ut_params->auth_xform.auth.add_auth_data_length = aad_len; + + /* 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 = 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; + + TEST_HEXDUMP(stdout, "key:", key, key_len); + + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create(dev_id, + &ut_params->cipher_xform); + + TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); + return 0; +} + +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); +} + static int create_wireless_algo_auth_cipher_session(uint8_t dev_id, enum rte_crypto_cipher_operation cipher_op, @@ -2039,6 +2139,111 @@ create_wireless_algo_hash_operation(const uint8_t *auth_tag, return 0; } +static int +create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata, + enum rte_crypto_auth_operation op, + enum rte_crypto_auth_algorithm auth_algo) +{ + 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; + const uint8_t *aad = tdata->aad.data; + const uint8_t aad_len = tdata->aad.len; + unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len); + unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); + + const uint8_t *iv = tdata->iv.data; + const uint8_t iv_len = tdata->iv.len; + const unsigned int cipher_len = tdata->validCipherLenInBits.len; + const unsigned int cipher_offset = 0; + const unsigned int auth_len = tdata->validAuthLenInBits.len; + const unsigned int auth_offset = tdata->aad.len << 3; + + unsigned int aad_buffer_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); + + 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, auth_tag_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_mtophys_offset( + ut_params->ibuf, data_pad_len); + sym_op->auth.digest.length = auth_tag_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); + + TEST_HEXDUMP(stdout, "digest:", + sym_op->auth.digest.data, + sym_op->auth.digest.length); + + /* aad */ + /* + * Always allocate the aad up to the block size. + * The cryptodev API calls out - + * - the array must be big enough to hold the AAD, plus any + * space to round this up to the nearest multiple of the + * block size (8 bytes for KASUMI and 16 bytes for SNOW 3G). + */ + if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9) + aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8); + else + aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); + sym_op->auth.aad.data = + (uint8_t *)rte_pktmbuf_prepend( + ut_params->ibuf, aad_buffer_len); + TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, + "no room to prepend aad"); + sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( + ut_params->ibuf); + sym_op->auth.aad.length = aad_len; + memset(sym_op->auth.aad.data, 0, aad_buffer_len); + rte_memcpy(sym_op->auth.aad.data, aad, aad_len); + TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len); + + /* iv */ + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); + sym_op->cipher.iv.length = iv_len; + + rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = cipher_offset + auth_offset; + sym_op->auth.data.length = auth_len; + sym_op->auth.data.offset = auth_offset + cipher_offset; + + return 0; +} + +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, + RTE_CRYPTO_AUTH_ZUC_EIA3); +} + static int create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, const unsigned auth_tag_len, @@ -2046,7 +2251,6 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, unsigned data_pad_len, enum rte_crypto_auth_operation op, enum rte_crypto_auth_algorithm auth_algo, - enum rte_crypto_cipher_algorithm cipher_algo, const uint8_t *iv, const uint8_t iv_len, const unsigned cipher_len, const unsigned cipher_offset, const unsigned auth_len, const unsigned auth_offset) @@ -2054,7 +2258,6 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - unsigned iv_pad_len = 0; unsigned aad_buffer_len; /* Generate Crypto op data structure */ @@ -2114,17 +2317,12 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len); /* iv */ - if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8) - iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); - else - iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, iv_pad_len); - - TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); - memset(sym_op->cipher.iv.data, 0, iv_pad_len); - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - sym_op->cipher.iv.length = iv_pad_len; + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); + sym_op->cipher.iv.length = iv_len; + rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); sym_op->cipher.data.length = cipher_len; sym_op->cipher.data.offset = cipher_offset + auth_offset; @@ -2141,13 +2339,11 @@ create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len, unsigned data_pad_len, const unsigned cipher_len, const unsigned cipher_offset, const unsigned auth_len, const unsigned auth_offset, - enum rte_crypto_auth_algorithm auth_algo, - enum rte_crypto_cipher_algorithm cipher_algo) + enum rte_crypto_auth_algorithm auth_algo) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - unsigned iv_pad_len = 0; unsigned aad_buffer_len = 0; /* Generate Crypto op data structure */ @@ -2206,18 +2402,11 @@ create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len, sym_op->auth.aad.data, aad_len); /* iv */ - if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8) - iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); - else - iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); - - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, iv_pad_len); - TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); - - memset(sym_op->cipher.iv.data, 0, iv_pad_len); - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - sym_op->cipher.iv.length = iv_pad_len; + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); + sym_op->cipher.iv.length = iv_len; rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); @@ -2270,7 +2459,7 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_SNOW3G_UIA2, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len); + (tdata->aad.len << 3)); if (retval < 0) return retval; @@ -2332,7 +2521,7 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) RTE_CRYPTO_AUTH_OP_VERIFY, RTE_CRYPTO_AUTH_SNOW3G_UIA2, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len); + (tdata->aad.len << 3)); if (retval < 0) return retval; @@ -2392,7 +2581,7 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_KASUMI_F9, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len); + (tdata->aad.len << 3)); if (retval < 0) return retval; @@ -2454,7 +2643,7 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) RTE_CRYPTO_AUTH_OP_VERIFY, RTE_CRYPTO_AUTH_KASUMI_F9, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len); + (tdata->aad.len << 3)); if (retval < 0) return retval; @@ -2651,8 +2840,7 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata) /* Create KASUMI operation */ retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, tdata->plaintext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_KASUMI_F8); + 0); if (retval < 0) return retval; @@ -2662,8 +2850,7 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len; + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else ciphertext = plaintext; @@ -2725,8 +2912,7 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, tdata->plaintext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_KASUMI_F8); + 0); if (retval < 0) return retval; @@ -2737,10 +2923,10 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len, + ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, plaintext_len, buffer); else - ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len, + ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, plaintext_len, buffer); /* Validate obuf */ @@ -2796,8 +2982,7 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata) retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, tdata->iv.len, tdata->plaintext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_KASUMI_F8); + 0); if (retval < 0) return retval; @@ -2807,8 +2992,7 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len; + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else ciphertext = plaintext; @@ -2871,8 +3055,7 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata) retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, tdata->iv.len, tdata->plaintext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_KASUMI_F8); + 0); if (retval < 0) return retval; @@ -2882,10 +3065,10 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len, + ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, plaintext_pad_len, buffer); else - ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len, + ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, plaintext_pad_len, buffer); /* Validate obuf */ @@ -2939,8 +3122,7 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata) retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, tdata->iv.len, tdata->ciphertext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_KASUMI_F8); + 0); if (retval < 0) return retval; @@ -2950,8 +3132,7 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len; + plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else plaintext = ciphertext; @@ -3005,8 +3186,7 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata) retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, tdata->ciphertext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_KASUMI_F8); + 0); if (retval < 0) return retval; @@ -3016,8 +3196,7 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len; + plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else plaintext = ciphertext; @@ -3070,8 +3249,7 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata) /* Create SNOW 3G operation */ retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + 0); if (retval < 0) return retval; @@ -3081,8 +3259,7 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len; + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else ciphertext = plaintext; @@ -3144,8 +3321,7 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, tdata->iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + 0); if (retval < 0) return retval; @@ -3155,8 +3331,7 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len; + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else ciphertext = plaintext; @@ -3221,8 +3396,7 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, tdata->iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + 0); if (retval < 0) return retval; @@ -3232,10 +3406,10 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len, + ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, plaintext_len, buffer); else - ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len, + ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, plaintext_len, buffer); TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); @@ -3324,9 +3498,7 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, tdata->iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len + - extra_offset, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + extra_offset); if (retval < 0) return retval; @@ -3336,8 +3508,7 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len; + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else ciphertext = plaintext; @@ -3345,8 +3516,7 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); #endif - expected_ciphertext_shifted = rte_malloc(NULL, - ceil_byte_length(plaintext_len + extra_offset), 0); + expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8); TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted, "failed to reserve memory for ciphertext shifted\n"); @@ -3403,8 +3573,7 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) /* Create SNOW 3G operation */ retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + 0); if (retval < 0) return retval; @@ -3413,8 +3582,7 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) 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 *) - + tdata->iv.len; + plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else plaintext = ciphertext; @@ -3477,8 +3645,7 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, tdata->iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + 0); if (retval < 0) return retval; @@ -3487,8 +3654,7 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) 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 *) - + tdata->iv.len; + plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else plaintext = ciphertext; @@ -3502,6 +3668,93 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) return 0; } +static int +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 int plaintext_pad_len; + unsigned int plaintext_len; + + 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); + + /* 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); + + TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_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); + TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); + ut_params->obuf = ut_params->op->sym->m_src; + if (ut_params->obuf) + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + + tdata->aad.len; + else + ciphertext = plaintext; + + TEST_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 + tdata->aad.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_snow3g_cipher_auth(const struct snow3g_test_data *tdata) { @@ -3546,12 +3799,11 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) tdata->aad.len, /*tdata->plaintext.len,*/ plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_SNOW3G_UIA2, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2, tdata->iv.data, tdata->iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, + 0, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len + (tdata->aad.len << 3) ); if (retval < 0) return retval; @@ -3562,7 +3814,7 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_src; if (ut_params->obuf) ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len + tdata->aad.len; + + tdata->aad.len; else ciphertext = plaintext; @@ -3575,7 +3827,7 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) "SNOW 3G Ciphertext data not as expected"); ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len + tdata->aad.len + tdata->iv.len; + + plaintext_pad_len + tdata->aad.len; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -3631,11 +3883,10 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata) tdata->aad.data, tdata->aad.len, plaintext_pad_len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, + 0, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len, - RTE_CRYPTO_AUTH_SNOW3G_UIA2, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2 + (tdata->aad.len << 3), + RTE_CRYPTO_AUTH_SNOW3G_UIA2 ); if (retval < 0) @@ -3647,12 +3898,12 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_src; if (ut_params->obuf) ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->aad.len + tdata->iv.len; + + tdata->aad.len; else ciphertext = plaintext; ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len + tdata->aad.len + tdata->iv.len; + + plaintext_pad_len + tdata->aad.len; TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); /* Validate obuf */ @@ -3716,11 +3967,10 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata) tdata->aad.data, tdata->aad.len, plaintext_pad_len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, + 0, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len, - RTE_CRYPTO_AUTH_KASUMI_F9, - RTE_CRYPTO_CIPHER_KASUMI_F8 + (tdata->aad.len << 3), + RTE_CRYPTO_AUTH_KASUMI_F9 ); if (retval < 0) @@ -3732,7 +3982,7 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_src; if (ut_params->obuf) ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len + tdata->aad.len; + + tdata->aad.len; else ciphertext = plaintext; @@ -3743,7 +3993,7 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata) tdata->validCipherLenInBits.len, "KASUMI Ciphertext data not as expected"); ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len + tdata->aad.len + tdata->iv.len; + + plaintext_pad_len + tdata->aad.len; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -3800,12 +4050,11 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) tdata->aad.len, plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_KASUMI_F9, - RTE_CRYPTO_CIPHER_KASUMI_F8, tdata->iv.data, tdata->iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, + 0, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len + (tdata->aad.len << 3) ); if (retval < 0) return retval; @@ -3816,12 +4065,12 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_src; if (ut_params->obuf) ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->aad.len + tdata->iv.len; + + tdata->aad.len; else ciphertext = plaintext; ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + plaintext_pad_len + tdata->aad.len + tdata->iv.len; + + plaintext_pad_len + tdata->aad.len; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( @@ -3840,7 +4089,7 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) } static int -test_zuc_encryption(const struct zuc_test_data *tdata) +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; @@ -3850,6 +4099,16 @@ test_zuc_encryption(const struct zuc_test_data *tdata) unsigned plaintext_pad_len; unsigned plaintext_len; + 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_ENCRYPT, @@ -3877,8 +4136,7 @@ test_zuc_encryption(const struct zuc_test_data *tdata) /* Create ZUC operation */ retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, tdata->plaintext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_ZUC_EEA3); + 0); if (retval < 0) return retval; @@ -3888,8 +4146,7 @@ test_zuc_encryption(const struct zuc_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len; + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else ciphertext = plaintext; @@ -3905,7 +4162,7 @@ test_zuc_encryption(const struct zuc_test_data *tdata) } static int -test_zuc_encryption_sgl(const struct zuc_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; @@ -3918,11 +4175,21 @@ test_zuc_encryption_sgl(const struct zuc_test_data *tdata) uint8_t ciphertext_buffer[2048]; struct rte_cryptodev_info dev_info; + 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; + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) { printf("Device doesn't support scatter-gather. " "Test Skipped.\n"); - return 0; + return -ENOTSUP; } plaintext_len = ceil_byte_length(tdata->plaintext.len); @@ -3952,8 +4219,7 @@ test_zuc_encryption_sgl(const struct zuc_test_data *tdata) /* Create ZUC operation */ retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, tdata->plaintext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_ZUC_EEA3); + 0); if (retval < 0) return retval; @@ -3964,10 +4230,10 @@ test_zuc_encryption_sgl(const struct zuc_test_data *tdata) ut_params->obuf = ut_params->op->sym->m_dst; if (ut_params->obuf) ciphertext = rte_pktmbuf_read(ut_params->obuf, - tdata->iv.len, plaintext_len, ciphertext_buffer); + 0, plaintext_len, ciphertext_buffer); else ciphertext = rte_pktmbuf_read(ut_params->ibuf, - tdata->iv.len, plaintext_len, ciphertext_buffer); + 0, plaintext_len, ciphertext_buffer); /* Validate obuf */ TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); @@ -3983,7 +4249,7 @@ test_zuc_encryption_sgl(const struct zuc_test_data *tdata) } static int -test_zuc_authentication(const struct zuc_hash_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; @@ -3993,6 +4259,16 @@ test_zuc_authentication(const struct zuc_hash_test_data *tdata) unsigned plaintext_len; uint8_t *plaintext; + 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; + /* Create ZUC session */ retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], tdata->key.data, tdata->key.len, @@ -4022,7 +4298,7 @@ test_zuc_authentication(const struct zuc_hash_test_data *tdata) plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len); + (tdata->aad.len << 3)); if (retval < 0) return retval; @@ -4237,67 +4513,97 @@ test_kasumi_cipher_auth_test_case_1(void) static int test_zuc_encryption_test_case_1(void) { - return test_zuc_encryption(&zuc_test_case_1); + return test_zuc_encryption(&zuc_test_case_cipher_193b); } static int test_zuc_encryption_test_case_2(void) { - return test_zuc_encryption(&zuc_test_case_2); + return test_zuc_encryption(&zuc_test_case_cipher_800b); } static int test_zuc_encryption_test_case_3(void) { - return test_zuc_encryption(&zuc_test_case_3); + return test_zuc_encryption(&zuc_test_case_cipher_1570b); } static int test_zuc_encryption_test_case_4(void) { - return test_zuc_encryption(&zuc_test_case_4); + return test_zuc_encryption(&zuc_test_case_cipher_2798b); } static int test_zuc_encryption_test_case_5(void) { - return test_zuc_encryption(&zuc_test_case_5); + return test_zuc_encryption(&zuc_test_case_cipher_4019b); } static int test_zuc_encryption_test_case_6_sgl(void) { - return test_zuc_encryption_sgl(&zuc_test_case_1); + return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b); } static int test_zuc_hash_generate_test_case_1(void) { - return test_zuc_authentication(&zuc_hash_test_case_1); + return test_zuc_authentication(&zuc_test_case_auth_1b); } static int test_zuc_hash_generate_test_case_2(void) { - return test_zuc_authentication(&zuc_hash_test_case_2); + return test_zuc_authentication(&zuc_test_case_auth_90b); } static int test_zuc_hash_generate_test_case_3(void) { - return test_zuc_authentication(&zuc_hash_test_case_3); + return test_zuc_authentication(&zuc_test_case_auth_577b); } static int test_zuc_hash_generate_test_case_4(void) { - return test_zuc_authentication(&zuc_hash_test_case_4); + return test_zuc_authentication(&zuc_test_case_auth_2079b); } static int test_zuc_hash_generate_test_case_5(void) { - return test_zuc_authentication(&zuc_hash_test_case_5); + 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) +{ + return test_zuc_authentication(&zuc_test_case_auth_2080b); +} + +static int +test_zuc_hash_generate_test_case_8(void) +{ + return test_zuc_authentication(&zuc_test_case_auth_584b); +} + +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 @@ -4332,6 +4638,54 @@ test_DES_cipheronly_qat_all(void) return TEST_SUCCESS; } +static int +test_DES_docsis_openssl_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->valid_devs[0], + RTE_CRYPTODEV_OPENSSL_PMD, + BLKCIPHER_DES_DOCSIS_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_3DES_chain_dpaa2_sec_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->valid_devs[0], + RTE_CRYPTODEV_DPAA2_SEC_PMD, + BLKCIPHER_3DES_CHAIN_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_3DES_cipheronly_dpaa2_sec_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->valid_devs[0], + RTE_CRYPTODEV_DPAA2_SEC_PMD, + BLKCIPHER_3DES_CIPHERONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + static int test_3DES_cipheronly_qat_all(void) { @@ -4476,7 +4830,7 @@ create_gcm_operation(enum rte_crypto_cipher_operation op, struct crypto_unittest_params *ut_params = &unittest_params; uint8_t *plaintext, *ciphertext; - unsigned int iv_pad_len, aad_pad_len, plaintext_pad_len; + unsigned int aad_pad_len, plaintext_pad_len; /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, @@ -4500,14 +4854,11 @@ create_gcm_operation(enum rte_crypto_cipher_operation op, TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, sym_op->auth.aad.length); - /* Prepend iv */ - iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16); - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, iv_pad_len); - TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); - - memset(sym_op->cipher.iv.data, 0, iv_pad_len); - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + /* Append IV at the end of the crypto operation*/ + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); sym_op->cipher.iv.length = tdata->iv.len; rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len); @@ -4528,12 +4879,11 @@ create_gcm_operation(enum rte_crypto_cipher_operation op, if (ut_params->obuf) { ciphertext = (uint8_t *)rte_pktmbuf_append( ut_params->obuf, - plaintext_pad_len + aad_pad_len + - iv_pad_len); + plaintext_pad_len + aad_pad_len); TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext"); - memset(ciphertext + aad_pad_len + iv_pad_len, 0, + memset(ciphertext + aad_pad_len, 0, tdata->ciphertext.len); } } else { @@ -4551,12 +4901,11 @@ create_gcm_operation(enum rte_crypto_cipher_operation op, if (ut_params->obuf) { plaintext = (uint8_t *)rte_pktmbuf_append( ut_params->obuf, - plaintext_pad_len + aad_pad_len + - iv_pad_len); + plaintext_pad_len + aad_pad_len); TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); - memset(plaintext + aad_pad_len + iv_pad_len, 0, + memset(plaintext + aad_pad_len, 0, tdata->plaintext.len); } } @@ -4574,7 +4923,7 @@ create_gcm_operation(enum rte_crypto_cipher_operation op, ut_params->obuf ? ut_params->obuf : ut_params->ibuf, plaintext_pad_len + - aad_pad_len + iv_pad_len); + aad_pad_len); sym_op->auth.digest.length = tdata->auth_tag.len; } else { sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( @@ -4583,7 +4932,7 @@ create_gcm_operation(enum rte_crypto_cipher_operation op, "no room to append digest"); sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( ut_params->ibuf, - plaintext_pad_len + aad_pad_len + iv_pad_len); + plaintext_pad_len + aad_pad_len); sym_op->auth.digest.length = tdata->auth_tag.len; rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data, @@ -4594,10 +4943,10 @@ create_gcm_operation(enum rte_crypto_cipher_operation op, } sym_op->cipher.data.length = tdata->plaintext.len; - sym_op->cipher.data.offset = aad_pad_len + iv_pad_len; + sym_op->cipher.data.offset = aad_pad_len; sym_op->auth.data.length = tdata->plaintext.len; - sym_op->auth.data.offset = aad_pad_len + iv_pad_len; + sym_op->auth.data.offset = aad_pad_len; return 0; } @@ -5126,8 +5475,8 @@ test_AES_GCM_authenticated_encryption_sessionless( ut_params->op->sym->m_src = ut_params->ibuf; - TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type, - RTE_CRYPTO_SYM_OP_SESSIONLESS, + TEST_ASSERT_EQUAL(ut_params->op->sess_type, + RTE_CRYPTO_OP_SESSIONLESS, "crypto op session type not sessionless"); /* Process crypto operation */ @@ -5206,8 +5555,8 @@ test_AES_GCM_authenticated_decryption_sessionless( ut_params->op->sym->m_src = ut_params->ibuf; - TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type, - RTE_CRYPTO_SYM_OP_SESSIONLESS, + TEST_ASSERT_EQUAL(ut_params->op->sess_type, + RTE_CRYPTO_OP_SESSIONLESS, "crypto op session type not sessionless"); /* Process crypto operation */ @@ -6035,10 +6384,8 @@ create_gmac_operation(enum rte_crypto_auth_operation op, struct crypto_unittest_params *ut_params = &unittest_params; struct rte_crypto_sym_op *sym_op; - unsigned iv_pad_len; unsigned aad_pad_len; - iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16); aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); /* @@ -6083,17 +6430,15 @@ create_gmac_operation(enum rte_crypto_auth_operation op, sym_op->auth.digest.length); } - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, iv_pad_len); - TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); - - memset(sym_op->cipher.iv.data, 0, iv_pad_len); - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); sym_op->cipher.iv.length = tdata->iv.len; rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len); - TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len); + TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, tdata->iv.len); sym_op->cipher.data.length = 0; sym_op->cipher.data.offset = 0; @@ -6631,14 +6976,13 @@ create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params, sym_op->auth.digest.data, sym_op->auth.digest.length); - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, reference->iv.len); - TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); - - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); sym_op->cipher.iv.length = reference->iv.len; - memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len); + rte_memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len); sym_op->cipher.data.length = 0; sym_op->cipher.data.offset = 0; @@ -6691,20 +7035,19 @@ create_cipher_auth_operation(struct crypto_testsuite_params *ts_params, sym_op->auth.digest.data, sym_op->auth.digest.length); - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, reference->iv.len); - TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); - - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); sym_op->cipher.iv.length = reference->iv.len; - memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len); + rte_memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len); sym_op->cipher.data.length = reference->ciphertext.len; - sym_op->cipher.data.offset = reference->iv.len; + sym_op->cipher.data.offset = 0; sym_op->auth.data.length = reference->ciphertext.len; - sym_op->auth.data.offset = reference->iv.len; + sym_op->auth.data.offset = 0; return 0; } @@ -6918,8 +7261,6 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op, const unsigned int iv_len = tdata->iv.len; const unsigned int aad_len = tdata->aad.len; - unsigned int iv_pad_len = 0; - /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); @@ -6944,19 +7285,13 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op, sym_op->auth.digest.length); } - iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); - - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, iv_pad_len); - - TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, - "no room to prepend iv"); - - memset(sym_op->cipher.iv.data, 0, iv_pad_len); - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); + sym_op->cipher.iv.data = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + sym_op->cipher.iv.phys_addr = rte_crypto_op_ctophys_offset(ut_params->op, + IV_OFFSET); sym_op->cipher.iv.length = iv_len; - rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, iv_pad_len); + rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, iv_len); sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend( ut_params->ibuf, aad_len); @@ -6969,14 +7304,14 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op, memset(sym_op->auth.aad.data, 0, aad_len); rte_memcpy(sym_op->auth.aad.data, tdata->aad.data, aad_len); - TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len); + TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_len); TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len); sym_op->cipher.data.length = tdata->plaintext.len; - sym_op->cipher.data.offset = aad_len + iv_pad_len; + sym_op->cipher.data.offset = aad_len; - sym_op->auth.data.offset = aad_len + iv_pad_len; + sym_op->auth.data.offset = aad_len; sym_op->auth.data.length = tdata->plaintext.len; return 0; @@ -7010,8 +7345,7 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata, int ecx = 0; void *digest_mem = NULL; - uint32_t prepend_len = ALIGN_POW2_ROUNDUP(tdata->iv.len, 16) - + tdata->aad.len; + uint32_t prepend_len = tdata->aad.len; if (tdata->plaintext.len % fragsz != 0) { if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO) @@ -7384,14 +7718,17 @@ test_scheduler_attach_slave_op(void) 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_count_devtype( RTE_CRYPTODEV_AESNI_MB_PMD); if (nb_devs < 2) { for (i = nb_devs; i < 2; i++) { - ret = rte_eal_vdev_init( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL); + 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" @@ -7463,11 +7800,11 @@ test_scheduler_mode_op(void) "Failed to set cdev %u to user defined mode", sched_id); /* set round robin mode */ - ret = rte_crpytodev_scheduler_mode_set(sched_id, + ret = rte_cryptodev_scheduler_mode_set(sched_id, CDEV_SCHED_MODE_ROUNDROBIN); TEST_ASSERT(ret == 0, "Failed to set cdev %u to round-robin mode", sched_id); - TEST_ASSERT(rte_crpytodev_scheduler_mode_get(sched_id) == + TEST_ASSERT(rte_cryptodev_scheduler_mode_get(sched_id) == CDEV_SCHED_MODE_ROUNDROBIN, "Scheduling Mode " "not match"); @@ -7516,6 +7853,10 @@ static struct unit_test_suite cryptodev_qat_testsuite = { 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_stats), /** AES GCM Authenticated Encryption */ @@ -7615,6 +7956,32 @@ static struct unit_test_suite cryptodev_qat_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_snow3g_auth_cipher_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), + /** HMAC_MD5 Authentication */ TEST_CASE_ST(ut_setup, ut_teardown, test_MD5_HMAC_generate_case_1), @@ -7673,6 +8040,7 @@ static struct unit_test_suite cryptodev_aesni_mb_testsuite = { .unit_test_cases = { 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_CASES_END() /**< NULL terminate unit test array */ @@ -7695,6 +8063,8 @@ static struct unit_test_suite cryptodev_openssl_testsuite = { 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_docsis_openssl_all), TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_openssl_all), @@ -8065,6 +8435,39 @@ static struct unit_test_suite cryptodev_sw_zuc_testsuite = { } }; +static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { + .suite_name = "Crypto DPAA2_SEC Unit Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { + TEST_CASE_ST(ut_setup, ut_teardown, + test_device_configure_invalid_dev_id), + TEST_CASE_ST(ut_setup, ut_teardown, + test_multi_session), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_chain_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), + + /** 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), + + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + static struct unit_test_suite cryptodev_null_testsuite = { .suite_name = "Crypto Device NULL Unit Test Suite", .setup = testsuite_setup, @@ -8188,6 +8591,13 @@ REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler); #endif +static int +test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/) +{ + gbl_cryptodev_type = RTE_CRYPTODEV_DPAA2_SEC_PMD; + return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite); +} + REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat); REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb); REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl); @@ -8197,3 +8607,4 @@ REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g); REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi); REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc); REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8); +REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);