X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Ftest%2Ftest_cryptodev.c;h=83cf7307754b1dc7f94a1c423262c990dbdb91c1;hb=refs%2Fchanges%2F08%2F13108%2F1;hp=029ce8a0f70994f45ef978ef394db5401c0f5d29;hpb=7595afa4d30097c1177b69257118d8ad89a539be;p=deb_dpdk.git diff --git a/test/test/test_cryptodev.c b/test/test/test_cryptodev.c index 029ce8a0..83cf7307 100644 --- a/test/test/test_cryptodev.c +++ b/test/test/test_cryptodev.c @@ -30,11 +30,15 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include + #include #include #include #include #include +#include +#include #include #include @@ -57,15 +61,16 @@ #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_gcm_test_vectors.h" +#include "test_cryptodev_aead_test_vectors.h" #include "test_cryptodev_hmac_test_vectors.h" -static enum rte_cryptodev_type gbl_cryptodev_type; +static int gbl_driver_id; struct crypto_testsuite_params { struct rte_mempool *mbuf_pool; struct rte_mempool *large_mbuf_pool; struct rte_mempool *op_mpool; + struct rte_mempool *session_mpool; struct rte_cryptodev_config conf; struct rte_cryptodev_qp_conf qp_conf; @@ -76,6 +81,7 @@ struct crypto_testsuite_params { struct crypto_unittest_params { struct rte_crypto_sym_xform cipher_xform; struct rte_crypto_sym_xform auth_xform; + struct rte_crypto_sym_xform aead_xform; struct rte_cryptodev_sym_session *sess; @@ -202,7 +208,8 @@ 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"); @@ -210,14 +217,11 @@ testsuite_setup(void) } /* 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" - " enabled in config file to run this testsuite.\n"); - return TEST_FAILED; -#endif - nb_devs = rte_cryptodev_count_devtype( - RTE_CRYPTODEV_AESNI_MB_PMD); + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) { + nb_devs = rte_cryptodev_device_count_by_driver( + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))); if (nb_devs < 1) { ret = rte_vdev_init( RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL); @@ -230,14 +234,11 @@ testsuite_setup(void) } /* 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" - " enabled in config file to run this testsuite.\n"); - return TEST_FAILED; -#endif - nb_devs = rte_cryptodev_count_devtype( - RTE_CRYPTODEV_AESNI_GCM_PMD); + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) { + nb_devs = rte_cryptodev_device_count_by_driver( + rte_cryptodev_driver_id_get( + 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), @@ -248,13 +249,11 @@ testsuite_setup(void) } /* 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" - " enabled in config file to run this testsuite.\n"); - return TEST_FAILED; -#endif - nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD); + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) { + nb_devs = rte_cryptodev_device_count_by_driver( + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))); if (nb_devs < 1) { TEST_ASSERT_SUCCESS(rte_vdev_init( RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL), @@ -265,13 +264,11 @@ testsuite_setup(void) } /* 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" - " enabled in config file to run this testsuite.\n"); - return TEST_FAILED; -#endif - nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD); + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) { + nb_devs = rte_cryptodev_device_count_by_driver( + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))); if (nb_devs < 1) { TEST_ASSERT_SUCCESS(rte_vdev_init( RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL), @@ -282,13 +279,11 @@ testsuite_setup(void) } /* 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" - " enabled in config file to run this testsuite.\n"); - return TEST_FAILED; -#endif - nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_ZUC_PMD); + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) { + nb_devs = rte_cryptodev_device_count_by_driver( + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_ZUC_PMD))); if (nb_devs < 1) { TEST_ASSERT_SUCCESS(rte_vdev_init( RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL), @@ -299,14 +294,11 @@ testsuite_setup(void) } /* 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" - " enabled in config file to run this testsuite.\n"); - return TEST_FAILED; -#endif - nb_devs = rte_cryptodev_count_devtype( - RTE_CRYPTODEV_NULL_PMD); + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_NULL_PMD))) { + nb_devs = rte_cryptodev_device_count_by_driver( + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_NULL_PMD))); if (nb_devs < 1) { ret = rte_vdev_init( RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL); @@ -319,14 +311,11 @@ testsuite_setup(void) } /* 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" - " enabled in config file to run this testsuite.\n"); - return TEST_FAILED; -#endif - nb_devs = rte_cryptodev_count_devtype( - RTE_CRYPTODEV_OPENSSL_PMD); + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) { + nb_devs = rte_cryptodev_device_count_by_driver( + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))); if (nb_devs < 1) { ret = rte_vdev_init( RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD), @@ -339,14 +328,11 @@ testsuite_setup(void) } /* 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" - " enabled in config file to run this testsuite.\n"); - return TEST_FAILED; -#endif - nb_devs = rte_cryptodev_count_devtype( - RTE_CRYPTODEV_ARMV8_PMD); + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) { + nb_devs = rte_cryptodev_device_count_by_driver( + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))); if (nb_devs < 1) { ret = rte_vdev_init( RTE_STR(CRYPTODEV_NAME_ARMV8_PMD), @@ -358,16 +344,35 @@ testsuite_setup(void) } } -#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER - if (gbl_cryptodev_type == RTE_CRYPTODEV_SCHEDULER_PMD) { - -#ifndef RTE_LIBRTE_PMD_AESNI_MB - RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be" + /* Create a MRVL device if required */ + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_MRVL_PMD))) { +#ifndef RTE_LIBRTE_PMD_MRVL_CRYPTO + RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_MRVL_CRYPTO must be" " enabled in config file to run this testsuite.\n"); return TEST_FAILED; #endif - nb_devs = rte_cryptodev_count_devtype( - RTE_CRYPTODEV_SCHEDULER_PMD); + nb_devs = rte_cryptodev_device_count_by_driver( + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_MRVL_PMD))); + if (nb_devs < 1) { + ret = rte_vdev_init( + RTE_STR(CRYPTODEV_NAME_MRVL_PMD), + NULL); + + TEST_ASSERT(ret == 0, "Failed to create " + "instance of pmd : %s", + RTE_STR(CRYPTODEV_NAME_MRVL_PMD)); + } + } + +#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER + if (gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) { + + nb_devs = rte_cryptodev_device_count_by_driver( + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))); if (nb_devs < 1) { ret = rte_vdev_init( RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD), @@ -381,14 +386,6 @@ testsuite_setup(void) } #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */ -#ifndef RTE_LIBRTE_PMD_QAT - if (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) { - RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled " - "in config file to run this testsuite.\n"); - return TEST_FAILED; - } -#endif - nb_devs = rte_cryptodev_count(); if (nb_devs < 1) { RTE_LOG(ERR, USER1, "No crypto devices found?\n"); @@ -398,7 +395,7 @@ testsuite_setup(void) /* Create list of valid crypto devs */ for (i = 0; i < nb_devs; i++) { rte_cryptodev_info_get(i, &info); - if (info.dev_type == gbl_cryptodev_type) + if (info.driver_id == gbl_driver_id) ts_params->valid_devs[ts_params->valid_dev_count++] = i; } @@ -413,7 +410,23 @@ testsuite_setup(void) ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs; ts_params->conf.socket_id = SOCKET_ID_ANY; - ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions; + + unsigned int session_size = rte_cryptodev_get_private_session_size(dev_id); + + /* + * Create mempool with maximum number of sessions * 2, + * to include the session headers + */ + ts_params->session_mpool = rte_mempool_create( + "test_sess_mp", + info.sym.max_nb_sessions * 2, + session_size, + 0, 0, NULL, NULL, NULL, + NULL, SOCKET_ID_ANY, + 0); + + TEST_ASSERT_NOT_NULL(ts_params->session_mpool, + "session mempool allocation failed"); TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf), @@ -425,7 +438,8 @@ testsuite_setup(void) for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) { TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( dev_id, qp_id, &ts_params->qp_conf, - rte_cryptodev_socket_id(dev_id)), + rte_cryptodev_socket_id(dev_id), + ts_params->session_mpool), "Failed to setup queue pair %u on cryptodev %u", qp_id, dev_id); } @@ -448,6 +462,11 @@ testsuite_teardown(void) rte_mempool_avail_count(ts_params->op_mpool)); } + /* Free session mempools */ + if (ts_params->session_mpool != NULL) { + rte_mempool_free(ts_params->session_mpool); + ts_params->session_mpool = NULL; + } } static int @@ -463,7 +482,6 @@ ut_setup(void) /* Reconfigure device to default parameters */ ts_params->conf.socket_id = SOCKET_ID_ANY; - ts_params->conf.session_mp.nb_objs = DEFAULT_NUM_OPS_INFLIGHT; TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], &ts_params->conf), @@ -474,7 +492,8 @@ ut_setup(void) TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( ts_params->valid_devs[0], qp_id, &ts_params->qp_conf, - rte_cryptodev_socket_id(ts_params->valid_devs[0])), + rte_cryptodev_socket_id(ts_params->valid_devs[0]), + ts_params->session_mpool), "Failed to setup queue pair %u on cryptodev %u", qp_id, ts_params->valid_devs[0]); } @@ -499,8 +518,9 @@ ut_teardown(void) /* free crypto session structure */ if (ut_params->sess) { - rte_cryptodev_sym_session_free(ts_params->valid_devs[0], + rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], ut_params->sess); + rte_cryptodev_sym_session_free(ut_params->sess); ut_params->sess = NULL; } @@ -593,7 +613,8 @@ test_device_configure_invalid_queue_pair_ids(void) TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], &ts_params->conf), "Failed to configure cryptodev: dev_id %u, qp_id %u", - ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs); + ts_params->valid_devs[0], + ts_params->conf.nb_queue_pairs); /* invalid - zero queue pairs */ @@ -651,13 +672,11 @@ test_queue_pair_descriptor_setup(void) rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); - ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions; - TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], - &ts_params->conf), "Failed to configure cryptodev %u", + &ts_params->conf), + "Failed to configure cryptodev %u", ts_params->valid_devs[0]); - /* * Test various ring sizes on this device. memzones can't be * freed so are re-used if ring is released and re-created. @@ -668,7 +687,8 @@ test_queue_pair_descriptor_setup(void) TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( ts_params->valid_devs[0], qp_id, &qp_conf, rte_cryptodev_socket_id( - ts_params->valid_devs[0])), + ts_params->valid_devs[0]), + ts_params->session_mpool), "Failed test for " "rte_cryptodev_queue_pair_setup: num_inflights " "%u on qp %u on cryptodev %u", @@ -682,7 +702,8 @@ test_queue_pair_descriptor_setup(void) TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( ts_params->valid_devs[0], qp_id, &qp_conf, rte_cryptodev_socket_id( - ts_params->valid_devs[0])), + ts_params->valid_devs[0]), + ts_params->session_mpool), "Failed test for" " rte_cryptodev_queue_pair_setup: num_inflights" " %u on qp %u on cryptodev %u", @@ -696,7 +717,8 @@ test_queue_pair_descriptor_setup(void) TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( ts_params->valid_devs[0], qp_id, &qp_conf, rte_cryptodev_socket_id( - ts_params->valid_devs[0])), + ts_params->valid_devs[0]), + ts_params->session_mpool), "Failed test for " "rte_cryptodev_queue_pair_setup: num_inflights" " %u on qp %u on cryptodev %u", @@ -711,7 +733,8 @@ test_queue_pair_descriptor_setup(void) TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( ts_params->valid_devs[0], qp_id, &qp_conf, rte_cryptodev_socket_id( - ts_params->valid_devs[0])), + ts_params->valid_devs[0]), + ts_params->session_mpool), "Unexpectedly passed test for " "rte_cryptodev_queue_pair_setup:" "num_inflights %u on qp %u on cryptodev %u", @@ -726,7 +749,8 @@ test_queue_pair_descriptor_setup(void) TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( ts_params->valid_devs[0], qp_id, &qp_conf, rte_cryptodev_socket_id( - ts_params->valid_devs[0])), + ts_params->valid_devs[0]), + ts_params->session_mpool), "Unexpectedly passed test for " "rte_cryptodev_queue_pair_setup:" "num_inflights %u on qp %u on cryptodev %u", @@ -740,7 +764,8 @@ test_queue_pair_descriptor_setup(void) TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( ts_params->valid_devs[0], qp_id, &qp_conf, rte_cryptodev_socket_id( - ts_params->valid_devs[0])), + ts_params->valid_devs[0]), + ts_params->session_mpool), "Failed test for" " rte_cryptodev_queue_pair_setup:" "num_inflights %u on qp %u on cryptodev %u", @@ -755,7 +780,8 @@ test_queue_pair_descriptor_setup(void) TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( ts_params->valid_devs[0], qp_id, &qp_conf, rte_cryptodev_socket_id( - ts_params->valid_devs[0])), + ts_params->valid_devs[0]), + ts_params->session_mpool), "Unexpectedly passed test for " "rte_cryptodev_queue_pair_setup:" "num_inflights %u on qp %u on cryptodev %u", @@ -771,7 +797,8 @@ test_queue_pair_descriptor_setup(void) TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( ts_params->valid_devs[0], qp_id, &qp_conf, - rte_cryptodev_socket_id(ts_params->valid_devs[0])), + rte_cryptodev_socket_id(ts_params->valid_devs[0]), + ts_params->session_mpool), "Failed test for rte_cryptodev_queue_pair_setup:" "invalid qp %u on cryptodev %u", qp_id, ts_params->valid_devs[0]); @@ -781,7 +808,8 @@ test_queue_pair_descriptor_setup(void) TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( ts_params->valid_devs[0], qp_id, &qp_conf, - rte_cryptodev_socket_id(ts_params->valid_devs[0])), + rte_cryptodev_socket_id(ts_params->valid_devs[0]), + ts_params->session_mpool), "Failed test for rte_cryptodev_queue_pair_setup:" "invalid qp %u on cryptodev %u", qp_id, ts_params->valid_devs[0]); @@ -1269,6 +1297,8 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void) ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; ut_params->cipher_xform.cipher.key.data = aes_cbc_key; ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; + ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; + ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; /* Setup HMAC Parameters */ ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; @@ -1281,10 +1311,13 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void) ut_params->auth_xform.auth.key.data = hmac_sha1_key; ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1; - /* Create crypto session*/ ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], - &ut_params->cipher_xform); + 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_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); /* Generate crypto op data structure */ @@ -1302,23 +1335,18 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void) /* Set crypto operation authentication parameters */ sym_op->auth.digest.data = ut_params->digest; - sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 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.length = CIPHER_IV_LENGTH_AES_CBC; - - rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, - CIPHER_IV_LENGTH_AES_CBC); + /* Copy IV at the end of the crypto operation */ + rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), + aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC); - sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + /* Set crypto operation cipher parameters */ + sym_op->cipher.data.offset = 0; sym_op->cipher.data.length = QUOTE_512_BYTES; /* Process crypto operation */ @@ -1329,8 +1357,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, @@ -1341,7 +1369,8 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void) TEST_ASSERT_BUFFERS_ARE_EQUAL(digest, catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest, - gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ? + gbl_driver_id == rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ? TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 : DIGEST_BYTE_LENGTH_SHA1, "Generated digest data not as expected"); @@ -1405,6 +1434,8 @@ test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 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 = CIPHER_KEY_LENGTH_AES_CBC; + ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; + ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; /* Setup HMAC Parameters */ ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; @@ -1456,23 +1487,17 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, sym_op->m_src = ut_params->ibuf; sym_op->auth.digest.data = ut_params->digest; - sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 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.length = CIPHER_IV_LENGTH_AES_CBC; + /* Copy IV at the end of the crypto operation */ + rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), + 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 */ @@ -1486,8 +1511,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"); @@ -1505,8 +1530,11 @@ test_AES_cipheronly_mb_all(void) 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, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)), BLKCIPHER_AES_CIPHERONLY_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1521,8 +1549,11 @@ test_AES_docsis_mb_all(void) 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, + ts_params->op_mpool, + ts_params->session_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"); @@ -1537,8 +1568,11 @@ test_AES_docsis_qat_all(void) 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, + ts_params->op_mpool, + ts_params->session_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"); @@ -1553,8 +1587,11 @@ test_DES_docsis_qat_all(void) 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, + ts_params->op_mpool, + ts_params->session_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"); @@ -1569,8 +1606,11 @@ test_authonly_mb_all(void) 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, + ts_params->op_mpool, + ts_params->session_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"); @@ -1578,6 +1618,24 @@ test_authonly_mb_all(void) return TEST_SUCCESS; } +static int +test_authonly_qat_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->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; +} static int test_AES_chain_mb_all(void) { @@ -1585,8 +1643,11 @@ test_AES_chain_mb_all(void) 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, + ts_params->op_mpool, + ts_params->session_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"); @@ -1603,8 +1664,11 @@ test_AES_cipheronly_scheduler_all(void) int status; status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->valid_devs[0], - RTE_CRYPTODEV_SCHEDULER_PMD, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)), BLKCIPHER_AES_CIPHERONLY_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1619,8 +1683,11 @@ test_AES_chain_scheduler_all(void) int status; status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->valid_devs[0], - RTE_CRYPTODEV_SCHEDULER_PMD, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)), BLKCIPHER_AES_CHAIN_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1635,8 +1702,11 @@ test_authonly_scheduler_all(void) int status; status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->valid_devs[0], - RTE_CRYPTODEV_SCHEDULER_PMD, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)), BLKCIPHER_AUTHONLY_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1653,8 +1723,11 @@ test_AES_chain_openssl_all(void) int status; status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->valid_devs[0], - RTE_CRYPTODEV_OPENSSL_PMD, + ts_params->op_mpool, + ts_params->session_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"); @@ -1669,8 +1742,11 @@ test_AES_cipheronly_openssl_all(void) int status; status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->valid_devs[0], - RTE_CRYPTODEV_OPENSSL_PMD, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)), BLKCIPHER_AES_CIPHERONLY_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1685,8 +1761,11 @@ test_AES_chain_qat_all(void) 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, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)), BLKCIPHER_AES_CHAIN_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1701,8 +1780,49 @@ test_AES_cipheronly_qat_all(void) 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, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)), + BLKCIPHER_AES_CIPHERONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_AES_chain_dpaa_sec_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)), + BLKCIPHER_AES_CHAIN_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_AES_cipheronly_dpaa_sec_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)), BLKCIPHER_AES_CIPHERONLY_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1710,6 +1830,25 @@ test_AES_cipheronly_qat_all(void) return TEST_SUCCESS; } +static int +test_authonly_dpaa_sec_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)), + BLKCIPHER_AUTHONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + static int test_AES_chain_dpaa2_sec_all(void) { @@ -1717,8 +1856,11 @@ test_AES_chain_dpaa2_sec_all(void) 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, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)), BLKCIPHER_AES_CHAIN_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1733,8 +1875,11 @@ test_AES_cipheronly_dpaa2_sec_all(void) 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, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)), BLKCIPHER_AES_CIPHERONLY_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1742,6 +1887,25 @@ test_AES_cipheronly_dpaa2_sec_all(void) return TEST_SUCCESS; } +static int +test_authonly_dpaa2_sec_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)), + BLKCIPHER_AUTHONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + static int test_authonly_openssl_all(void) { @@ -1749,8 +1913,11 @@ test_authonly_openssl_all(void) int status; status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->valid_devs[0], - RTE_CRYPTODEV_OPENSSL_PMD, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)), BLKCIPHER_AUTHONLY_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1765,8 +1932,30 @@ test_AES_chain_armv8_all(void) int status; status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->valid_devs[0], - RTE_CRYPTODEV_ARMV8_PMD, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)), + BLKCIPHER_AES_CHAIN_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_AES_chain_mrvl_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_MRVL_PMD)), BLKCIPHER_AES_CHAIN_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -1774,16 +1963,93 @@ test_AES_chain_armv8_all(void) return TEST_SUCCESS; } +static int +test_AES_cipheronly_mrvl_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_MRVL_PMD)), + BLKCIPHER_AES_CIPHERONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_authonly_mrvl_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_MRVL_PMD)), + BLKCIPHER_AUTHONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_3DES_chain_mrvl_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_MRVL_PMD)), + BLKCIPHER_3DES_CHAIN_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_3DES_cipheronly_mrvl_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_MRVL_PMD)), + BLKCIPHER_3DES_CIPHERONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + /* ***** SNOW 3G Tests ***** */ static int create_wireless_algo_hash_session(uint8_t dev_id, const uint8_t *key, const uint8_t key_len, - const uint8_t aad_len, const uint8_t auth_len, + const uint8_t iv_len, const uint8_t auth_len, enum rte_crypto_auth_operation op, enum rte_crypto_auth_algorithm algo) { uint8_t hash_key[key_len]; + struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; memcpy(hash_key, key, key_len); @@ -1799,9 +2065,13 @@ create_wireless_algo_hash_session(uint8_t dev_id, 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.add_auth_data_length = aad_len; - ut_params->sess = rte_cryptodev_sym_session_create(dev_id, - &ut_params->auth_xform); + 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); + + rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->auth_xform, ts_params->session_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; } @@ -1810,10 +2080,12 @@ 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) + const uint8_t *key, const uint8_t key_len, + uint8_t iv_len) { uint8_t cipher_key[key_len]; + struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; memcpy(cipher_key, key, key_len); @@ -1826,26 +2098,28 @@ create_wireless_algo_cipher_session(uint8_t dev_id, 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; TEST_HEXDUMP(stdout, "key:", key, key_len); /* Create Crypto session */ - ut_params->sess = rte_cryptodev_sym_session_create(dev_id, - &ut_params-> - cipher_xform); + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); + + rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->cipher_xform, ts_params->session_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; } 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, @@ -1862,35 +2136,20 @@ 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; - - rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); + 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 -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, @@ -1908,24 +2167,8 @@ 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; - - rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); + 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; @@ -1937,12 +2180,14 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id, 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, - const uint8_t aad_len, const uint8_t auth_len) + const uint8_t *key, uint8_t key_len, + uint8_t auth_iv_len, uint8_t auth_len, + uint8_t cipher_iv_len) { uint8_t cipher_auth_key[key_len]; + struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; memcpy(cipher_auth_key, key, key_len); @@ -1957,7 +2202,9 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id, /* 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; + /* 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; /* Setup Cipher Parameters */ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; @@ -1967,12 +2214,17 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id, 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; TEST_HEXDUMP(stdout, "key:", key, key_len); /* Create Crypto session*/ - ut_params->sess = rte_cryptodev_sym_session_create(dev_id, - &ut_params->cipher_xform); + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); + + rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->cipher_xform, ts_params->session_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; @@ -1989,10 +2241,12 @@ create_wireless_cipher_auth_session(uint8_t dev_id, const uint8_t key_len = tdata->key.len; uint8_t cipher_auth_key[key_len]; + 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 aad_len = tdata->aad.len; 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); @@ -2006,7 +2260,9 @@ create_wireless_cipher_auth_session(uint8_t dev_id, /* 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; + /* 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; /* Setup Cipher Parameters */ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; @@ -2016,12 +2272,18 @@ create_wireless_cipher_auth_session(uint8_t dev_id, 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; + TEST_HEXDUMP(stdout, "key:", key, key_len); /* Create Crypto session*/ - ut_params->sess = rte_cryptodev_sym_session_create(dev_id, - &ut_params->cipher_xform); + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); + + rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->cipher_xform, ts_params->session_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; @@ -2044,10 +2306,12 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id, enum rte_crypto_auth_algorithm auth_algo, enum rte_crypto_cipher_algorithm cipher_algo, const uint8_t *key, const uint8_t key_len, - const uint8_t aad_len, const uint8_t auth_len) + uint8_t auth_iv_len, uint8_t auth_len, + uint8_t cipher_iv_len) { uint8_t auth_cipher_key[key_len]; + struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; memcpy(auth_cipher_key, key, key_len); @@ -2060,7 +2324,9 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id, 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; - ut_params->auth_xform.auth.add_auth_data_length = aad_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; /* Setup Cipher Parameters */ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; @@ -2069,12 +2335,17 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id, 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; TEST_HEXDUMP(stdout, "key:", key, key_len); /* Create Crypto session*/ - ut_params->sess = rte_cryptodev_sym_session_create(dev_id, - &ut_params->auth_xform); + 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_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); @@ -2083,19 +2354,16 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id, static int create_wireless_algo_hash_operation(const uint8_t *auth_tag, - const unsigned auth_tag_len, - const uint8_t *aad, const unsigned aad_len, - unsigned data_pad_len, + unsigned int auth_tag_len, + const uint8_t *iv, unsigned int iv_len, + unsigned int data_pad_len, enum rte_crypto_auth_operation op, - enum rte_crypto_auth_algorithm algo, - const unsigned auth_len, const unsigned auth_offset) + unsigned int auth_len, unsigned int auth_offset) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - unsigned aad_buffer_len; - /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); @@ -2110,32 +2378,9 @@ create_wireless_algo_hash_operation(const uint8_t *auth_tag, /* set crypto operation source mbuf */ sym_op->m_src = ut_params->ibuf; - /* 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 (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 */ + 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); @@ -2143,9 +2388,8 @@ create_wireless_algo_hash_operation(const uint8_t *auth_tag, TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, "no room to append auth tag"); ut_params->digest = sym_op->auth.digest.data; - sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( - ut_params->ibuf, data_pad_len + aad_len); - sym_op->auth.digest.length = auth_tag_len; + 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 @@ -2153,7 +2397,7 @@ create_wireless_algo_hash_operation(const uint8_t *auth_tag, TEST_HEXDUMP(stdout, "digest:", sym_op->auth.digest.data, - sym_op->auth.digest.length); + auth_tag_len); sym_op->auth.data.length = auth_len; sym_op->auth.data.offset = auth_offset; @@ -2163,30 +2407,22 @@ create_wireless_algo_hash_operation(const uint8_t *auth_tag, 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, - enum rte_crypto_cipher_algorithm cipher_algo) + enum rte_crypto_auth_operation op) { 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 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 cipher_offset = - tdata->validCipherOffsetLenInBits.len; const unsigned int auth_len = tdata->validAuthLenInBits.len; - const unsigned int auth_offset = tdata->validAuthOffsetLenInBits.len; - - unsigned int iv_pad_len = 0; - unsigned int aad_buffer_len; /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, @@ -2208,9 +2444,8 @@ create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata, 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( + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_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 @@ -2218,49 +2453,19 @@ create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata, TEST_HEXDUMP(stdout, "digest:", sym_op->auth.digest.data, - sym_op->auth.digest.length); + auth_tag_len); - /* 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); + /* 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); - /* 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; - 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->cipher.data.offset = 0; sym_op->auth.data.length = auth_len; - sym_op->auth.data.offset = auth_offset + cipher_offset; + sym_op->auth.data.offset = 0; return 0; } @@ -2270,29 +2475,22 @@ 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, - RTE_CRYPTO_CIPHER_ZUC_EEA3); + RTE_CRYPTO_AUTH_OP_GENERATE); } static int create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, const unsigned auth_tag_len, - const uint8_t *aad, const uint8_t aad_len, + const uint8_t *auth_iv, uint8_t auth_iv_len, 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 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; struct crypto_unittest_params *ut_params = &unittest_params; - unsigned iv_pad_len = 0; - unsigned aad_buffer_len; - /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); @@ -2313,9 +2511,8 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, "no room to append auth tag"); ut_params->digest = sym_op->auth.digest.data; - sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_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 @@ -2323,69 +2520,34 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, TEST_HEXDUMP(stdout, "digest:", sym_op->auth.digest.data, - sym_op->auth.digest.length); + auth_tag_len); - /* 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); + /* 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); - /* 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; - 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->cipher.data.offset = cipher_offset; sym_op->auth.data.length = auth_len; - sym_op->auth.data.offset = auth_offset + cipher_offset; + sym_op->auth.data.offset = auth_offset; return 0; } static int -create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len, - const uint8_t *iv, const uint8_t iv_len, - const uint8_t *aad, const uint8_t aad_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) +create_wireless_algo_auth_cipher_operation(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) { 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 */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); @@ -2407,61 +2569,27 @@ create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len, TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, "no room to append auth tag"); - sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( ut_params->ibuf, data_pad_len); - sym_op->auth.digest.length = auth_tag_len; memset(sym_op->auth.digest.data, 0, 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 16 bytes). - */ - 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 */ - 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); + auth_tag_len); - 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; - - rte_memcpy(sym_op->cipher.iv.data, iv, iv_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); + rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len); + iv_ptr += cipher_iv_len; + rte_memcpy(iv_ptr, auth_iv, auth_iv_len); sym_op->cipher.data.length = cipher_len; - sym_op->cipher.data.offset = auth_offset + cipher_offset; + sym_op->cipher.data.offset = cipher_offset; sym_op->auth.data.length = auth_len; - sym_op->auth.data.offset = auth_offset + cipher_offset; + sym_op->auth.data.offset = auth_offset; return 0; } @@ -2480,7 +2608,7 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) /* Create SNOW 3G session */ retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->digest.len, + tdata->auth_iv.len, tdata->digest.len, RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_SNOW3G_UIA2); if (retval < 0) @@ -2502,11 +2630,10 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) /* Create SNOW 3G operation */ retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, - tdata->aad.data, tdata->aad.len, + tdata->auth_iv.data, tdata->auth_iv.len, plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, - RTE_CRYPTO_AUTH_SNOW3G_UIA2, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len); + 0); if (retval < 0) return retval; @@ -2515,7 +2642,7 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) 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 + tdata->aad.len; + + plaintext_pad_len; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -2541,7 +2668,7 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) /* Create SNOW 3G session */ retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->digest.len, + tdata->auth_iv.len, tdata->digest.len, RTE_CRYPTO_AUTH_OP_VERIFY, RTE_CRYPTO_AUTH_SNOW3G_UIA2); if (retval < 0) @@ -2563,12 +2690,11 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) /* Create SNOW 3G operation */ retval = create_wireless_algo_hash_operation(tdata->digest.data, tdata->digest.len, - tdata->aad.data, tdata->aad.len, + tdata->auth_iv.data, tdata->auth_iv.len, plaintext_pad_len, RTE_CRYPTO_AUTH_OP_VERIFY, - RTE_CRYPTO_AUTH_SNOW3G_UIA2, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len); + 0); if (retval < 0) return retval; @@ -2577,7 +2703,7 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) 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 + tdata->aad.len; + + plaintext_pad_len; /* Validate obuf */ if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) @@ -2602,7 +2728,7 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) /* Create KASUMI session */ retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->digest.len, + 0, tdata->digest.len, RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_KASUMI_F9); if (retval < 0) @@ -2624,11 +2750,10 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) /* Create KASUMI operation */ retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, - tdata->aad.data, tdata->aad.len, + NULL, 0, plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, - RTE_CRYPTO_AUTH_KASUMI_F9, - tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len); + tdata->plaintext.len, + 0); if (retval < 0) return retval; @@ -2637,7 +2762,7 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) 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 + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8); + + plaintext_pad_len; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -2663,7 +2788,7 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) /* Create KASUMI session */ retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->digest.len, + 0, tdata->digest.len, RTE_CRYPTO_AUTH_OP_VERIFY, RTE_CRYPTO_AUTH_KASUMI_F9); if (retval < 0) @@ -2685,12 +2810,11 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) /* Create KASUMI operation */ retval = create_wireless_algo_hash_operation(tdata->digest.data, tdata->digest.len, - tdata->aad.data, tdata->aad.len, + NULL, 0, plaintext_pad_len, RTE_CRYPTO_AUTH_OP_VERIFY, - RTE_CRYPTO_AUTH_KASUMI_F9, - tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len); + tdata->plaintext.len, + 0); if (retval < 0) return retval; @@ -2699,7 +2823,7 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) 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 + tdata->aad.len; + + plaintext_pad_len; /* Validate obuf */ if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) @@ -2864,7 +2988,8 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -2885,10 +3010,10 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata) TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); /* 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); + 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; @@ -2898,17 +3023,18 @@ 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; + ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3); TEST_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, - tdata->ciphertext.data, + reference_ciphertext, tdata->validCipherLenInBits.len, "KASUMI Ciphertext data not as expected"); return 0; @@ -2941,7 +3067,8 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -2958,11 +3085,10 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); /* 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); + 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; @@ -2973,22 +3099,25 @@ 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, + tdata->validCipherOffsetInBits.len >> 3, plaintext_len, buffer); /* Validate obuf */ TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); - /* Validate obuf */ - TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( - ciphertext, - tdata->ciphertext.data, - tdata->validCipherLenInBits.len, - "KASUMI Ciphertext data not as expected"); - return 0; + 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 @@ -3006,7 +3135,8 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -3029,11 +3159,10 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata) TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); /* Create KASUMI operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, - tdata->iv.len, - tdata->plaintext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_KASUMI_F8); + 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; @@ -3043,17 +3172,18 @@ 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; + ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3); TEST_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, - tdata->ciphertext.data, + reference_ciphertext, tdata->validCipherLenInBits.len, "KASUMI Ciphertext data not as expected"); return 0; @@ -3085,7 +3215,8 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -3104,11 +3235,10 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata) pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); /* Create KASUMI operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, - tdata->iv.len, - tdata->plaintext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_KASUMI_F8); + 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; @@ -3118,16 +3248,19 @@ 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, + 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, - tdata->ciphertext.data, + reference_ciphertext, tdata->validCipherLenInBits.len, "KASUMI Ciphertext data not as expected"); return 0; @@ -3149,7 +3282,8 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -3172,11 +3306,10 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata) TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); /* Create KASUMI operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, - tdata->iv.len, - tdata->ciphertext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_KASUMI_F8); + 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; @@ -3186,17 +3319,18 @@ 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; + plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3); TEST_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, - tdata->plaintext.data, + reference_plaintext, tdata->validCipherLenInBits.len, "KASUMI Plaintext data not as expected"); return 0; @@ -3217,7 +3351,8 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -3238,11 +3373,10 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata) TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); /* Create KASUMI operation */ - retval = create_wireless_algo_cipher_operation(tdata->iv.data, - tdata->iv.len, + retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, + tdata->cipher_iv.len, tdata->ciphertext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_KASUMI_F8); + tdata->validCipherOffsetInBits.len); if (retval < 0) return retval; @@ -3252,17 +3386,18 @@ 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; + plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3); TEST_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, - tdata->plaintext.data, + reference_plaintext, tdata->validCipherLenInBits.len, "KASUMI Plaintext data not as expected"); return 0; @@ -3283,7 +3418,8 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -3304,10 +3440,10 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata) TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, + retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, + tdata->cipher_iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + 0); if (retval < 0) return retval; @@ -3317,8 +3453,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; @@ -3349,7 +3484,8 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -3377,11 +3513,10 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, - tdata->iv.len, + retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + tdata->cipher_iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + 0); if (retval < 0) return retval; @@ -3391,8 +3526,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; @@ -3432,7 +3566,8 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -3454,11 +3589,10 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, - tdata->iv.len, + retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + tdata->cipher_iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + 0); if (retval < 0) return retval; @@ -3468,10 +3602,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); @@ -3522,7 +3656,8 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -3557,12 +3692,10 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); #endif /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, - tdata->iv.len, + retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + tdata->cipher_iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len + - extra_offset, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + extra_offset); if (retval < 0) return retval; @@ -3572,8 +3705,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; @@ -3581,8 +3713,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"); @@ -3616,7 +3747,8 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -3637,10 +3769,10 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, + retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, + tdata->cipher_iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + 0); if (retval < 0) return retval; @@ -3649,8 +3781,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; @@ -3679,7 +3810,8 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) 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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -3710,11 +3842,10 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); /* Create SNOW 3G operation */ - retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, - tdata->iv.len, + retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, + tdata->cipher_iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_SNOW3G_UEA2); + 0); if (retval < 0) return retval; @@ -3723,8 +3854,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; @@ -3800,8 +3930,7 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata) 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->iv.len + tdata->aad.len; + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else ciphertext = plaintext; @@ -3814,7 +3943,7 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata) "ZUC 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; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -3844,7 +3973,8 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) RTE_CRYPTO_AUTH_SNOW3G_UIA2, RTE_CRYPTO_CIPHER_SNOW3G_UEA2, tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->digest.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); @@ -3865,16 +3995,14 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) /* Create SNOW 3G operation */ retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data, - tdata->digest.len, tdata->aad.data, - tdata->aad.len, /*tdata->plaintext.len,*/ + tdata->digest.len, tdata->auth_iv.data, + tdata->auth_iv.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->cipher_iv.data, tdata->cipher_iv.len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, + 0, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len + 0 ); if (retval < 0) return retval; @@ -3884,8 +4012,7 @@ test_snow3g_cipher_auth(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_src; if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len + tdata->aad.len; + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); else ciphertext = plaintext; @@ -3898,7 +4025,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; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -3927,7 +4054,8 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata) RTE_CRYPTO_AUTH_SNOW3G_UIA2, RTE_CRYPTO_CIPHER_SNOW3G_UEA2, tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->digest.len); + tdata->auth_iv.len, tdata->digest.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -3950,16 +4078,13 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata) /* Create SNOW 3G operation */ retval = create_wireless_algo_auth_cipher_operation( tdata->digest.len, - tdata->iv.data, tdata->iv.len, - tdata->aad.data, tdata->aad.len, + tdata->cipher_iv.data, tdata->cipher_iv.len, + tdata->auth_iv.data, tdata->auth_iv.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 - ); + 0); if (retval < 0) return retval; @@ -3969,13 +4094,12 @@ test_snow3g_auth_cipher(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_src; if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->aad.len + tdata->iv.len; + ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 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; TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); /* Validate obuf */ @@ -4014,7 +4138,8 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata) RTE_CRYPTO_AUTH_KASUMI_F9, RTE_CRYPTO_CIPHER_KASUMI_F8, tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->digest.len); + 0, tdata->digest.len, + tdata->cipher_iv.len); if (retval < 0) return retval; ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); @@ -4035,15 +4160,13 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata) /* Create KASUMI operation */ retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len, - tdata->iv.data, tdata->iv.len, - tdata->aad.data, tdata->aad.len, + tdata->cipher_iv.data, tdata->cipher_iv.len, + NULL, 0, plaintext_pad_len, tdata->validCipherLenInBits.len, - tdata->validCipherOffsetLenInBits.len, + tdata->validCipherOffsetInBits.len, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len, - RTE_CRYPTO_AUTH_KASUMI_F9, - RTE_CRYPTO_CIPHER_KASUMI_F8 + 0 ); if (retval < 0) @@ -4052,21 +4175,24 @@ test_kasumi_auth_cipher(const struct kasumi_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_src; - if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->iv.len + tdata->aad.len; + if (ut_params->op->sym->m_dst) + ut_params->obuf = ut_params->op->sym->m_dst; else - ciphertext = plaintext; + ut_params->obuf = ut_params->op->sym->m_src; + + ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, + tdata->validCipherOffsetInBits.len >> 3); + const uint8_t *reference_ciphertext = tdata->ciphertext.data + + (tdata->validCipherOffsetInBits.len >> 3); /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( ciphertext, - tdata->ciphertext.data, + reference_ciphertext, 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; + ut_params->digest = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *) + + plaintext_pad_len; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -4097,7 +4223,8 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) RTE_CRYPTO_AUTH_KASUMI_F9, RTE_CRYPTO_CIPHER_KASUMI_F8, tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->digest.len); + 0, tdata->digest.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -4119,16 +4246,13 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) /* Create KASUMI operation */ retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data, - tdata->digest.len, tdata->aad.data, - tdata->aad.len, + tdata->digest.len, NULL, 0, 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, + tdata->cipher_iv.data, tdata->cipher_iv.len, + RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), + tdata->validCipherOffsetInBits.len, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len + 0 ); if (retval < 0) return retval; @@ -4136,20 +4260,24 @@ test_kasumi_cipher_auth(const struct kasumi_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_src; - if (ut_params->obuf) - ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) - + tdata->aad.len + tdata->iv.len; + + if (ut_params->op->sym->m_dst) + ut_params->obuf = ut_params->op->sym->m_dst; else - ciphertext = plaintext; + ut_params->obuf = ut_params->op->sym->m_src; + + 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 + tdata->aad.len + tdata->iv.len; + + plaintext_pad_len; + const uint8_t *reference_ciphertext = tdata->ciphertext.data + + (tdata->validCipherOffsetInBits.len >> 3); /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( ciphertext, - tdata->ciphertext.data, + reference_ciphertext, tdata->validCipherLenInBits.len, "KASUMI Ciphertext data not as expected"); @@ -4187,7 +4315,8 @@ test_zuc_encryption(const struct wireless_test_data *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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -4208,10 +4337,10 @@ test_zuc_encryption(const struct wireless_test_data *tdata) TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); /* Create ZUC operation */ - retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, + retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, + tdata->cipher_iv.len, tdata->plaintext.len, - tdata->validCipherOffsetLenInBits.len, - RTE_CRYPTO_CIPHER_ZUC_EEA3); + 0); if (retval < 0) return retval; @@ -4221,8 +4350,7 @@ test_zuc_encryption(const struct wireless_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; @@ -4284,7 +4412,8 @@ test_zuc_encryption_sgl(const struct wireless_test_data *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->key.data, tdata->key.len, + tdata->cipher_iv.len); if (retval < 0) return retval; @@ -4293,10 +4422,9 @@ test_zuc_encryption_sgl(const struct wireless_test_data *tdata) pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); /* 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); + retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, + tdata->cipher_iv.len, tdata->plaintext.len, + 0); if (retval < 0) return retval; @@ -4307,10 +4435,10 @@ test_zuc_encryption_sgl(const struct wireless_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); @@ -4349,7 +4477,7 @@ test_zuc_authentication(const struct wireless_test_data *tdata) /* Create ZUC session */ retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->digest.len, + tdata->auth_iv.len, tdata->digest.len, RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3); if (retval < 0) @@ -4371,11 +4499,10 @@ test_zuc_authentication(const struct wireless_test_data *tdata) /* Create ZUC operation */ retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, - tdata->aad.data, tdata->aad.len, + tdata->auth_iv.data, tdata->auth_iv.len, plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, - RTE_CRYPTO_AUTH_ZUC_EIA3, tdata->validAuthLenInBits.len, - tdata->validAuthOffsetLenInBits.len); + 0); if (retval < 0) return retval; @@ -4384,7 +4511,7 @@ test_zuc_authentication(const struct wireless_test_data *tdata) 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 + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8); + + plaintext_pad_len; /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL( @@ -4690,8 +4817,11 @@ test_3DES_chain_qat_all(void) 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, + ts_params->op_mpool, + ts_params->session_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"); @@ -4706,8 +4836,30 @@ test_DES_cipheronly_qat_all(void) 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, + ts_params->op_mpool, + ts_params->session_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; +} + +static int +test_DES_cipheronly_openssl_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->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"); @@ -4722,8 +4874,49 @@ test_DES_docsis_openssl_all(void) int status; status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->valid_devs[0], - RTE_CRYPTODEV_OPENSSL_PMD, + ts_params->op_mpool, + ts_params->session_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; +} + +static int +test_DES_cipheronly_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->session_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; +} + +static int +test_DES_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->session_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"); @@ -4731,6 +4924,44 @@ test_DES_docsis_openssl_all(void) return TEST_SUCCESS; } +static int +test_3DES_chain_dpaa_sec_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)), + BLKCIPHER_3DES_CHAIN_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_3DES_cipheronly_dpaa_sec_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)), + BLKCIPHER_3DES_CIPHERONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + static int test_3DES_chain_dpaa2_sec_all(void) { @@ -4738,8 +4969,11 @@ test_3DES_chain_dpaa2_sec_all(void) 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, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)), BLKCIPHER_3DES_CHAIN_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -4754,8 +4988,11 @@ test_3DES_cipheronly_dpaa2_sec_all(void) 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, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)), BLKCIPHER_3DES_CIPHERONLY_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -4770,8 +5007,11 @@ test_3DES_cipheronly_qat_all(void) 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, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)), BLKCIPHER_3DES_CIPHERONLY_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -4786,8 +5026,11 @@ test_3DES_chain_openssl_all(void) int status; status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->valid_devs[0], - RTE_CRYPTODEV_OPENSSL_PMD, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)), BLKCIPHER_3DES_CHAIN_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -4802,8 +5045,11 @@ test_3DES_cipheronly_openssl_all(void) int status; status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, ts_params->valid_devs[0], - RTE_CRYPTODEV_OPENSSL_PMD, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)), BLKCIPHER_3DES_CIPHERONLY_TYPE); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -4811,54 +5057,42 @@ test_3DES_cipheronly_openssl_all(void) return TEST_SUCCESS; } -/* ***** AES-GCM Tests ***** */ +/* ***** AEAD algorithm Tests ***** */ static int -create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op, +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 uint8_t aad_len, const uint8_t auth_len, - enum rte_crypto_auth_operation auth_op) + const uint16_t aad_len, const uint8_t auth_len, + uint8_t iv_len) { - uint8_t cipher_key[key_len]; + uint8_t aead_key[key_len]; + struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - memcpy(cipher_key, key, key_len); - - /* Setup Cipher Parameters */ - ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - ut_params->cipher_xform.next = NULL; + memcpy(aead_key, key, key_len); - ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM; - ut_params->auth_xform.auth.op = auth_op; - 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; + /* 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; TEST_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.algo = RTE_CRYPTO_AUTH_AES_GCM; - - ut_params->auth_xform.auth.digest_length = auth_len; - ut_params->auth_xform.auth.add_auth_data_length = aad_len; - ut_params->auth_xform.auth.key.length = 0; - ut_params->auth_xform.auth.key.data = NULL; - - if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) { - ut_params->cipher_xform.next = &ut_params->auth_xform; + /* Create Crypto session*/ + ut_params->sess = rte_cryptodev_sym_session_create( + ts_params->session_mpool); - /* Create Crypto session*/ - ut_params->sess = rte_cryptodev_sym_session_create(dev_id, - &ut_params->cipher_xform); - } else {/* Create Crypto session*/ - ut_params->auth_xform.next = &ut_params->cipher_xform; - ut_params->sess = rte_cryptodev_sym_session_create(dev_id, - &ut_params->auth_xform); - } + rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + &ut_params->aead_xform, ts_params->session_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); @@ -4866,48 +5100,44 @@ create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op, } static int -create_gcm_xforms(struct rte_crypto_op *op, - enum rte_crypto_cipher_operation cipher_op, +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, - enum rte_crypto_auth_operation auth_op) + uint8_t iv_len) { - TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 2), - "failed to allocate space for crypto transforms"); + TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1), + "failed to allocate space for crypto transform"); struct rte_crypto_sym_op *sym_op = op->sym; - /* Setup Cipher Parameters */ - sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER; - sym_op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM; - sym_op->xform->cipher.op = cipher_op; - sym_op->xform->cipher.key.data = key; - sym_op->xform->cipher.key.length = key_len; + /* 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; TEST_HEXDUMP(stdout, "key:", key, key_len); - /* Setup Authentication Parameters */ - sym_op->xform->next->type = RTE_CRYPTO_SYM_XFORM_AUTH; - sym_op->xform->next->auth.algo = RTE_CRYPTO_AUTH_AES_GCM; - sym_op->xform->next->auth.op = auth_op; - sym_op->xform->next->auth.digest_length = auth_len; - sym_op->xform->next->auth.add_auth_data_length = aad_len; - sym_op->xform->next->auth.key.length = 0; - sym_op->xform->next->auth.key.data = NULL; - sym_op->xform->next->next = NULL; - return 0; } static int -create_gcm_operation(enum rte_crypto_cipher_operation op, - const struct gcm_test_data *tdata) +create_aead_operation(enum rte_crypto_aead_operation op, + 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, *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, @@ -4918,35 +5148,52 @@ create_gcm_operation(enum rte_crypto_cipher_operation op, struct rte_crypto_sym_op *sym_op = ut_params->op->sym; /* Append aad data */ - aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); - sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - aad_pad_len); - TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, - "no room to append aad"); - - sym_op->auth.aad.length = tdata->aad.len; - sym_op->auth.aad.phys_addr = - rte_pktmbuf_mtophys(ut_params->ibuf); - memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len); - 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); - 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, - sym_op->cipher.iv.length); + 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); + TEST_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); + TEST_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); + TEST_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); + + rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); + TEST_HEXDUMP(stdout, "iv:", iv_ptr, + tdata->iv.len); + } /* Append plaintext/ciphertext */ - if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) { + 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); @@ -4959,12 +5206,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 { @@ -4982,59 +5228,53 @@ 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); } } /* Append digest data */ - if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) { - sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + 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->auth.digest.data, + TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, "no room to append digest"); - memset(sym_op->auth.digest.data, 0, tdata->auth_tag.len); - sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + 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 + iv_pad_len); - sym_op->auth.digest.length = tdata->auth_tag.len; + aad_pad_len); } else { - sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( + sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append( ut_params->ibuf, tdata->auth_tag.len); - TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, "no room to append digest"); - sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset( ut_params->ibuf, - plaintext_pad_len + aad_pad_len + iv_pad_len); - sym_op->auth.digest.length = tdata->auth_tag.len; + plaintext_pad_len + aad_pad_len); - rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data, + rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data, tdata->auth_tag.len); TEST_HEXDUMP(stdout, "digest:", - sym_op->auth.digest.data, - sym_op->auth.digest.length); + sym_op->aead.digest.data, + tdata->auth_tag.len); } - sym_op->cipher.data.length = tdata->plaintext.len; - sym_op->cipher.data.offset = aad_pad_len + iv_pad_len; - - sym_op->auth.data.length = tdata->plaintext.len; - sym_op->auth.data.offset = aad_pad_len + iv_pad_len; + sym_op->aead.data.length = tdata->plaintext.len; + sym_op->aead.data.offset = aad_pad_len; return 0; } static int -test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata) +test_authenticated_encryption(const struct aead_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -5044,19 +5284,20 @@ test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata) uint16_t plaintext_pad_len; uint32_t i; - /* Create GCM session */ - retval = create_gcm_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, + /* 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, - RTE_CRYPTO_AUTH_OP_GENERATE); + tdata->iv.len); 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 < GCM_MAX_AAD_LENGTH; i += 32) + 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); @@ -5065,8 +5306,8 @@ test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata) memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->ibuf)); - /* Create GCM operation */ - retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata); + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); if (retval < 0) return retval; @@ -5103,116 +5344,158 @@ test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata) ciphertext, tdata->ciphertext.data, tdata->ciphertext.len, - "GCM Ciphertext data not as expected"); + "Ciphertext data not as expected"); TEST_ASSERT_BUFFERS_ARE_EQUAL( auth_tag, tdata->auth_tag.data, tdata->auth_tag.len, - "GCM Generated auth tag not as expected"); + "Generated auth tag not as expected"); return 0; } static int -test_mb_AES_GCM_authenticated_encryption_test_case_1(void) +test_AES_GCM_authenticated_encryption_test_case_1(void) +{ + return test_authenticated_encryption(&gcm_test_case_1); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_2(void) +{ + return test_authenticated_encryption(&gcm_test_case_2); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_3(void) +{ + return test_authenticated_encryption(&gcm_test_case_3); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_4(void) +{ + return test_authenticated_encryption(&gcm_test_case_4); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_5(void) +{ + return test_authenticated_encryption(&gcm_test_case_5); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_6(void) +{ + return test_authenticated_encryption(&gcm_test_case_6); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_7(void) +{ + return test_authenticated_encryption(&gcm_test_case_7); +} + +static int +test_AES_GCM_auth_encryption_test_case_192_1(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1); + return test_authenticated_encryption(&gcm_test_case_192_1); } static int -test_mb_AES_GCM_authenticated_encryption_test_case_2(void) +test_AES_GCM_auth_encryption_test_case_192_2(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2); + return test_authenticated_encryption(&gcm_test_case_192_2); } static int -test_mb_AES_GCM_authenticated_encryption_test_case_3(void) +test_AES_GCM_auth_encryption_test_case_192_3(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3); + return test_authenticated_encryption(&gcm_test_case_192_3); } static int -test_mb_AES_GCM_authenticated_encryption_test_case_4(void) +test_AES_GCM_auth_encryption_test_case_192_4(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4); + return test_authenticated_encryption(&gcm_test_case_192_4); } static int -test_mb_AES_GCM_authenticated_encryption_test_case_5(void) +test_AES_GCM_auth_encryption_test_case_192_5(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5); + return test_authenticated_encryption(&gcm_test_case_192_5); } static int -test_mb_AES_GCM_authenticated_encryption_test_case_6(void) +test_AES_GCM_auth_encryption_test_case_192_6(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6); + return test_authenticated_encryption(&gcm_test_case_192_6); } static int -test_mb_AES_GCM_authenticated_encryption_test_case_7(void) +test_AES_GCM_auth_encryption_test_case_192_7(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7); + return test_authenticated_encryption(&gcm_test_case_192_7); } static int -test_mb_AES_GCM_auth_encryption_test_case_256_1(void) +test_AES_GCM_auth_encryption_test_case_256_1(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_1); + return test_authenticated_encryption(&gcm_test_case_256_1); } static int -test_mb_AES_GCM_auth_encryption_test_case_256_2(void) +test_AES_GCM_auth_encryption_test_case_256_2(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_2); + return test_authenticated_encryption(&gcm_test_case_256_2); } static int -test_mb_AES_GCM_auth_encryption_test_case_256_3(void) +test_AES_GCM_auth_encryption_test_case_256_3(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_3); + return test_authenticated_encryption(&gcm_test_case_256_3); } static int -test_mb_AES_GCM_auth_encryption_test_case_256_4(void) +test_AES_GCM_auth_encryption_test_case_256_4(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_4); + return test_authenticated_encryption(&gcm_test_case_256_4); } static int -test_mb_AES_GCM_auth_encryption_test_case_256_5(void) +test_AES_GCM_auth_encryption_test_case_256_5(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_5); + return test_authenticated_encryption(&gcm_test_case_256_5); } static int -test_mb_AES_GCM_auth_encryption_test_case_256_6(void) +test_AES_GCM_auth_encryption_test_case_256_6(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_6); + return test_authenticated_encryption(&gcm_test_case_256_6); } static int -test_mb_AES_GCM_auth_encryption_test_case_256_7(void) +test_AES_GCM_auth_encryption_test_case_256_7(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_7); + return test_authenticated_encryption(&gcm_test_case_256_7); } static int -test_mb_AES_GCM_auth_encryption_test_case_aad_1(void) +test_AES_GCM_auth_encryption_test_case_aad_1(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_1); + return test_authenticated_encryption(&gcm_test_case_aad_1); } static int -test_mb_AES_GCM_auth_encryption_test_case_aad_2(void) +test_AES_GCM_auth_encryption_test_case_aad_2(void) { - return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_2); + return test_authenticated_encryption(&gcm_test_case_aad_2); } static int -test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata) +test_authenticated_decryption(const struct aead_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -5221,12 +5504,13 @@ test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata) uint8_t *plaintext; uint32_t i; - /* Create GCM session */ - retval = create_gcm_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_DECRYPT, + /* 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, - RTE_CRYPTO_AUTH_OP_VERIFY); + tdata->iv.len); if (retval < 0) return retval; @@ -5234,7 +5518,7 @@ test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata) 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 < GCM_MAX_AAD_LENGTH; i += 32) + 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); @@ -5242,8 +5526,8 @@ test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata) memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->ibuf)); - /* Create GCM operation */ - retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata); + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); if (retval < 0) return retval; @@ -5273,112 +5557,154 @@ test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata) plaintext, tdata->plaintext.data, tdata->plaintext.len, - "GCM plaintext data not as expected"); + "Plaintext data not as expected"); TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "GCM authentication failed"); + "Authentication failed"); return 0; } static int -test_mb_AES_GCM_authenticated_decryption_test_case_1(void) +test_AES_GCM_authenticated_decryption_test_case_1(void) +{ + return test_authenticated_decryption(&gcm_test_case_1); +} + +static int +test_AES_GCM_authenticated_decryption_test_case_2(void) +{ + return test_authenticated_decryption(&gcm_test_case_2); +} + +static int +test_AES_GCM_authenticated_decryption_test_case_3(void) +{ + return test_authenticated_decryption(&gcm_test_case_3); +} + +static int +test_AES_GCM_authenticated_decryption_test_case_4(void) +{ + return test_authenticated_decryption(&gcm_test_case_4); +} + +static int +test_AES_GCM_authenticated_decryption_test_case_5(void) +{ + return test_authenticated_decryption(&gcm_test_case_5); +} + +static int +test_AES_GCM_authenticated_decryption_test_case_6(void) +{ + return test_authenticated_decryption(&gcm_test_case_6); +} + +static int +test_AES_GCM_authenticated_decryption_test_case_7(void) +{ + return test_authenticated_decryption(&gcm_test_case_7); +} + +static int +test_AES_GCM_auth_decryption_test_case_192_1(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1); + return test_authenticated_decryption(&gcm_test_case_192_1); } static int -test_mb_AES_GCM_authenticated_decryption_test_case_2(void) +test_AES_GCM_auth_decryption_test_case_192_2(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2); + return test_authenticated_decryption(&gcm_test_case_192_2); } static int -test_mb_AES_GCM_authenticated_decryption_test_case_3(void) +test_AES_GCM_auth_decryption_test_case_192_3(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3); + return test_authenticated_decryption(&gcm_test_case_192_3); } static int -test_mb_AES_GCM_authenticated_decryption_test_case_4(void) +test_AES_GCM_auth_decryption_test_case_192_4(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4); + return test_authenticated_decryption(&gcm_test_case_192_4); } static int -test_mb_AES_GCM_authenticated_decryption_test_case_5(void) +test_AES_GCM_auth_decryption_test_case_192_5(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5); + return test_authenticated_decryption(&gcm_test_case_192_5); } static int -test_mb_AES_GCM_authenticated_decryption_test_case_6(void) +test_AES_GCM_auth_decryption_test_case_192_6(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6); + return test_authenticated_decryption(&gcm_test_case_192_6); } static int -test_mb_AES_GCM_authenticated_decryption_test_case_7(void) +test_AES_GCM_auth_decryption_test_case_192_7(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7); + return test_authenticated_decryption(&gcm_test_case_192_7); } static int -test_mb_AES_GCM_auth_decryption_test_case_256_1(void) +test_AES_GCM_auth_decryption_test_case_256_1(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_1); + return test_authenticated_decryption(&gcm_test_case_256_1); } static int -test_mb_AES_GCM_auth_decryption_test_case_256_2(void) +test_AES_GCM_auth_decryption_test_case_256_2(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_2); + return test_authenticated_decryption(&gcm_test_case_256_2); } static int -test_mb_AES_GCM_auth_decryption_test_case_256_3(void) +test_AES_GCM_auth_decryption_test_case_256_3(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_3); + return test_authenticated_decryption(&gcm_test_case_256_3); } static int -test_mb_AES_GCM_auth_decryption_test_case_256_4(void) +test_AES_GCM_auth_decryption_test_case_256_4(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_4); + return test_authenticated_decryption(&gcm_test_case_256_4); } static int -test_mb_AES_GCM_auth_decryption_test_case_256_5(void) +test_AES_GCM_auth_decryption_test_case_256_5(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_5); + return test_authenticated_decryption(&gcm_test_case_256_5); } static int -test_mb_AES_GCM_auth_decryption_test_case_256_6(void) +test_AES_GCM_auth_decryption_test_case_256_6(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_6); + return test_authenticated_decryption(&gcm_test_case_256_6); } static int -test_mb_AES_GCM_auth_decryption_test_case_256_7(void) +test_AES_GCM_auth_decryption_test_case_256_7(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_7); + return test_authenticated_decryption(&gcm_test_case_256_7); } static int -test_mb_AES_GCM_auth_decryption_test_case_aad_1(void) +test_AES_GCM_auth_decryption_test_case_aad_1(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_1); + return test_authenticated_decryption(&gcm_test_case_aad_1); } static int -test_mb_AES_GCM_auth_decryption_test_case_aad_2(void) +test_AES_GCM_auth_decryption_test_case_aad_2(void) { - return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_2); + return test_authenticated_decryption(&gcm_test_case_aad_2); } static int -test_AES_GCM_authenticated_encryption_oop(const struct gcm_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; @@ -5387,12 +5713,13 @@ test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata) uint8_t *ciphertext, *auth_tag; uint16_t plaintext_pad_len; - /* Create GCM session */ - retval = create_gcm_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, + /* 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, - RTE_CRYPTO_AUTH_OP_GENERATE); + tdata->iv.len); if (retval < 0) return retval; @@ -5405,8 +5732,8 @@ test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata) memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->obuf)); - /* Create GCM operation */ - retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata); + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); if (retval < 0) return retval; @@ -5436,26 +5763,26 @@ test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata) ciphertext, tdata->ciphertext.data, tdata->ciphertext.len, - "GCM Ciphertext data not as expected"); + "Ciphertext data not as expected"); TEST_ASSERT_BUFFERS_ARE_EQUAL( auth_tag, tdata->auth_tag.data, tdata->auth_tag.len, - "GCM Generated auth tag not as expected"); + "Generated auth tag not as expected"); return 0; } static int -test_mb_AES_GCM_authenticated_encryption_oop(void) +test_AES_GCM_authenticated_encryption_oop_test_case_1(void) { - return test_AES_GCM_authenticated_encryption_oop(&gcm_test_case_5); + return test_authenticated_encryption_oop(&gcm_test_case_5); } static int -test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata) +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; @@ -5463,12 +5790,13 @@ test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata) int retval; uint8_t *plaintext; - /* Create GCM session */ - retval = create_gcm_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_DECRYPT, + /* 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, - RTE_CRYPTO_AUTH_OP_VERIFY); + tdata->iv.len); if (retval < 0) return retval; @@ -5481,8 +5809,8 @@ test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata) memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->obuf)); - /* Create GCM operation */ - retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata); + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); if (retval < 0) return retval; @@ -5508,23 +5836,23 @@ test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata) plaintext, tdata->plaintext.data, tdata->plaintext.len, - "GCM plaintext data not as expected"); + "Plaintext data not as expected"); TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "GCM authentication failed"); + "Authentication failed"); return 0; } static int -test_mb_AES_GCM_authenticated_decryption_oop(void) +test_AES_GCM_authenticated_decryption_oop_test_case_1(void) { - return test_AES_GCM_authenticated_decryption_oop(&gcm_test_case_5); + return test_authenticated_decryption_oop(&gcm_test_case_5); } static int -test_AES_GCM_authenticated_encryption_sessionless( - const struct gcm_test_data *tdata) +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; @@ -5540,25 +5868,26 @@ test_AES_GCM_authenticated_encryption_sessionless( memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->ibuf)); - /* Create GCM operation */ - retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata); + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); if (retval < 0) return retval; - /* Create GCM xforms */ + /* Create GCM xform */ memcpy(key, tdata->key.data, tdata->key.len); - retval = create_gcm_xforms(ut_params->op, - RTE_CRYPTO_CIPHER_OP_ENCRYPT, + 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, - RTE_CRYPTO_AUTH_OP_GENERATE); + tdata->iv.len); if (retval < 0) return retval; 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 */ @@ -5584,28 +5913,28 @@ test_AES_GCM_authenticated_encryption_sessionless( ciphertext, tdata->ciphertext.data, tdata->ciphertext.len, - "GCM Ciphertext data not as expected"); + "Ciphertext data not as expected"); TEST_ASSERT_BUFFERS_ARE_EQUAL( auth_tag, tdata->auth_tag.data, tdata->auth_tag.len, - "GCM Generated auth tag not as expected"); + "Generated auth tag not as expected"); return 0; } static int -test_mb_AES_GCM_authenticated_encryption_sessionless(void) +test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void) { - return test_AES_GCM_authenticated_encryption_sessionless( + return test_authenticated_encryption_sessionless( &gcm_test_case_5); } static int -test_AES_GCM_authenticated_decryption_sessionless( - const struct gcm_test_data *tdata) +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; @@ -5620,25 +5949,26 @@ test_AES_GCM_authenticated_decryption_sessionless( memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->ibuf)); - /* Create GCM operation */ - retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata); + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); if (retval < 0) return retval; - /* Create GCM xforms */ + /* Create AEAD xform */ memcpy(key, tdata->key.data, tdata->key.len); - retval = create_gcm_xforms(ut_params->op, - RTE_CRYPTO_CIPHER_OP_DECRYPT, + 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, - RTE_CRYPTO_AUTH_OP_VERIFY); + tdata->iv.len); if (retval < 0) return retval; 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 */ @@ -5660,42 +5990,150 @@ test_AES_GCM_authenticated_decryption_sessionless( plaintext, tdata->plaintext.data, tdata->plaintext.len, - "GCM plaintext data not as expected"); + "Plaintext data not as expected"); TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, - "GCM authentication failed"); + "Authentication failed"); return 0; } static int -test_mb_AES_GCM_authenticated_decryption_sessionless(void) +test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void) { - return test_AES_GCM_authenticated_decryption_sessionless( + return test_authenticated_decryption_sessionless( &gcm_test_case_5); } static int -test_stats(void) +test_AES_CCM_authenticated_encryption_test_case_128_1(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; - struct rte_cryptodev_stats stats; - struct rte_cryptodev *dev; - cryptodev_stats_get_t temp_pfn; + return test_authenticated_encryption(&ccm_test_case_128_1); +} - 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_CCM_authenticated_encryption_test_case_128_2(void) +{ + return test_authenticated_encryption(&ccm_test_case_128_2); +} + +static int +test_AES_CCM_authenticated_encryption_test_case_128_3(void) +{ + return test_authenticated_encryption(&ccm_test_case_128_3); +} + +static int +test_AES_CCM_authenticated_decryption_test_case_128_1(void) +{ + return test_authenticated_decryption(&ccm_test_case_128_1); +} + +static int +test_AES_CCM_authenticated_decryption_test_case_128_2(void) +{ + return test_authenticated_decryption(&ccm_test_case_128_2); +} + +static int +test_AES_CCM_authenticated_decryption_test_case_128_3(void) +{ + return test_authenticated_decryption(&ccm_test_case_128_3); +} + +static int +test_AES_CCM_authenticated_encryption_test_case_192_1(void) +{ + return test_authenticated_encryption(&ccm_test_case_192_1); +} + +static int +test_AES_CCM_authenticated_encryption_test_case_192_2(void) +{ + return test_authenticated_encryption(&ccm_test_case_192_2); +} + +static int +test_AES_CCM_authenticated_encryption_test_case_192_3(void) +{ + return test_authenticated_encryption(&ccm_test_case_192_3); +} + +static int +test_AES_CCM_authenticated_decryption_test_case_192_1(void) +{ + return test_authenticated_decryption(&ccm_test_case_192_1); +} + +static int +test_AES_CCM_authenticated_decryption_test_case_192_2(void) +{ + return test_authenticated_decryption(&ccm_test_case_192_2); +} + +static int +test_AES_CCM_authenticated_decryption_test_case_192_3(void) +{ + return test_authenticated_decryption(&ccm_test_case_192_3); +} + +static int +test_AES_CCM_authenticated_encryption_test_case_256_1(void) +{ + return test_authenticated_encryption(&ccm_test_case_256_1); +} + +static int +test_AES_CCM_authenticated_encryption_test_case_256_2(void) +{ + return test_authenticated_encryption(&ccm_test_case_256_2); +} + +static int +test_AES_CCM_authenticated_encryption_test_case_256_3(void) +{ + return test_authenticated_encryption(&ccm_test_case_256_3); +} + +static int +test_AES_CCM_authenticated_decryption_test_case_256_1(void) +{ + return test_authenticated_decryption(&ccm_test_case_256_1); +} + +static int +test_AES_CCM_authenticated_decryption_test_case_256_2(void) +{ + return test_authenticated_decryption(&ccm_test_case_256_2); +} + +static int +test_AES_CCM_authenticated_decryption_test_case_256_3(void) +{ + return test_authenticated_decryption(&ccm_test_case_256_3); +} + +static int +test_stats(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct rte_cryptodev_stats stats; + struct rte_cryptodev *dev; + cryptodev_stats_get_t temp_pfn; + + rte_cryptodev_stats_reset(ts_params->valid_devs[0]); + TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600, + &stats) == -ENODEV), + "rte_cryptodev_stats_get invalid dev failed"); + TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0), + "rte_cryptodev_stats_get invalid Param failed"); + dev = &rte_cryptodevs[ts_params->valid_devs[0]]; + temp_pfn = dev->dev_ops->stats_get; + dev->dev_ops->stats_get = (cryptodev_stats_get_t)0; + TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats) + == -ENOTSUP), + "rte_cryptodev_stats_get invalid Param failed"); + dev->dev_ops->stats_get = temp_pfn; /* Test expected values */ ut_setup(); @@ -5750,12 +6188,15 @@ static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params, 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.add_auth_data_length = 0; ut_params->auth_xform.auth.key.length = test_case->key.len; ut_params->auth_xform.auth.key.data = key; ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], &ut_params->auth_xform); + ts_params->session_mpool); + + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + ut_params->sess, &ut_params->auth_xform, + ts_params->session_mpool); if (ut_params->sess == NULL) return TEST_FAILED; @@ -5788,9 +6229,8 @@ static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params, 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_mtophys_offset( + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( ut_params->ibuf, plaintext_pad_len); - sym_op->auth.digest.length = MD5_DIGEST_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, @@ -5931,9 +6371,13 @@ test_multi_session(void) /* Create multiple crypto sessions*/ for (i = 0; i < dev_info.sym.max_nb_sessions; i++) { + sessions[i] = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], - &ut_params->auth_xform); + ts_params->session_mpool); + + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + sessions[i], &ut_params->auth_xform, + ts_params->session_mpool); TEST_ASSERT_NOT_NULL(sessions[i], "Session creation failed at session number %u", i); @@ -5969,14 +6413,17 @@ test_multi_session(void) } /* Next session create should fail */ - sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0], - &ut_params->auth_xform); + rte_cryptodev_sym_session_init(ts_params->valid_devs[0], + sessions[i], &ut_params->auth_xform, + ts_params->session_mpool); TEST_ASSERT_NULL(sessions[i], "Session creation succeeded unexpectedly!"); - for (i = 0; i < dev_info.sym.max_nb_sessions; i++) - rte_cryptodev_sym_session_free(ts_params->valid_devs[0], + for (i = 0; i < dev_info.sym.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); @@ -6034,7 +6481,10 @@ test_multi_session_random_usage(void) * dev_info.sym.max_nb_sessions) + 1, 0); for (i = 0; i < MB_SESSION_NUMBER; i++) { - rte_memcpy(&ut_paramz[i].ut_params, &testsuite_params, + sessions[i] = rte_cryptodev_sym_session_create( + ts_params->session_mpool); + + rte_memcpy(&ut_paramz[i].ut_params, &unittest_params, sizeof(struct crypto_unittest_params)); test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( @@ -6042,9 +6492,11 @@ test_multi_session_random_usage(void) ut_paramz[i].cipher_key, ut_paramz[i].hmac_key); /* Create multiple crypto sessions*/ - sessions[i] = rte_cryptodev_sym_session_create( + rte_cryptodev_sym_session_init( ts_params->valid_devs[0], - &ut_paramz[i].ut_params.auth_xform); + sessions[i], + &ut_paramz[i].ut_params.auth_xform, + ts_params->session_mpool); TEST_ASSERT_NOT_NULL(sessions[i], "Session creation failed at session number %u", @@ -6087,9 +6539,11 @@ test_multi_session_random_usage(void) } } - for (i = 0; i < MB_SESSION_NUMBER; i++) - rte_cryptodev_sym_session_free(ts_params->valid_devs[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); @@ -6113,9 +6567,14 @@ test_null_cipher_only_operation(void) ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; - /* Create Crypto session*/ ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], &ut_params->cipher_xform); + 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_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); /* Generate Crypto op data structure */ @@ -6170,9 +6629,13 @@ test_null_auth_only_operation(void) ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; - /* Create Crypto session*/ ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], &ut_params->auth_xform); + 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_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); /* Generate Crypto op data structure */ @@ -6226,9 +6689,13 @@ test_null_cipher_auth_operation(void) ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; - /* Create Crypto session*/ ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], &ut_params->cipher_xform); + 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_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); /* Generate Crypto op data structure */ @@ -6292,9 +6759,13 @@ test_null_auth_cipher_operation(void) ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; - /* Create Crypto session*/ ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], &ut_params->cipher_xform); + 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_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); /* Generate Crypto op data structure */ @@ -6340,6 +6811,7 @@ test_null_invalid_operation(void) { 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; @@ -6348,10 +6820,14 @@ test_null_invalid_operation(void) ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; - /* Create Crypto session*/ ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], &ut_params->cipher_xform); - TEST_ASSERT_NULL(ut_params->sess, + 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_mpool); + TEST_ASSERT(ret < 0, "Session creation succeeded unexpectedly"); @@ -6362,10 +6838,14 @@ test_null_invalid_operation(void) ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; - /* Create Crypto session*/ ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], &ut_params->auth_xform); - TEST_ASSERT_NULL(ut_params->sess, + 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_mpool); + TEST_ASSERT(ret < 0, "Session creation succeeded unexpectedly"); return TEST_SUCCESS; @@ -6399,9 +6879,13 @@ test_null_burst_operation(void) ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; - /* Create Crypto session*/ ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->valid_devs[0], &ut_params->cipher_xform); + 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_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool, @@ -6466,19 +6950,7 @@ 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); - - /* - * 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->aad.len == GMAC_LARGE_PLAINTEXT_LENGTH) - generate_gmac_large_plaintext(tdata->aad.data); + 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, @@ -6487,72 +6959,49 @@ create_gmac_operation(enum rte_crypto_auth_operation op, "Failed to allocate symmetric crypto operation struct"); sym_op = ut_params->op->sym; - sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - aad_pad_len); - TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, - "no room to append aad"); - - sym_op->auth.aad.length = tdata->aad.len; - sym_op->auth.aad.phys_addr = - rte_pktmbuf_mtophys(ut_params->ibuf); - memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len); sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( ut_params->ibuf, tdata->gmac_tag.len); TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, "no room to append digest"); - sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( - ut_params->ibuf, aad_pad_len); - sym_op->auth.digest.length = tdata->gmac_tag.len; + 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); TEST_HEXDUMP(stdout, "digest:", sym_op->auth.digest.data, - sym_op->auth.digest.length); + tdata->gmac_tag.len); } - 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"); + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); - 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 = tdata->iv.len; + rte_memcpy(iv_ptr, tdata->iv.data, 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:", 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 = 0; + sym_op->auth.data.length = tdata->plaintext.len; return 0; } static int create_gmac_session(uint8_t dev_id, - enum rte_crypto_cipher_operation op, const struct gmac_test_data *tdata, enum rte_crypto_auth_operation auth_op) { - uint8_t cipher_key[tdata->key.len]; + uint8_t auth_key[tdata->key.len]; + struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - memcpy(cipher_key, tdata->key.data, tdata->key.len); - - /* For GMAC we 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_GCM; - ut_params->cipher_xform.cipher.op = op; - ut_params->cipher_xform.cipher.key.data = cipher_key; - ut_params->cipher_xform.cipher.key.length = tdata->key.len; + 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; @@ -6560,14 +7009,18 @@ static int create_gmac_session(uint8_t dev_id, 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.add_auth_data_length = 0; - ut_params->auth_xform.auth.key.length = 0; - ut_params->auth_xform.auth.key.data = NULL; + 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->cipher_xform.next = &ut_params->auth_xform; - ut_params->sess = rte_cryptodev_sym_session_create(dev_id, - &ut_params->cipher_xform); + 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_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); @@ -6582,20 +7035,19 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata) int retval; - uint8_t *auth_tag, *p; - uint16_t aad_pad_len; + 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"); retval = create_gmac_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata, RTE_CRYPTO_AUTH_OP_GENERATE); if (retval < 0) return retval; - if (tdata->aad.len > MBUF_SIZE) + 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); @@ -6605,9 +7057,22 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata) memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->ibuf)); - aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); + 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); + TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); - p = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); + TEST_HEXDUMP(stdout, "plaintext:", plaintext, + tdata->plaintext.len); retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE, tdata); @@ -6627,9 +7092,9 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata) if (ut_params->op->sym->m_dst) { auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, - uint8_t *, aad_pad_len); + uint8_t *, plaintext_pad_len); } else { - auth_tag = p + aad_pad_len; + auth_tag = plaintext + plaintext_pad_len; } TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len); @@ -6673,18 +7138,19 @@ 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; 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], - RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata, RTE_CRYPTO_AUTH_OP_VERIFY); if (retval < 0) return retval; - if (tdata->aad.len > MBUF_SIZE) + 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); @@ -6694,6 +7160,24 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata) 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); + TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); + + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); + TEST_HEXDUMP(stdout, "plaintext:", plaintext, + tdata->plaintext.len); + retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY, tdata); @@ -6807,8 +7291,7 @@ hmac_sha1_test_crypto_vector = { static const struct test_crypto_vector aes128_gmac_test_vector = { .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC, - .crypto_algo = RTE_CRYPTO_CIPHER_AES_GCM, - .aad = { + .plaintext = { .data = plaintext_hash, .len = 512 }, @@ -6819,7 +7302,7 @@ aes128_gmac_test_vector = { }, .len = 12 }, - .cipher_key = { + .auth_key = { .data = { 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA @@ -6897,6 +7380,7 @@ create_auth_session(struct crypto_unittest_params *ut_params, 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]; memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); @@ -6909,11 +7393,14 @@ create_auth_session(struct crypto_unittest_params *ut_params, 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.add_auth_data_length = reference->aad.len; /* Create Crypto session*/ - ut_params->sess = rte_cryptodev_sym_session_create(dev_id, - &ut_params->auth_xform); + 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_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); @@ -6927,6 +7414,7 @@ create_auth_cipher_session(struct crypto_unittest_params *ut_params, enum rte_crypto_auth_operation auth_op, enum rte_crypto_cipher_operation cipher_op) { + struct crypto_testsuite_params *ts_params = &testsuite_params; uint8_t cipher_key[reference->cipher_key.len + 1]; uint8_t auth_key[reference->auth_key.len + 1]; @@ -6937,24 +7425,35 @@ create_auth_cipher_session(struct crypto_unittest_params *ut_params, /* 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 = 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.add_auth_data_length = reference->aad.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 = cipher_op; - ut_params->cipher_xform.cipher.key.data = cipher_key; - ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len; + if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) { + ut_params->auth_xform.auth.iv.offset = IV_OFFSET; + ut_params->auth_xform.auth.iv.length = reference->iv.len; + } 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; + } /* Create Crypto session*/ - ut_params->sess = rte_cryptodev_sym_session_create(dev_id, - &ut_params->auth_xform); + 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_mpool); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); @@ -6988,9 +7487,8 @@ create_auth_operation(struct crypto_testsuite_params *ts_params, TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, "no room to append auth tag"); - sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( ut_params->ibuf, reference->plaintext.len); - sym_op->auth.digest.length = reference->digest.len; if (auth_generate) memset(sym_op->auth.digest.data, 0, reference->digest.len); @@ -7001,7 +7499,7 @@ create_auth_operation(struct crypto_testsuite_params *ts_params, TEST_HEXDUMP(stdout, "digest:", sym_op->auth.digest.data, - sym_op->auth.digest.length); + reference->digest.len); sym_op->auth.data.length = reference->plaintext.len; sym_op->auth.data.offset = 0; @@ -7029,17 +7527,6 @@ create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params, /* set crypto operation source mbuf */ sym_op->m_src = ut_params->ibuf; - /* aad */ - sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, - reference->aad.len); - TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, "no room to append AAD"); - memcpy(sym_op->auth.aad.data, reference->aad.data, reference->aad.len); - - TEST_HEXDUMP(stdout, "AAD:", sym_op->auth.aad.data, reference->aad.len); - - sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - sym_op->auth.aad.length = reference->aad.len; - /* digest */ sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( ut_params->ibuf, reference->digest.len); @@ -7047,9 +7534,8 @@ create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params, TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, "no room to append auth tag"); - sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( ut_params->ibuf, reference->ciphertext.len); - sym_op->auth.digest.length = reference->digest.len; if (auth_generate) memset(sym_op->auth.digest.data, 0, reference->digest.len); @@ -7060,21 +7546,15 @@ create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params, TEST_HEXDUMP(stdout, "digest:", 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"); + reference->digest.len); - sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); - sym_op->cipher.iv.length = reference->iv.len; - - memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->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->auth.data.length = 0; + sym_op->auth.data.length = reference->plaintext.len; sym_op->auth.data.offset = 0; return 0; @@ -7107,9 +7587,8 @@ create_cipher_auth_operation(struct crypto_testsuite_params *ts_params, TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, "no room to append auth tag"); - sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( ut_params->ibuf, reference->ciphertext.len); - sym_op->auth.digest.length = reference->digest.len; if (auth_generate) memset(sym_op->auth.digest.data, 0, reference->digest.len); @@ -7120,22 +7599,16 @@ create_cipher_auth_operation(struct crypto_testsuite_params *ts_params, TEST_HEXDUMP(stdout, "digest:", 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.length = reference->iv.len; + reference->digest.len); - memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->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 = 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; } @@ -7231,6 +7704,7 @@ test_authentication_verify_GMAC_fail_when_corruption( unsigned int data_corrupted) { int retval; + uint8_t *plaintext; /* Create session */ retval = create_auth_cipher_session(ut_params, @@ -7249,6 +7723,13 @@ test_authentication_verify_GMAC_fail_when_corruption( 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); + + TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len); + /* Create operation */ retval = create_auth_verify_GMAC_operation(ts_params, ut_params, @@ -7258,10 +7739,9 @@ test_authentication_verify_GMAC_fail_when_corruption( return retval; if (data_corrupted) - data_corruption(ut_params->op->sym->auth.aad.data); + data_corruption(plaintext); else - tag_corruption(ut_params->op->sym->auth.aad.data, - reference->aad.len); + tag_corruption(plaintext, reference->aad.len); ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); @@ -7338,8 +7818,8 @@ test_authenticated_decryption_fail_when_corruption( } static int -create_gcm_operation_SGL(enum rte_crypto_cipher_operation op, - const struct gcm_test_data *tdata, +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; @@ -7347,9 +7827,7 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op, const unsigned int auth_tag_len = tdata->auth_tag.len; const unsigned int iv_len = tdata->iv.len; - const unsigned int aad_len = tdata->aad.len; - - unsigned int iv_pad_len = 0; + unsigned int aad_len = tdata->aad.len; /* Generate Crypto op data structure */ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, @@ -7359,56 +7837,68 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op, struct rte_crypto_sym_op *sym_op = ut_params->op->sym; - sym_op->auth.digest.data = digest_mem; + sym_op->aead.digest.data = digest_mem; - TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, "no room to append digest"); - sym_op->auth.digest.phys_addr = digest_phys; - sym_op->auth.digest.length = auth_tag_len; + sym_op->aead.digest.phys_addr = digest_phys; - if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) { - rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data, + if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) { + rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data, auth_tag_len); TEST_HEXDUMP(stdout, "digest:", - sym_op->auth.digest.data, - sym_op->auth.digest.length); + sym_op->aead.digest.data, + auth_tag_len); } - iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); + /* 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); + + /* Copy IV 1 byte after the IV pointer, according to the API */ + rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len); - sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, iv_pad_len); + aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16); - TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, - "no room to prepend iv"); + 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); - 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_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); - rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, iv_pad_len); + TEST_HEXDUMP(stdout, "iv:", iv_ptr, iv_len); + TEST_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.aad.data = (uint8_t *)rte_pktmbuf_prepend( - ut_params->ibuf, aad_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; + rte_memcpy(iv_ptr, tdata->iv.data, iv_len); - memset(sym_op->auth.aad.data, 0, aad_len); - rte_memcpy(sym_op->auth.aad.data, tdata->aad.data, aad_len); + 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); - TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len); - TEST_HEXDUMP(stdout, "aad:", - sym_op->auth.aad.data, aad_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 = tdata->plaintext.len; - sym_op->cipher.data.offset = aad_len + iv_pad_len; + TEST_HEXDUMP(stdout, "iv:", iv_ptr, iv_len); + TEST_HEXDUMP(stdout, "aad:", + sym_op->aead.aad.data, aad_len); + } - sym_op->auth.data.offset = aad_len + iv_pad_len; - sym_op->auth.data.length = tdata->plaintext.len; + sym_op->aead.data.length = tdata->plaintext.len; + sym_op->aead.data.offset = aad_len; return 0; } @@ -7416,7 +7906,7 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op, #define SGL_MAX_NO 16 static int -test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata, +test_authenticated_encryption_SGL(const struct aead_test_data *tdata, const int oop, uint32_t fragsz, uint32_t fragsz_oop) { struct crypto_testsuite_params *ts_params = &testsuite_params; @@ -7441,8 +7931,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) @@ -7462,12 +7951,13 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata, buf_oop = ut_params->obuf; } - /* Create GCM session */ - retval = create_gcm_session(ts_params->valid_devs[0], - RTE_CRYPTO_CIPHER_OP_ENCRYPT, + /* 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, - RTE_CRYPTO_AUTH_OP_GENERATE); + tdata->iv.len); if (retval < 0) return retval; @@ -7543,7 +8033,7 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata, digest_mem = rte_pktmbuf_append(ut_params->obuf, tdata->auth_tag.len); - digest_phys = rte_pktmbuf_mtophys_offset( + digest_phys = rte_pktmbuf_iova_offset( ut_params->obuf, tdata->plaintext.len + prepend_len); } @@ -7581,19 +8071,19 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata, * Place digest at the end of the last buffer */ if (!digest_phys) - digest_phys = rte_pktmbuf_mtophys(buf) + to_trn; + digest_phys = rte_pktmbuf_iova(buf) + to_trn; if (oop && buf_last_oop) - digest_phys = rte_pktmbuf_mtophys(buf_last_oop) + to_trn; + 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_mtophys_offset(ut_params->ibuf, + digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf, tdata->plaintext.len); } - /* Create GCM opertaion */ - retval = create_gcm_operation_SGL(RTE_CRYPTO_CIPHER_OP_ENCRYPT, + /* Create AEAD operation */ + retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata, digest_mem, digest_phys); if (retval < 0) @@ -7627,7 +8117,7 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata, ciphertext, tdata->ciphertext.data, fragsz, - "GCM Ciphertext data not as expected"); + "Ciphertext data not as expected"); buf = ut_params->op->sym->m_src->next; if (oop) @@ -7644,7 +8134,7 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata, ciphertext, tdata->ciphertext.data + off, to_trn_tbl[ecx], - "GCM Ciphertext data not as expected"); + "Ciphertext data not as expected"); off += to_trn_tbl[ecx++]; buf = buf->next; @@ -7655,7 +8145,7 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata, auth_tag, tdata->auth_tag.data, tdata->auth_tag.len, - "GCM Generated auth tag not as expected"); + "Generated auth tag not as expected"); return 0; } @@ -7666,21 +8156,21 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata, static int test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void) { - return test_AES_GCM_authenticated_encryption_SGL( + 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_AES_GCM_authenticated_encryption_SGL( + 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_AES_GCM_authenticated_encryption_SGL( + return test_authenticated_encryption_SGL( &gcm_test_case_8, OUT_OF_PLACE, 400, gcm_test_case_8.plaintext.len); } @@ -7689,7 +8179,7 @@ static int test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void) { - return test_AES_GCM_authenticated_encryption_SGL( + return test_authenticated_encryption_SGL( &gcm_test_case_SGL_1, IN_PLACE, 1500, 0); } @@ -7818,8 +8308,9 @@ test_scheduler_attach_slave_op(void) char vdev_name[32]; /* create 2 AESNI_MB if necessary */ - nb_devs = rte_cryptodev_count_devtype( - RTE_CRYPTODEV_AESNI_MB_PMD); + 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", @@ -7840,9 +8331,37 @@ test_scheduler_attach_slave_op(void) struct rte_cryptodev_info info; rte_cryptodev_info_get(i, &info); - if (info.dev_type != RTE_CRYPTODEV_AESNI_MB_PMD) + if (info.driver_id != rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) continue; + /* + * 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; + } + unsigned int session_size = rte_cryptodev_get_private_session_size(i); + + /* + * Create mempool with maximum number of sessions * 2, + * to include the session headers + */ + if (ts_params->session_mpool == NULL) { + ts_params->session_mpool = rte_mempool_create( + "test_sess_mp", + info.sym.max_nb_sessions * 2, + session_size, + 0, 0, NULL, NULL, NULL, + NULL, SOCKET_ID_ANY, + 0); + + TEST_ASSERT_NOT_NULL(ts_params->session_mpool, + "session mempool allocation failed"); + } + ret = rte_cryptodev_scheduler_slave_attach(sched_id, (uint8_t)i); @@ -7954,8 +8473,25 @@ static struct unit_test_suite cryptodev_qat_testsuite = { 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), @@ -7964,61 +8500,109 @@ static struct unit_test_suite cryptodev_qat_testsuite = { 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_mb_AES_GCM_authenticated_encryption_test_case_1), + test_AES_GCM_authenticated_encryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_2), + test_AES_GCM_authenticated_encryption_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_3), + test_AES_GCM_authenticated_encryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_4), + test_AES_GCM_authenticated_encryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_5), + test_AES_GCM_authenticated_encryption_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_6), + test_AES_GCM_authenticated_encryption_test_case_6), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_7), + test_AES_GCM_authenticated_encryption_test_case_7), /** AES GCM Authenticated Decryption */ TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_1), + test_AES_GCM_authenticated_decryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_2), + test_AES_GCM_authenticated_decryption_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_3), + test_AES_GCM_authenticated_decryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_4), + test_AES_GCM_authenticated_decryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_5), + test_AES_GCM_authenticated_decryption_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_6), + test_AES_GCM_authenticated_decryption_test_case_6), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_7), + test_AES_GCM_authenticated_decryption_test_case_7), - /** AES GMAC Authentication */ + /** AES GCM Authenticated Encryption 192 bits key */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_1), + test_AES_GCM_auth_encryption_test_case_192_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_1), + test_AES_GCM_auth_encryption_test_case_192_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_2), + test_AES_GCM_auth_encryption_test_case_192_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_2), + test_AES_GCM_auth_encryption_test_case_192_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_3), + test_AES_GCM_auth_encryption_test_case_192_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_3), + 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), - /** SNOW 3G encrypt only (UEA2) */ + /** AES GCM Authenticated Decryption 192 bits key */ TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_1), + test_AES_GCM_auth_decryption_test_case_192_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_2), + test_AES_GCM_auth_decryption_test_case_192_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_3), + test_AES_GCM_auth_decryption_test_case_192_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_4), + test_AES_GCM_auth_decryption_test_case_192_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_snow3g_encryption_test_case_5), + 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 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), @@ -8099,10 +8683,31 @@ static struct unit_test_suite cryptodev_qat_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_null_auth_cipher_operation), + /** 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), - /** KASUMI tests */ + 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, @@ -8139,6 +8744,10 @@ static struct unit_test_suite cryptodev_aesni_mb_testsuite = { 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_CASES_END() /**< NULL terminate unit test array */ } @@ -8160,6 +8769,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_cipheronly_openssl_all), TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_openssl_all), TEST_CASE_ST(ut_setup, ut_teardown, @@ -8167,35 +8778,100 @@ static struct unit_test_suite cryptodev_openssl_testsuite = { /** AES GCM Authenticated Encryption */ TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_1), + test_AES_GCM_authenticated_encryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_2), + test_AES_GCM_authenticated_encryption_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_3), + test_AES_GCM_authenticated_encryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_4), + test_AES_GCM_authenticated_encryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_5), + test_AES_GCM_authenticated_encryption_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_6), + test_AES_GCM_authenticated_encryption_test_case_6), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_7), + test_AES_GCM_authenticated_encryption_test_case_7), /** AES GCM Authenticated Decryption */ TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_1), + 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), + + /** 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_mb_AES_GCM_authenticated_decryption_test_case_2), + test_AES_GCM_auth_decryption_test_case_256_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_3), + test_AES_GCM_auth_decryption_test_case_256_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_4), + test_AES_GCM_auth_decryption_test_case_256_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_5), + test_AES_GCM_auth_decryption_test_case_256_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_6), + test_AES_GCM_auth_decryption_test_case_256_6), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_7), + test_AES_GCM_auth_decryption_test_case_256_7), /** AES GMAC Authentication */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -8215,6 +8891,54 @@ static struct unit_test_suite cryptodev_openssl_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GMAC_authentication_verify_test_case_4), + /** AES CCM Authenticated Encryption 128 bits key */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_128_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_128_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_128_3), + + /** AES CCM Authenticated Decryption 128 bits key*/ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_128_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_128_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_128_3), + + /** AES CCM Authenticated Encryption 192 bits key */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_192_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_192_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_192_3), + + /** AES CCM Authenticated Decryption 192 bits key*/ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_192_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_192_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_192_3), + + /** AES CCM Authenticated Encryption 256 bits key */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_256_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_256_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_256_3), + + /** AES CCM Authenticated Decryption 256 bits key*/ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_256_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_256_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_256_3), + /** Scatter-Gather */ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg), @@ -8244,79 +8968,111 @@ static struct unit_test_suite cryptodev_aesni_gcm_testsuite = { .unit_test_cases = { /** AES GCM Authenticated Encryption */ TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_1), + test_AES_GCM_authenticated_encryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_2), + test_AES_GCM_authenticated_encryption_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_3), + test_AES_GCM_authenticated_encryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_4), + test_AES_GCM_authenticated_encryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_5), + test_AES_GCM_authenticated_encryption_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_6), + test_AES_GCM_authenticated_encryption_test_case_6), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_test_case_7), + test_AES_GCM_authenticated_encryption_test_case_7), /** AES GCM Authenticated Decryption */ TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_1), + test_AES_GCM_authenticated_decryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_2), + test_AES_GCM_authenticated_decryption_test_case_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_3), + test_AES_GCM_authenticated_decryption_test_case_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_4), + test_AES_GCM_authenticated_decryption_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_5), + test_AES_GCM_authenticated_decryption_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_6), + test_AES_GCM_authenticated_decryption_test_case_6), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_test_case_7), + 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_mb_AES_GCM_auth_encryption_test_case_256_1), + test_AES_GCM_auth_encryption_test_case_256_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_encryption_test_case_256_2), + test_AES_GCM_auth_encryption_test_case_256_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_encryption_test_case_256_3), + test_AES_GCM_auth_encryption_test_case_256_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_encryption_test_case_256_4), + test_AES_GCM_auth_encryption_test_case_256_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_encryption_test_case_256_5), + test_AES_GCM_auth_encryption_test_case_256_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_encryption_test_case_256_6), + test_AES_GCM_auth_encryption_test_case_256_6), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_encryption_test_case_256_7), + test_AES_GCM_auth_encryption_test_case_256_7), /** AES GCM Authenticated Decryption 256 bits key */ TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_decryption_test_case_256_1), + test_AES_GCM_auth_decryption_test_case_256_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_decryption_test_case_256_2), + test_AES_GCM_auth_decryption_test_case_256_2), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_decryption_test_case_256_3), + test_AES_GCM_auth_decryption_test_case_256_3), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_decryption_test_case_256_4), + test_AES_GCM_auth_decryption_test_case_256_4), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_decryption_test_case_256_5), + test_AES_GCM_auth_decryption_test_case_256_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_decryption_test_case_256_6), + test_AES_GCM_auth_decryption_test_case_256_6), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_decryption_test_case_256_7), + test_AES_GCM_auth_decryption_test_case_256_7), /** AES GCM Authenticated Encryption big aad size */ TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_encryption_test_case_aad_1), + test_AES_GCM_auth_encryption_test_case_aad_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_encryption_test_case_aad_2), + test_AES_GCM_auth_encryption_test_case_aad_2), /** AES GCM Authenticated Decryption big aad size */ TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_decryption_test_case_aad_1), + test_AES_GCM_auth_decryption_test_case_aad_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_auth_decryption_test_case_aad_2), + test_AES_GCM_auth_decryption_test_case_aad_2), /** AES GMAC Authentication */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -8340,15 +9096,15 @@ static struct unit_test_suite cryptodev_aesni_gcm_testsuite = { /** Out of place tests */ TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_oop), + test_AES_GCM_authenticated_encryption_oop_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_oop), + test_AES_GCM_authenticated_decryption_oop_test_case_1), /** Session-less tests */ TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_encryption_sessionless), + test_AES_GCM_authenticated_encryption_sessionless_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_mb_AES_GCM_authenticated_decryption_sessionless), + test_AES_GCM_authenticated_decryption_sessionless_test_case_1), /** Scatter-Gather */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -8532,8 +9288,8 @@ 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", +static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { + .suite_name = "Crypto DPAA_SEC Unit Test Suite", .setup = testsuite_setup, .teardown = testsuite_teardown, .unit_test_cases = { @@ -8543,23 +9299,212 @@ static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { test_multi_session), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_dpaa2_sec_all), + test_AES_chain_dpaa_sec_all), TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_dpaa2_sec_all), + test_3DES_chain_dpaa_sec_all), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_dpaa2_sec_all), + test_AES_cipheronly_dpaa_sec_all), TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_dpaa2_sec_all), + test_3DES_cipheronly_dpaa_sec_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_authonly_dpaa_sec_all), - /** HMAC_MD5 Authentication */ + /** 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), + + /** 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 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_MD5_HMAC_generate_case_1), + test_AES_GCM_auth_decryption_test_case_256_5), TEST_CASE_ST(ut_setup, ut_teardown, - test_MD5_HMAC_verify_case_1), + test_AES_GCM_auth_decryption_test_case_256_6), TEST_CASE_ST(ut_setup, ut_teardown, - test_MD5_HMAC_generate_case_2), + test_AES_GCM_auth_decryption_test_case_256_7), + + /** 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_MD5_HMAC_verify_case_2), + test_AES_GCM_authenticated_decryption_oop_test_case_1), + + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + +static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { + .suite_name = "Crypto DPAA2_SEC Unit Test Suite", + .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), + TEST_CASE_ST(ut_setup, ut_teardown, + test_authonly_dpaa2_sec_all), + + /** 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), + + /** 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), + + /** AES GCM Authenticated Decryption 256 bits key */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_7), + + /** Out of place tests */ + 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), TEST_CASES_END() /**< NULL terminate unit test array */ } @@ -8604,17 +9549,68 @@ static struct unit_test_suite cryptodev_armv8_testsuite = { } }; +static struct unit_test_suite cryptodev_mrvl_testsuite = { + .suite_name = "Crypto Device Marvell Component Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { + TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session), + TEST_CASE_ST(ut_setup, ut_teardown, + test_multi_session_random_usage), + TEST_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), + + /** Negative tests */ + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_HMAC_SHA1_fail_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_HMAC_SHA1_fail_tag_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), + + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + + static int test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/) { - gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD; + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_QAT is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } + return unit_test_suite_runner(&cryptodev_qat_testsuite); } static int test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/) { - gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD; + 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_FAILED; + } return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite); } @@ -8622,7 +9618,15 @@ test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/) static int test_cryptodev_openssl(void) { - gbl_cryptodev_type = RTE_CRYPTODEV_OPENSSL_PMD; + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } return unit_test_suite_runner(&cryptodev_openssl_testsuite); } @@ -8630,7 +9634,15 @@ test_cryptodev_openssl(void) static int test_cryptodev_aesni_gcm(void) { - gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD; + 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_FAILED; + } return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite); } @@ -8638,7 +9650,15 @@ test_cryptodev_aesni_gcm(void) static int test_cryptodev_null(void) { - gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD; + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_NULL_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "NULL PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_NULL is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } return unit_test_suite_runner(&cryptodev_null_testsuite); } @@ -8646,7 +9666,15 @@ test_cryptodev_null(void) static int test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/) { - gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD; + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite); } @@ -8654,7 +9682,15 @@ test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/) static int test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/) { - gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD; + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite); } @@ -8662,7 +9698,15 @@ test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/) static int test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/) { - gbl_cryptodev_type = RTE_CRYPTODEV_ZUC_PMD; + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_ZUC_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_ZUC is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite); } @@ -8670,17 +9714,56 @@ test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/) static int test_cryptodev_armv8(void) { - gbl_cryptodev_type = RTE_CRYPTODEV_ARMV8_PMD; + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } return unit_test_suite_runner(&cryptodev_armv8_testsuite); } +static int +test_cryptodev_mrvl(void) +{ + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_MRVL_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "MRVL PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_MRVL_CRYPTO is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } + + return unit_test_suite_runner(&cryptodev_mrvl_testsuite); +} + #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER static int test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/) { - gbl_cryptodev_type = RTE_CRYPTODEV_SCHEDULER_PMD; + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } + + if (rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) { + RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be" + " enabled in config file to run this testsuite.\n"); + return TEST_FAILED; +} return unit_test_suite_runner(&cryptodev_scheduler_testsuite); } @@ -8691,10 +9774,35 @@ REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler); static int test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/) { - gbl_cryptodev_type = RTE_CRYPTODEV_DPAA2_SEC_PMD; + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } + return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite); } +static int +test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/) +{ + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_DPAA_SEC is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } + + return unit_test_suite_runner(&cryptodev_dpaa_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); @@ -8704,4 +9812,6 @@ 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_sw_mrvl_autotest, test_cryptodev_mrvl); REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec); +REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);