#include <rte_crypto.h>
#include <rte_cryptodev.h>
-#include <rte_cryptodev_pmd.h>
+#include <rte_ip.h>
#include <rte_string_fns.h>
+#include <rte_tcp.h>
+#include <rte_udp.h>
#ifdef RTE_CRYPTO_SCHEDULER
#include <rte_cryptodev_scheduler.h>
#include "test_cryptodev_hmac_test_vectors.h"
#include "test_cryptodev_mixed_test_vectors.h"
#ifdef RTE_LIB_SECURITY
+#include "test_cryptodev_security_ipsec.h"
+#include "test_cryptodev_security_ipsec_test_vectors.h"
#include "test_cryptodev_security_pdcp_test_vectors.h"
#include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
#include "test_cryptodev_security_pdcp_test_func.h"
#define IN_PLACE 0
#define OUT_OF_PLACE 1
-#ifndef ARRAY_SIZE
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
-#endif
-
static int gbl_driver_id;
static enum rte_security_session_action_type gbl_action_type =
enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
-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_mempool *session_priv_mpool;
- struct rte_cryptodev_config conf;
- struct rte_cryptodev_qp_conf qp_conf;
-
- uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
- uint8_t valid_dev_count;
-};
-
struct crypto_unittest_params {
struct rte_crypto_sym_xform cipher_xform;
struct rte_crypto_sym_xform auth_xform;
for (j = 0; j < num_child_ts; index++, j++) \
parent_ts.unit_test_suites[index] = child_ts[j]
+#define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types) \
+ for (j = 0; j < num_blk_types; index++, j++) \
+ parent_ts.unit_test_suites[index] = \
+ build_blockcipher_test_suite(blk_types[j])
+
+#define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types) \
+ for (j = index; j < index + num_blk_types; j++) \
+ free_blockcipher_test_suite(parent_ts.unit_test_suites[j])
+
/*
* Forward declarations.
*/
const uint8_t *digest,
const uint8_t *iv);
+static int
+security_proto_supported(enum rte_security_session_action_type action,
+ enum rte_security_session_protocol proto);
+
+static int
+dev_configure_and_start(uint64_t ff_disable);
+
static struct rte_mbuf *
setup_test_string(struct rte_mempool *mpool,
const char *string, size_t len, uint8_t blocksize)
struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
size_t t_len = len - (blocksize ? (len % blocksize) : 0);
- memset(m->buf_addr, 0, m->buf_len);
if (m) {
- char *dst = rte_pktmbuf_append(m, t_len);
+ char *dst;
+ memset(m->buf_addr, 0, m->buf_len);
+ dst = rte_pktmbuf_append(m, t_len);
if (!dst) {
rte_pktmbuf_free(m);
return NULL;
{
struct rte_crypto_sym_op *sop = op->sym;
struct rte_crypto_op *ret_op = NULL;
- struct rte_crypto_vec data_vec[UINT8_MAX];
+ struct rte_crypto_vec data_vec[UINT8_MAX], dest_data_vec[UINT8_MAX];
struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
union rte_crypto_sym_ofs ofs;
struct rte_crypto_sym_vec vec;
- struct rte_crypto_sgl sgl;
+ struct rte_crypto_sgl sgl, dest_sgl;
uint32_t max_len;
union rte_cryptodev_session_ctx sess;
uint32_t count = 0;
digest.va = NULL;
sgl.vec = data_vec;
vec.num = 1;
- vec.sgl = &sgl;
+ vec.src_sgl = &sgl;
vec.iv = &cipher_iv;
vec.digest = &digest;
vec.aad = &aad_auth_iv;
}
sgl.num = n;
+ /* Out of place */
+ if (sop->m_dst != NULL) {
+ dest_sgl.vec = dest_data_vec;
+ vec.dest_sgl = &dest_sgl;
+ n = rte_crypto_mbuf_to_vec(sop->m_dst, 0, max_len,
+ dest_data_vec, RTE_DIM(dest_data_vec));
+ if (n < 0 || n > sop->m_dst->nb_segs) {
+ op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+ goto exit;
+ }
+ dest_sgl.num = n;
+ } else
+ vec.dest_sgl = NULL;
if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
&enqueue_status) < 1) {
}
op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
+ ret_op->status == RTE_CRYPTO_OP_STATUS_ERROR ||
n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
RTE_CRYPTO_OP_STATUS_SUCCESS;
sgl.vec = vec;
sgl.num = n;
- symvec.sgl = &sgl;
+ symvec.src_sgl = &sgl;
symvec.iv = &iv_ptr;
symvec.digest = &digest_ptr;
symvec.aad = &aad_ptr;
sgl.vec = vec;
sgl.num = n;
- symvec.sgl = &sgl;
+ symvec.src_sgl = &sgl;
symvec.iv = &iv_ptr;
symvec.digest = &digest_ptr;
symvec.status = &st;
}
static struct crypto_testsuite_params testsuite_params = { NULL };
+struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
static struct crypto_unittest_params unittest_params;
static int
}
#ifdef RTE_LIB_SECURITY
+static int
+ipsec_proto_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct crypto_unittest_params *ut_params = &unittest_params;
+ struct rte_cryptodev_info dev_info;
+ int ret = 0;
+
+ rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Reconfigure to enable security */
+ ret = dev_configure_and_start(0);
+ if (ret != TEST_SUCCESS)
+ return ret;
+
+ /* Set action type */
+ ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
+
+ if (security_proto_supported(
+ RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
+ RTE_SECURITY_PROTOCOL_IPSEC) < 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto "
+ "test not met\n");
+ ret = TEST_SKIPPED;
+ }
+
+ /*
+ * Stop the device. Device would be started again by individual test
+ * case setup routine.
+ */
+ rte_cryptodev_stop(ts_params->valid_devs[0]);
+
+ return ret;
+}
+
static int
pdcp_proto_testsuite_setup(void)
{
return TEST_SUCCESS;
}
-static int
+int
ut_setup(void)
{
/* Configure and start the device with security feature disabled */
return dev_configure_and_start(0);
}
-static void
+void
ut_teardown(void)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Generate test mbuf data and space for digest */
ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
return TEST_SUCCESS;
}
-static int
-test_blockcipher(enum blockcipher_test_type test_type)
-{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- int status;
-
- status = test_blockcipher_all_tests(ts_params->mbuf_pool,
- ts_params->op_mpool,
- ts_params->session_mpool, ts_params->session_priv_mpool,
- ts_params->valid_devs[0],
- test_type);
-
- if (status == -ENOTSUP)
- return status;
-
- TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
- return TEST_SUCCESS;
-}
-
-static int
-test_AES_cipheronly_all(void)
-{
- return test_blockcipher(BLKCIPHER_AES_CIPHERONLY_TYPE);
-}
-
-static int
-test_AES_docsis_all(void)
-{
- /* Data-path service does not support DOCSIS yet */
- if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
- return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE);
-}
-
-static int
-test_DES_docsis_all(void)
-{
- /* Data-path service does not support DOCSIS yet */
- if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
- return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE);
-}
-
-static int
-test_DES_cipheronly_all(void)
-{
- return test_blockcipher(BLKCIPHER_DES_CIPHERONLY_TYPE);
-}
-
-static int
-test_authonly_all(void)
-{
- return test_blockcipher(BLKCIPHER_AUTHONLY_TYPE);
-}
-
-static int
-test_AES_chain_all(void)
-{
- return test_blockcipher(BLKCIPHER_AES_CHAIN_TYPE);
-}
-
-static int
-test_3DES_chain_all(void)
-{
- return test_blockcipher(BLKCIPHER_3DES_CHAIN_TYPE);
-}
-
-static int
-test_3DES_cipheronly_all(void)
-{
- return test_blockcipher(BLKCIPHER_3DES_CIPHERONLY_TYPE);
-}
-
/* ***** SNOW 3G Tests ***** */
static int
create_wireless_algo_hash_session(uint8_t dev_id,
status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
&ut_params->auth_xform,
ts_params->session_priv_mpool);
+ if (status == -ENOTSUP)
+ return TEST_SKIPPED;
+
TEST_ASSERT_EQUAL(status, 0, "session init failed");
TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
return 0;
status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
&ut_params->cipher_xform,
ts_params->session_priv_mpool);
+ if (status == -ENOTSUP)
+ return TEST_SKIPPED;
+
TEST_ASSERT_EQUAL(status, 0, "session init failed");
TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
return 0;
&ut_params->cipher_xform,
ts_params->session_priv_mpool);
if (status == -ENOTSUP)
- return status;
+ return TEST_SKIPPED;
TEST_ASSERT_EQUAL(status, 0, "session init failed");
return 0;
&ut_params->cipher_xform,
ts_params->session_priv_mpool);
if (status == -ENOTSUP)
- return status;
+ return TEST_SKIPPED;
TEST_ASSERT_EQUAL(status, 0, "session init failed");
TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
ts_params->session_priv_mpool);
if (status == -ENOTSUP)
- return status;
+ return TEST_SKIPPED;
TEST_ASSERT_EQUAL(status, 0, "session init failed");
if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
((tdata->validAuthLenInBits.len % 8) != 0)) {
printf("Device doesn't support NON-Byte Aligned Data.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
((tdata->validAuthLenInBits.len % 8) != 0)) {
printf("Device doesn't support NON-Byte Aligned Data.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather. "
"Test Skipped.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
/* Data-path service does not support OOP */
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs. "
"Test Skipped.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Create KASUMI session */
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
int retval;
unsigned plaintext_pad_len;
unsigned plaintext_len;
+ struct rte_cryptodev_info dev_info;
+
+ rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+ uint64_t feat_flags = dev_info.feature_flags;
+
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ printf("Device does not support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
if (retval < 0)
return retval;
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
+ ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
+ else
+ 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");
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs. "
"Test Skipped.\n");
+ return TEST_SKIPPED;
+ }
+
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ printf("Device does not support RAW data-path APIs.\n");
return -ENOTSUP;
}
if (retval < 0)
return retval;
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
+ ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
+ else
+ ut_params->op = process_crypto_request(ts_params->valid_devs[0],
ut_params->op);
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
((tdata->validDataLenInBits.len % 8) != 0)) {
printf("Device doesn't support NON-Byte Aligned Data.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
if (retval < 0)
return retval;
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
+ ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
+ else
+ ut_params->op = process_crypto_request(ts_params->valid_devs[0],
ut_params->op);
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
uint8_t *plaintext, *ciphertext;
unsigned ciphertext_pad_len;
unsigned ciphertext_len;
+ struct rte_cryptodev_info dev_info;
+
+ rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+ uint64_t feat_flags = dev_info.feature_flags;
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ printf("Device does not support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
if (retval < 0)
return retval;
- ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
+ ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
+ else
+ ut_params->op = process_crypto_request(ts_params->valid_devs[0],
ut_params->op);
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
ut_params->obuf = ut_params->op->sym->m_dst;
((tdata->validAuthLenInBits.len % 8 != 0) ||
(tdata->validDataLenInBits.len % 8 != 0))) {
printf("Device doesn't support NON-Byte Aligned Data.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Check if device supports ZUC EEA3 */
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Check if device supports ZUC EIA3 */
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create ZUC session */
retval = create_zuc_cipher_auth_encrypt_generate_session(
ts_params->valid_devs[0],
tdata);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
tdata->key.data, tdata->key.len,
tdata->auth_iv.len, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (op_mode == OUT_OF_PLACE) {
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Create SNOW 3G session */
tdata->key.data, tdata->key.len,
tdata->auth_iv.len, tdata->digest.len,
tdata->cipher_iv.len);
-
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
tdata->auth_iv.len, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (op_mode == OUT_OF_PLACE) {
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
0, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
0, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_cipher_auth_session(
tdata->key.data, tdata->key.len,
0, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
return 0;
}
+static int
+check_cipher_capability(const struct crypto_testsuite_params *ts_params,
+ const enum rte_crypto_cipher_algorithm cipher_algo,
+ const uint16_t key_size, const uint16_t iv_size)
+{
+ struct rte_cryptodev_sym_capability_idx cap_idx;
+ const struct rte_cryptodev_symmetric_capability *cap;
+
+ /* Check if device supports the algorithm */
+ cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+ cap_idx.algo.cipher = cipher_algo;
+
+ cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+ &cap_idx);
+
+ if (cap == NULL)
+ return -1;
+
+ /* Check if device supports key size and IV size */
+ if (rte_cryptodev_sym_capability_check_cipher(cap, key_size,
+ iv_size) < 0) {
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+check_auth_capability(const struct crypto_testsuite_params *ts_params,
+ const enum rte_crypto_auth_algorithm auth_algo,
+ const uint16_t key_size, const uint16_t iv_size,
+ const uint16_t tag_size)
+{
+ struct rte_cryptodev_sym_capability_idx cap_idx;
+ const struct rte_cryptodev_symmetric_capability *cap;
+
+ /* Check if device supports the algorithm */
+ cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+ cap_idx.algo.auth = auth_algo;
+
+ cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+ &cap_idx);
+
+ if (cap == NULL)
+ return -1;
+
+ /* Check if device supports key size and IV size */
+ if (rte_cryptodev_sym_capability_check_auth(cap, key_size,
+ tag_size, iv_size) < 0) {
+ return -1;
+ }
+
+ return 0;
+}
+
static int
test_zuc_encryption(const struct wireless_test_data *tdata)
{
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
-
- struct rte_cryptodev_sym_capability_idx cap_idx;
+ return TEST_SKIPPED;
/* Check if device supports ZUC EEA3 */
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
-
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
+ if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
+ tdata->key.len, tdata->cipher_iv.len) < 0)
+ return TEST_SKIPPED;
/* Create ZUC session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_ZUC_EEA3,
tdata->key.data, tdata->key.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
uint8_t ciphertext_buffer[2048];
struct rte_cryptodev_info dev_info;
- struct rte_cryptodev_sym_capability_idx cap_idx;
-
/* Check if device supports ZUC EEA3 */
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
-
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
+ if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
+ tdata->key.len, tdata->cipher_iv.len) < 0)
+ return TEST_SKIPPED;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather. "
"Test Skipped.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
plaintext_len = ceil_byte_length(tdata->plaintext.len);
unsigned plaintext_len;
uint8_t *plaintext;
- struct rte_cryptodev_sym_capability_idx cap_idx;
struct rte_cryptodev_info dev_info;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
(tdata->validAuthLenInBits.len % 8 != 0)) {
printf("Device doesn't support NON-Byte Aligned Data.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Check if device supports ZUC EIA3 */
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
-
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
+ if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
+ tdata->key.len, tdata->auth_iv.len,
+ tdata->digest.len) < 0)
+ return TEST_SKIPPED;
/* Create ZUC session */
retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
tdata->auth_iv.len, tdata->digest.len,
RTE_CRYPTO_AUTH_OP_GENERATE,
RTE_CRYPTO_AUTH_ZUC_EIA3);
- if (retval < 0)
+ if (retval != 0)
return retval;
/* alloc mbuf and set payload */
unsigned int ciphertext_len;
struct rte_cryptodev_info dev_info;
- struct rte_cryptodev_sym_capability_idx cap_idx;
- /* Check if device supports ZUC EIA3 */
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
+ /* Check if device supports ZUC EEA3 */
+ if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
+ tdata->key.len, tdata->cipher_iv.len) < 0)
+ return TEST_SKIPPED;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
+ /* Check if device supports ZUC EIA3 */
+ if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
+ tdata->key.len, tdata->auth_iv.len,
+ tdata->digest.len) < 0)
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (op_mode == IN_PLACE) {
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
tdata->auth_iv.len, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
uint8_t digest_buffer[10000];
struct rte_cryptodev_info dev_info;
- struct rte_cryptodev_sym_capability_idx cap_idx;
- /* Check if device supports ZUC EIA3 */
- cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
- cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
+ /* Check if device supports ZUC EEA3 */
+ if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
+ tdata->key.len, tdata->cipher_iv.len) < 0)
+ return TEST_SKIPPED;
- if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
- &cap_idx) == NULL)
- return -ENOTSUP;
+ /* Check if device supports ZUC EIA3 */
+ if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
+ tdata->key.len, tdata->auth_iv.len,
+ tdata->digest.len) < 0)
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
tdata->auth_iv.len, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
{
/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
return test_kasumi_decryption(&kasumi_test_case_3);
}
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support encrypted digest operations.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/*
{
/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
return test_snow3g_auth_cipher_sgl(
&snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
}
{
/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
return test_snow3g_auth_cipher_sgl(
&snow3g_auth_cipher_partial_digest_encryption,
IN_PLACE, 0);
return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
}
+static int
+test_zuc_encryption_test_case_7(void)
+{
+ return test_zuc_encryption(&zuc_test_case_cipher_800b_key_256b);
+}
+
static int
test_zuc_hash_generate_test_case_1(void)
{
return test_zuc_authentication(&zuc_test_case_auth_584b);
}
+static int
+test_zuc_hash_generate_test_case_9(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_584b_mac_64b);
+}
+
+static int
+test_zuc_hash_generate_test_case_10(void)
+{
+ return test_zuc_authentication(&zuc_test_case_auth_2080b_mac_128b);
+}
+
static int
test_zuc_cipher_auth_test_case_1(void)
{
&zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
}
+static int
+test_zuc256_encryption_test_case_1(void)
+{
+ return test_zuc_encryption(&zuc256_test_case_cipher_1);
+}
+
+static int
+test_zuc256_encryption_test_case_2(void)
+{
+ return test_zuc_encryption(&zuc256_test_case_cipher_2);
+}
+
+static int
+test_zuc256_authentication_test_case_1(void)
+{
+ return test_zuc_authentication(&zuc256_test_case_auth_1);
+}
+
+static int
+test_zuc256_authentication_test_case_2(void)
+{
+ return test_zuc_authentication(&zuc256_test_case_auth_2);
+}
+
static int
test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
{
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = tdata->cipher_algo;
if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Check if device supports particular hash algorithm */
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
cap_idx.algo.auth = tdata->auth_algo;
if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
return 0;
}
/* Check if device supports particular algorithms separately */
if (test_mixed_check_if_unsupported(tdata))
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Create the session */
tdata->auth_key.data, tdata->auth_key.len,
tdata->auth_iv.len, tdata->digest_enc.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
printf("Device doesn't support this mixed combination. "
"Test Skipped.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
ut_params->op = op;
/* Check if device supports particular algorithms */
if (test_mixed_check_if_unsupported(tdata))
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
tdata->auth_key.data, tdata->auth_key.len,
tdata->auth_iv.len, tdata->digest_enc.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
printf("Device doesn't support this mixed combination. "
"Test Skipped.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
ut_params->op = op;
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
capability = rte_cryptodev_sym_capability_get(
ts_params->valid_devs[0], &cap_idx);
if (capability == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (rte_cryptodev_sym_capability_check_aead(
capability, tdata->key.len, tdata->auth_tag.len,
tdata->aad.len, tdata->iv.len))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create AEAD session */
retval = create_aead_session(ts_params->valid_devs[0],
sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
sec_cap_idx.pdcp.domain = domain;
if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Generate test mbuf data */
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
int to_trn_tbl[16];
int segs = 1;
unsigned int trn_data = 0;
+ struct rte_cryptodev_info dev_info;
+ uint64_t feat_flags;
struct rte_security_ctx *ctx = (struct rte_security_ctx *)
rte_cryptodev_get_sec_ctx(
ts_params->valid_devs[0]);
+ struct rte_mbuf *temp_mbuf;
+ rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+ feat_flags = dev_info.feature_flags;
+
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ printf("Device does not support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_security_capability_idx sec_cap_idx;
sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (fragsz > input_vec_len)
fragsz = input_vec_len;
ut_params->op->sym->m_dst = ut_params->obuf;
/* Process crypto operation */
- if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
- == NULL) {
+ temp_mbuf = ut_params->op->sym->m_src;
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
+ /* filling lengths */
+ while (temp_mbuf) {
+ ut_params->op->sym->cipher.data.length
+ += temp_mbuf->pkt_len;
+ ut_params->op->sym->auth.data.length
+ += temp_mbuf->pkt_len;
+ temp_mbuf = temp_mbuf->next;
+ }
+ process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
+ ut_params->op, 1, 1, 0, 0);
+ } else {
+ ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+ ut_params->op);
+ }
+ if (ut_params->op == NULL) {
printf("TestCase %s()-%d line %d failed %s: ",
__func__, i, __LINE__,
"failed to process sym crypto op");
int err, all_err = TEST_SUCCESS;
const struct pdcp_sdap_test *cur_test;
- size = ARRAY_SIZE(list_pdcp_sdap_tests);
+ size = RTE_DIM(list_pdcp_sdap_tests);
for (i = 0; i < size; i++) {
cur_test = &list_pdcp_sdap_tests[i];
return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
}
+static int
+test_PDCP_PROTO_short_mac(void)
+{
+ int i = 0, size = 0;
+ int err, all_err = TEST_SUCCESS;
+ const struct pdcp_short_mac_test *cur_test;
+
+ size = RTE_DIM(list_pdcp_smac_tests);
+
+ for (i = 0; i < size; i++) {
+ cur_test = &list_pdcp_smac_tests[i];
+ err = test_pdcp_proto(
+ i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+ RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
+ cur_test->in_len, cur_test->data_out,
+ cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
+ RTE_CRYPTO_CIPHER_NULL, NULL,
+ 0, cur_test->param.auth_alg,
+ cur_test->auth_key, cur_test->param.auth_key_len,
+ 0, cur_test->param.domain, 0, 0,
+ 0, 0, 0);
+ if (err) {
+ printf("\t%d) %s: Short MAC test failed\n",
+ cur_test->test_idx,
+ cur_test->param.name);
+ err = TEST_FAILED;
+ } else {
+ printf("\t%d) %s: Short MAC test PASS\n",
+ cur_test->test_idx,
+ cur_test->param.name);
+ rte_hexdump(stdout, "MAC I",
+ cur_test->data_out + cur_test->in_len + 2,
+ 2);
+ err = TEST_SUCCESS;
+ }
+ all_err += err;
+ }
+
+ printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
+
+ return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
+
+}
+
static int
test_PDCP_SDAP_PROTO_decap_all(void)
{
int err, all_err = TEST_SUCCESS;
const struct pdcp_sdap_test *cur_test;
- size = ARRAY_SIZE(list_pdcp_sdap_tests);
+ size = RTE_DIM(list_pdcp_sdap_tests);
for (i = 0; i < size; i++) {
cur_test = &list_pdcp_sdap_tests[i];
all_err += err;
}
- printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
+ printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
+
+ return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
+}
+
+static int
+test_ipsec_proto_process(const struct ipsec_test_data td[],
+ struct ipsec_test_data res_d[],
+ int nb_td,
+ bool silent,
+ const struct ipsec_test_flags *flags)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct crypto_unittest_params *ut_params = &unittest_params;
+ struct rte_security_capability_idx sec_cap_idx;
+ const struct rte_security_capability *sec_cap;
+ struct rte_security_ipsec_xform ipsec_xform;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ enum rte_security_ipsec_sa_direction dir;
+ struct ipsec_test_data *res_d_tmp = NULL;
+ uint32_t src = RTE_IPV4(192, 168, 1, 0);
+ uint32_t dst = RTE_IPV4(192, 168, 1, 1);
+ int salt_len, i, ret = TEST_SUCCESS;
+ struct rte_security_ctx *ctx;
+ uint8_t *input_text;
+ uint32_t verify;
+
+ ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
+ gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
+
+ /* Use first test data to create session */
+
+ /* Copy IPsec xform */
+ memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
+
+ dir = ipsec_xform.direction;
+ verify = flags->tunnel_hdr_verify;
+
+ if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
+ if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
+ src += 1;
+ else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
+ dst += 1;
+ }
+
+ memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src, sizeof(src));
+ memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst, sizeof(dst));
+
+ ctx = rte_cryptodev_get_sec_ctx(dev_id);
+
+ sec_cap_idx.action = ut_params->type;
+ sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
+ sec_cap_idx.ipsec.proto = ipsec_xform.proto;
+ sec_cap_idx.ipsec.mode = ipsec_xform.mode;
+ sec_cap_idx.ipsec.direction = ipsec_xform.direction;
+
+ if (flags->udp_encap)
+ ipsec_xform.options.udp_encap = 1;
+
+ sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
+ if (sec_cap == NULL)
+ return TEST_SKIPPED;
+
+ /* Copy cipher session parameters */
+ if (td[0].aead) {
+ memcpy(&ut_params->aead_xform, &td[0].xform.aead,
+ sizeof(ut_params->aead_xform));
+ ut_params->aead_xform.aead.key.data = td[0].key.data;
+ ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
+
+ /* Verify crypto capabilities */
+ if (test_ipsec_crypto_caps_aead_verify(
+ sec_cap,
+ &ut_params->aead_xform) != 0) {
+ if (!silent)
+ RTE_LOG(INFO, USER1,
+ "Crypto capabilities not supported\n");
+ return TEST_SKIPPED;
+ }
+ } else {
+ /* Only AEAD supported now */
+ return TEST_SKIPPED;
+ }
+
+ if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
+ return TEST_SKIPPED;
+
+ salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
+ memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
+
+ struct rte_security_session_conf sess_conf = {
+ .action_type = ut_params->type,
+ .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
+ .ipsec = ipsec_xform,
+ .crypto_xform = &ut_params->aead_xform,
+ };
+
+ /* Create security session */
+ ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
+ ts_params->session_mpool,
+ ts_params->session_priv_mpool);
+
+ if (ut_params->sec_session == NULL)
+ return TEST_SKIPPED;
+
+ for (i = 0; i < nb_td; i++) {
+ /* Setup source mbuf payload */
+ ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+ rte_pktmbuf_tailroom(ut_params->ibuf));
+
+ input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+ td[i].input_text.len);
+
+ memcpy(input_text, td[i].input_text.data,
+ td[i].input_text.len);
+
+ /* Generate crypto op data structure */
+ ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+ RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+ if (!ut_params->op) {
+ printf("TestCase %s line %d: %s\n",
+ __func__, __LINE__,
+ "failed to allocate crypto op");
+ ret = TEST_FAILED;
+ goto crypto_op_free;
+ }
+
+ /* Attach session to operation */
+ rte_security_attach_session(ut_params->op,
+ ut_params->sec_session);
+
+ /* Set crypto operation mbufs */
+ ut_params->op->sym->m_src = ut_params->ibuf;
+ ut_params->op->sym->m_dst = NULL;
+
+ /* Copy IV in crypto operation when IV generation is disabled */
+ if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
+ ipsec_xform.options.iv_gen_disable == 1) {
+ uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
+ uint8_t *,
+ IV_OFFSET);
+ int len;
+
+ if (td[i].aead)
+ len = td[i].xform.aead.aead.iv.length;
+ else
+ len = td[i].xform.chain.cipher.cipher.iv.length;
+
+ memcpy(iv, td[i].iv.data, len);
+ }
+
+ /* Process crypto operation */
+ process_crypto_request(dev_id, ut_params->op);
+
+ ret = test_ipsec_status_check(ut_params->op, flags, dir, i + 1);
+ if (ret != TEST_SUCCESS)
+ goto crypto_op_free;
+
+ if (res_d != NULL)
+ res_d_tmp = &res_d[i];
+
+ ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
+ res_d_tmp, silent, flags);
+ if (ret != TEST_SUCCESS)
+ goto crypto_op_free;
+
+ rte_crypto_op_free(ut_params->op);
+ ut_params->op = NULL;
+
+ rte_pktmbuf_free(ut_params->ibuf);
+ ut_params->ibuf = NULL;
+ }
+
+crypto_op_free:
+ rte_crypto_op_free(ut_params->op);
+ ut_params->op = NULL;
+
+ rte_pktmbuf_free(ut_params->ibuf);
+ ut_params->ibuf = NULL;
+
+ if (ut_params->sec_session)
+ rte_security_session_destroy(ctx, ut_params->sec_session);
+ ut_params->sec_session = NULL;
+
+ return ret;
+}
+
+static int
+test_ipsec_proto_known_vec(const void *test_data)
+{
+ struct ipsec_test_data td_outb;
+ struct ipsec_test_flags flags;
+
+ memset(&flags, 0, sizeof(flags));
+
+ memcpy(&td_outb, test_data, sizeof(td_outb));
+
+ /* Disable IV gen to be able to test with known vectors */
+ td_outb.ipsec_xform.options.iv_gen_disable = 1;
+
+ return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
+}
+
+static int
+test_ipsec_proto_known_vec_inb(const void *td_outb)
+{
+ struct ipsec_test_flags flags;
+ struct ipsec_test_data td_inb;
+
+ memset(&flags, 0, sizeof(flags));
+
+ test_ipsec_td_in_from_out(td_outb, &td_inb);
+
+ return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
+}
+
+static int
+test_ipsec_proto_all(const struct ipsec_test_flags *flags)
+{
+ struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
+ struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
+ unsigned int i, nb_pkts = 1, pass_cnt = 0;
+ int ret;
+
+ if (flags->iv_gen ||
+ flags->sa_expiry_pkts_soft ||
+ flags->sa_expiry_pkts_hard)
+ nb_pkts = IPSEC_TEST_PACKETS_MAX;
+
+ for (i = 0; i < RTE_DIM(aead_list); i++) {
+ test_ipsec_td_prepare(&aead_list[i],
+ NULL,
+ flags,
+ td_outb,
+ nb_pkts);
+
+ ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
+ flags);
+ if (ret == TEST_SKIPPED)
+ continue;
+
+ if (ret == TEST_FAILED)
+ return TEST_FAILED;
+
+ test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
+
+ ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
+ flags);
+ if (ret == TEST_SKIPPED)
+ continue;
+
+ if (ret == TEST_FAILED)
+ return TEST_FAILED;
+
+ if (flags->display_alg)
+ test_ipsec_display_alg(&aead_list[i], NULL);
+
+ pass_cnt++;
+ }
+
+ if (pass_cnt > 0)
+ return TEST_SUCCESS;
+ else
+ return TEST_SKIPPED;
+}
+
+static int
+test_ipsec_proto_display_list(const void *data __rte_unused)
+{
+ struct ipsec_test_flags flags;
+
+ memset(&flags, 0, sizeof(flags));
+
+ flags.display_alg = true;
+
+ return test_ipsec_proto_all(&flags);
+}
+
+static int
+test_ipsec_proto_iv_gen(const void *data __rte_unused)
+{
+ struct ipsec_test_flags flags;
+
+ memset(&flags, 0, sizeof(flags));
+
+ flags.iv_gen = true;
+
+ return test_ipsec_proto_all(&flags);
+}
+
+static int
+test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
+{
+ struct ipsec_test_flags flags;
+
+ memset(&flags, 0, sizeof(flags));
+
+ flags.sa_expiry_pkts_soft = true;
+
+ return test_ipsec_proto_all(&flags);
+}
+
+static int
+test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
+{
+ struct ipsec_test_flags flags;
+
+ memset(&flags, 0, sizeof(flags));
+
+ flags.sa_expiry_pkts_hard = true;
+
+ return test_ipsec_proto_all(&flags);
+}
+
+static int
+test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
+{
+ struct ipsec_test_flags flags;
+
+ memset(&flags, 0, sizeof(flags));
+
+ flags.icv_corrupt = true;
+
+ return test_ipsec_proto_all(&flags);
+}
+
+static int
+test_ipsec_proto_udp_encap(const void *data __rte_unused)
+{
+ struct ipsec_test_flags flags;
+
+ memset(&flags, 0, sizeof(flags));
+
+ flags.udp_encap = true;
+
+ return test_ipsec_proto_all(&flags);
+}
+
+static int
+test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
+{
+ struct ipsec_test_flags flags;
+
+ memset(&flags, 0, sizeof(flags));
+
+ flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
+
+ return test_ipsec_proto_all(&flags);
+}
+
+static int
+test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
+{
+ struct ipsec_test_flags flags;
+
+ memset(&flags, 0, sizeof(flags));
+
+ flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
+
+ return test_ipsec_proto_all(&flags);
+}
+
+static int
+test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
+{
+ struct ipsec_test_flags flags;
+
+ memset(&flags, 0, sizeof(flags));
+
+ flags.udp_encap = true;
+ flags.udp_ports_verify = true;
+
+ return test_ipsec_proto_all(&flags);
+}
+
+static int
+test_ipsec_proto_inner_ip_csum(const void *data __rte_unused)
+{
+ struct ipsec_test_flags flags;
- return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
+ memset(&flags, 0, sizeof(flags));
+
+ flags.ip_csum = true;
+
+ return test_ipsec_proto_all(&flags);
+}
+
+static int
+test_ipsec_proto_inner_l4_csum(const void *data __rte_unused)
+{
+ struct ipsec_test_flags flags;
+
+ memset(&flags, 0, sizeof(flags));
+
+ flags.l4_csum = true;
+
+ return test_ipsec_proto_all(&flags);
}
static int
uint64_t feat_flags = dev_info.feature_flags;
if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Set action type */
ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
if (security_proto_supported(ut_params->type,
RTE_SECURITY_PROTOCOL_PDCP) < 0)
- return -ENOTSUP;
+ return TEST_SKIPPED;
status = test_PDCP_PROTO_cplane_encap_all();
status += test_PDCP_PROTO_cplane_decap_all();
status += test_PDCP_PROTO_SGL_oop_128B_32B();
status += test_PDCP_SDAP_PROTO_encap_all();
status += test_PDCP_SDAP_PROTO_decap_all();
+ status += test_PDCP_PROTO_short_mac();
if (status)
return TEST_FAILED;
sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
if (sec_cap == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
RTE_CRYPTO_OP_TYPE_UNDEFINED) {
}
if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Setup source mbuf payload */
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
if (sec_cap == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
RTE_CRYPTO_OP_TYPE_UNDEFINED) {
}
if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Setup source mbuf payload */
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
printf("\t%2d)", n++); \
printf("+++++ PASSED:" #func"\n"); \
p++; \
- } else if (ret == -ENOTSUP) { \
+ } else if (ret == TEST_SKIPPED) { \
printf("\t%2d)", n++); \
- printf("~~~~~ UNSUPP:" #func"\n"); \
- u++; \
+ printf("~~~~~ SKIPPED:" #func"\n"); \
+ s++; \
} else { \
printf("\t%2d)", n++); \
printf("----- FAILED:" #func"\n"); \
static int
test_DOCSIS_PROTO_uplink_all(void)
{
- int p = 0, u = 0, f = 0, n = 0;
+ int p = 0, s = 0, f = 0, n = 0;
TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
if (f)
- printf("## %s: %d passed out of %d (%d unsupported)\n",
- __func__, p, n, u);
+ printf("## %s: %d passed out of %d (%d skipped)\n",
+ __func__, p, n, s);
return f;
};
static int
test_DOCSIS_PROTO_downlink_all(void)
{
- int p = 0, u = 0, f = 0, n = 0;
+ int p = 0, s = 0, f = 0, n = 0;
TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
if (f)
- printf("## %s: %d passed out of %d (%d unsupported)\n",
- __func__, p, n, u);
+ printf("## %s: %d passed out of %d (%d skipped)\n",
+ __func__, p, n, s);
return f;
};
uint64_t feat_flags = dev_info.feature_flags;
if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Set action type */
ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
if (security_proto_supported(ut_params->type,
RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
- return -ENOTSUP;
+ return TEST_SKIPPED;
status = test_DOCSIS_PROTO_uplink_all();
status += test_DOCSIS_PROTO_downlink_all();
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.iv.data[0] += 1;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.plaintext.data[0] += 1;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.ciphertext.data[0] += 1;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.aad.len += 1;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
aad[0] += 1;
tdata.aad.data = aad;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.auth_tag.data[0] += 1;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
capability = rte_cryptodev_sym_capability_get(
ts_params->valid_devs[0], &cap_idx);
if (capability == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (rte_cryptodev_sym_capability_check_aead(
capability, tdata->key.len, tdata->auth_tag.len,
tdata->aad.len, tdata->iv.len))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create AEAD session */
retval = create_aead_session(ts_params->valid_devs[0],
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.iv.data[0] += 1;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.plaintext.data[0] += 1;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.ciphertext.data[0] += 1;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.aad.len += 1;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
return TEST_SUCCESS;
aad[0] += 1;
tdata.aad.data = aad;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.auth_tag.data[0] += 1;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
return TEST_SUCCESS;
int retval;
uint8_t *ciphertext, *auth_tag;
uint16_t plaintext_pad_len;
+ struct rte_cryptodev_info dev_info;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.aead = tdata->algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
- if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+ uint64_t feat_flags = dev_info.feature_flags;
+
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)))
+ return TEST_SKIPPED;
/* not supported with CPU crypto */
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create AEAD session */
retval = create_aead_session(ts_params->valid_devs[0],
ut_params->op->sym->m_dst = ut_params->obuf;
/* Process crypto operation */
- TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
+ ut_params->op, 0, 0, 0, 0);
+ else
+ TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
ut_params->op), "failed to process sym crypto op");
TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
int retval;
uint8_t *plaintext;
+ struct rte_cryptodev_info dev_info;
+
+ rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+ uint64_t feat_flags = dev_info.feature_flags;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.aead = tdata->algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* not supported with CPU crypto and raw data-path APIs*/
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ printf("Device does not support RAW data-path APIs.\n");
+ return TEST_SKIPPED;
+ }
/* Create AEAD session */
retval = create_aead_session(ts_params->valid_devs[0],
ut_params->op->sym->m_dst = ut_params->obuf;
/* Process crypto operation */
- TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
+ ut_params->op, 0, 0, 0, 0);
+ else
+ TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
ut_params->op), "failed to process sym crypto op");
TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
printf("Device doesn't support Sessionless ops.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* not supported with CPU crypto */
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.aead = tdata->algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
printf("Device doesn't support Sessionless ops.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* not supported with CPU crypto */
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.aead = tdata->algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* alloc mbuf and set payload */
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
struct rte_cryptodev_stats stats;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
== -ENOTSUP)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (MD5_HMAC_create_session(ts_params, ut_params,
RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (MD5_HMAC_create_session(ts_params, ut_params,
RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
aes_cbc_key, hmac_sha512_key);
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
sessions = rte_malloc(NULL,
- (sizeof(struct rte_cryptodev_sym_session *) *
- MAX_NB_SESSIONS) + 1, 0);
+ sizeof(struct rte_cryptodev_sym_session *) *
+ (MAX_NB_SESSIONS + 1), 0);
/* Create multiple crypto sessions*/
for (i = 0; i < MAX_NB_SESSIONS; i++) {
}
}
+ sessions[i] = NULL;
/* Next session create should fail */
rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
sessions[i], &ut_params->auth_xform,
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
/* This test is for NULL PMD only */
if (gbl_driver_id != rte_cryptodev_driver_id_get(
RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Setup Cipher Parameters */
ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
/* This test is for NULL PMD only */
if (gbl_driver_id != rte_cryptodev_driver_id_get(
RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Setup Cipher Parameters */
ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
int retval;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
retval = create_gmac_session(ts_params->valid_devs[0],
tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
retval = create_gmac_session(ts_params->valid_devs[0],
tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Check for any input SGL support */
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
(!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
(!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (fragsz > tdata->plaintext.len)
fragsz = tdata->plaintext.len;
ut_params->op->sym->m_src = ut_params->ibuf;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
TEST_ASSERT_NOT_NULL(
process_crypto_request(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = reference->auth_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create session */
else {
ut_params->op = process_crypto_request(ts_params->valid_devs[0],
ut_params->op);
- TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
}
+ if (ut_params->op == NULL)
+ return 0;
+ else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
+ return 0;
- return 0;
+ return -1;
}
static int
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = reference->auth_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create session */
retval = create_auth_cipher_session(ut_params,
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = reference->auth_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = reference->crypto_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create session */
retval = create_auth_cipher_session(ut_params,
}
static int
-test_authenticated_encryt_with_esn(
+test_authenticated_encrypt_with_esn(
struct crypto_testsuite_params *ts_params,
struct crypto_unittest_params *ut_params,
const struct test_crypto_vector *reference)
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = reference->auth_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = reference->crypto_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create session */
memcpy(cipher_key, reference->cipher_key.data,
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = reference->auth_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = reference->crypto_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create session */
memcpy(cipher_key, reference->cipher_key.data,
cap_idx.algo.aead = tdata->algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* OOP not supported with CPU crypto */
if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Detailed check for the particular SGL support flag */
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
unsigned int sgl_in = fragsz < tdata->plaintext.len;
if (sgl_in && (!(dev_info.feature_flags &
RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
- return -ENOTSUP;
+ return TEST_SKIPPED;
uint64_t feat_flags = dev_info.feature_flags;
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
unsigned int sgl_in = fragsz < tdata->plaintext.len;
tdata->plaintext.len;
/* Raw data path API does not support OOP */
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (sgl_in && !sgl_out) {
if (!(dev_info.feature_flags &
RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
- return -ENOTSUP;
+ return TEST_SKIPPED;
} else if (!sgl_in && sgl_out) {
if (!(dev_info.feature_flags &
RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
- return -ENOTSUP;
+ return TEST_SKIPPED;
} else if (sgl_in && sgl_out) {
if (!(dev_info.feature_flags &
RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
/* This test is not for OPENSSL PMD */
if (gbl_driver_id == rte_cryptodev_driver_id_get(
RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
- return -ENOTSUP;
+ return TEST_SKIPPED;
return test_authenticated_encryption_SGL(
&gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
static int
auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
{
- return test_authenticated_encryt_with_esn(
+ return test_authenticated_encrypt_with_esn(
&testsuite_params,
&unittest_params,
&aes128cbc_hmac_sha1_aad_test_vector);
}
static int
-test_scheduler_attach_slave_op(void)
+test_scheduler_attach_worker_op(void)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
uint8_t sched_id = ts_params->valid_devs[0];
- uint32_t nb_devs, i, nb_devs_attached = 0;
+ uint32_t i, nb_devs_attached = 0;
int ret;
char vdev_name[32];
+ unsigned int count = rte_cryptodev_count();
- /* create 2 AESNI_MB if necessary */
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
- if (nb_devs < 2) {
- for (i = nb_devs; i < 2; i++) {
- snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
- i);
- ret = rte_vdev_init(vdev_name, NULL);
+ /* create 2 AESNI_MB vdevs on top of existing devices */
+ for (i = count; i < count + 2; i++) {
+ snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
+ RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
+ i);
+ ret = rte_vdev_init(vdev_name, NULL);
- TEST_ASSERT(ret == 0,
- "Failed to create instance %u of"
- " pmd : %s",
- i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
+ TEST_ASSERT(ret == 0,
+ "Failed to create instance %u of"
+ " pmd : %s",
+ i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
+
+ if (ret < 0) {
+ RTE_LOG(ERR, USER1,
+ "Failed to create 2 AESNI MB PMDs.\n");
+ return TEST_SKIPPED;
}
}
/* attach 2 AESNI_MB cdevs */
- for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
- i++) {
+ for (i = count; i < count + 2; i++) {
struct rte_cryptodev_info info;
unsigned int session_size;
}
static int
-test_scheduler_detach_slave_op(void)
+test_scheduler_detach_worker_op(void)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
uint8_t sched_id = ts_params->valid_devs[0];
static int
scheduler_multicore_testsuite_setup(void)
{
- if (test_scheduler_attach_slave_op() < 0)
+ if (test_scheduler_attach_worker_op() < 0)
return TEST_SKIPPED;
if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
return TEST_SKIPPED;
static int
scheduler_roundrobin_testsuite_setup(void)
{
- if (test_scheduler_attach_slave_op() < 0)
+ if (test_scheduler_attach_worker_op() < 0)
return TEST_SKIPPED;
if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
return TEST_SKIPPED;
static int
scheduler_failover_testsuite_setup(void)
{
- if (test_scheduler_attach_slave_op() < 0)
+ if (test_scheduler_attach_worker_op() < 0)
return TEST_SKIPPED;
if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
return TEST_SKIPPED;
static int
scheduler_pkt_size_distr_testsuite_setup(void)
{
- if (test_scheduler_attach_slave_op() < 0)
+ if (test_scheduler_attach_worker_op() < 0)
return TEST_SKIPPED;
if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
return TEST_SKIPPED;
static void
scheduler_mode_testsuite_teardown(void)
{
- test_scheduler_detach_slave_op();
+ test_scheduler_detach_worker_op();
}
#endif /* RTE_CRYPTO_SCHEDULER */
};
#ifdef RTE_LIB_SECURITY
+static struct unit_test_suite ipsec_proto_testsuite = {
+ .suite_name = "IPsec Proto Unit Test Suite",
+ .setup = ipsec_proto_testsuite_setup,
+ .unit_test_cases = {
+ TEST_CASE_NAMED_WITH_DATA(
+ "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
+ TEST_CASE_NAMED_WITH_DATA(
+ "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
+ TEST_CASE_NAMED_WITH_DATA(
+ "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
+ TEST_CASE_NAMED_WITH_DATA(
+ "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
+ TEST_CASE_NAMED_WITH_DATA(
+ "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
+ TEST_CASE_NAMED_WITH_DATA(
+ "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
+ TEST_CASE_NAMED_ST(
+ "Combined test alg list",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_display_list),
+ TEST_CASE_NAMED_ST(
+ "IV generation",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_iv_gen),
+ TEST_CASE_NAMED_ST(
+ "UDP encapsulation",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_udp_encap),
+ TEST_CASE_NAMED_ST(
+ "UDP encapsulation ports verification test",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_udp_ports_verify),
+ TEST_CASE_NAMED_ST(
+ "SA expiry packets soft",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_sa_exp_pkts_soft),
+ TEST_CASE_NAMED_ST(
+ "SA expiry packets hard",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_sa_exp_pkts_hard),
+ TEST_CASE_NAMED_ST(
+ "Negative test: ICV corruption",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_err_icv_corrupt),
+ TEST_CASE_NAMED_ST(
+ "Tunnel dst addr verification",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_tunnel_dst_addr_verify),
+ TEST_CASE_NAMED_ST(
+ "Tunnel src and dst addr verification",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_tunnel_src_dst_addr_verify),
+ TEST_CASE_NAMED_ST(
+ "Inner IP checksum",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_inner_ip_csum),
+ TEST_CASE_NAMED_ST(
+ "Inner L4 checksum",
+ ut_setup_security, ut_teardown,
+ test_ipsec_proto_inner_l4_csum),
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
+
static struct unit_test_suite pdcp_proto_testsuite = {
.suite_name = "PDCP Proto Unit Test Suite",
.setup = pdcp_proto_testsuite_setup,
test_queue_pair_descriptor_setup),
TEST_CASE_ST(ut_setup, ut_teardown,
test_device_configure_invalid_queue_pair_ids),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
test_zuc_encryption_test_case_5),
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_encryption_test_case_6_sgl),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_encryption_test_case_7),
/** ZUC authenticate (EIA3) */
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_hash_generate_test_case_7),
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_hash_generate_test_case_8),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_generate_test_case_9),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc_hash_generate_test_case_10),
+
/** ZUC alg-chain (EEA3/EIA3) */
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_auth_cipher_verify_test_case_1_sgl),
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
+
+ /** ZUC-256 encrypt only **/
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc256_encryption_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc256_encryption_test_case_2),
+
+ /** ZUC-256 authentication only **/
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc256_authentication_test_case_1),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_zuc256_authentication_test_case_2),
+
TEST_CASES_END()
}
};
test_kasumi_decryption_test_case_5),
TEST_CASE_ST(ut_setup, ut_teardown,
test_kasumi_decryption_test_case_1_oop),
-
TEST_CASE_ST(ut_setup, ut_teardown,
test_kasumi_cipher_auth_test_case_1),
static int
run_cryptodev_testsuite(const char *pmd_name)
{
- uint8_t ret, j, i = 0;
+ uint8_t ret, j, i = 0, blk_start_idx = 0;
+ const enum blockcipher_test_type blk_suites[] = {
+ BLKCIPHER_AES_CHAIN_TYPE,
+ BLKCIPHER_AES_CIPHERONLY_TYPE,
+ BLKCIPHER_AES_DOCSIS_TYPE,
+ BLKCIPHER_3DES_CHAIN_TYPE,
+ BLKCIPHER_3DES_CIPHERONLY_TYPE,
+ BLKCIPHER_DES_CIPHERONLY_TYPE,
+ BLKCIPHER_DES_DOCSIS_TYPE,
+ BLKCIPHER_AUTHONLY_TYPE};
struct unit_test_suite *static_suites[] = {
&cryptodev_multi_session_testsuite,
&cryptodev_null_testsuite,
&cryptodev_negative_hmac_sha1_testsuite,
&cryptodev_gen_testsuite,
#ifdef RTE_LIB_SECURITY
+ &ipsec_proto_testsuite,
&pdcp_proto_testsuite,
&docsis_proto_testsuite,
#endif
if (gbl_driver_id == -1) {
RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
- return TEST_FAILED;
+ return TEST_SKIPPED;
}
ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
- RTE_DIM(static_suites));
+ (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
+ ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
ret = unit_test_suite_runner(&ts);
+ FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
free(ts.unit_test_suites);
return ret;
}
static int
-test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
+require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
+{
+ struct rte_cryptodev_info dev_info;
+ uint8_t i, nb_devs;
+ int driver_id;
+
+ driver_id = rte_cryptodev_driver_id_get(pmd_name);
+ if (driver_id == -1) {
+ RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
+ return TEST_SKIPPED;
+ }
+
+ nb_devs = rte_cryptodev_count();
+ if (nb_devs < 1) {
+ RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
+ return TEST_SKIPPED;
+ }
+
+ for (i = 0; i < nb_devs; i++) {
+ rte_cryptodev_info_get(i, &dev_info);
+ if (dev_info.driver_id == driver_id) {
+ if (!(dev_info.feature_flags & flag)) {
+ RTE_LOG(INFO, USER1, "%s not supported\n",
+ flag_name);
+ return TEST_SKIPPED;
+ }
+ return 0; /* found */
+ }
+ }
+
+ RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
+ return TEST_SKIPPED;
+}
+
+static int
+test_cryptodev_qat(void)
{
return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
}
static int
-test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
+test_cryptodev_virtio(void)
{
return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
}
static int
-test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
+test_cryptodev_aesni_mb(void)
{
return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
}
return rc;
}
+static int
+test_cryptodev_mlx5(void)
+{
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
+}
+
static int
test_cryptodev_null(void)
{
}
static int
-test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
+test_cryptodev_sw_snow3g(void)
{
return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
}
static int
-test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
+test_cryptodev_sw_kasumi(void)
{
return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
}
static int
-test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
+test_cryptodev_sw_zuc(void)
{
return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
}
#ifdef RTE_CRYPTO_SCHEDULER
static int
-test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
+test_cryptodev_scheduler(void)
{
- uint8_t ret, j, i = 0;
+ uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
+ const enum blockcipher_test_type blk_suites[] = {
+ BLKCIPHER_AES_CHAIN_TYPE,
+ BLKCIPHER_AES_CIPHERONLY_TYPE,
+ BLKCIPHER_AUTHONLY_TYPE
+ };
static struct unit_test_suite scheduler_multicore = {
.suite_name = "Scheduler Multicore Unit Test Suite",
.setup = scheduler_multicore_testsuite_setup,
.teardown = scheduler_mode_testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
- TEST_CASES_END()
- }
+ .unit_test_cases = {TEST_CASES_END()}
};
static struct unit_test_suite scheduler_round_robin = {
.suite_name = "Scheduler Round Robin Unit Test Suite",
.setup = scheduler_roundrobin_testsuite_setup,
.teardown = scheduler_mode_testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
- TEST_CASES_END()
- }
+ .unit_test_cases = {TEST_CASES_END()}
};
static struct unit_test_suite scheduler_failover = {
.suite_name = "Scheduler Failover Unit Test Suite",
.setup = scheduler_failover_testsuite_setup,
.teardown = scheduler_mode_testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
- TEST_CASES_END()
- }
+ .unit_test_cases = {TEST_CASES_END()}
};
static struct unit_test_suite scheduler_pkt_size_distr = {
.suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
.setup = scheduler_pkt_size_distr_testsuite_setup,
.teardown = scheduler_mode_testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
- TEST_CASES_END()
- }
+ .unit_test_cases = {TEST_CASES_END()}
};
struct unit_test_suite *sched_mode_suites[] = {
&scheduler_multicore,
static struct unit_test_suite scheduler_config = {
.suite_name = "Crypto Device Scheduler Config Unit Test Suite",
.unit_test_cases = {
- TEST_CASE(test_scheduler_attach_slave_op),
+ TEST_CASE(test_scheduler_attach_worker_op),
TEST_CASE(test_scheduler_mode_multicore_op),
TEST_CASE(test_scheduler_mode_roundrobin_op),
TEST_CASE(test_scheduler_mode_failover_op),
TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
- TEST_CASE(test_scheduler_detach_slave_op),
+ TEST_CASE(test_scheduler_detach_worker_op),
TEST_CASES_END() /**< NULL terminate array */
}
return TEST_SKIPPED;
}
+ for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
+ uint8_t blk_i = 0;
+ sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
+ (struct unit_test_suite *) *
+ (RTE_DIM(blk_suites) + 1));
+ ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
+ blk_suites, RTE_DIM(blk_suites));
+ sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
+ }
+
ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
(RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
ret = unit_test_suite_runner(&ts);
+ for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
+ FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
+ (*sched_mode_suites[sched_i]),
+ RTE_DIM(blk_suites));
+ free(sched_mode_suites[sched_i]->unit_test_suites);
+ }
free(ts.unit_test_suites);
return ret;
}
#endif
static int
-test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
+test_cryptodev_dpaa2_sec(void)
{
return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
}
static int
-test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
+test_cryptodev_dpaa_sec(void)
{
return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
}
}
static int
-test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
+test_cryptodev_caam_jr(void)
{
return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
}
}
static int
-test_cryptodev_qat_raw_api(void /*argv __rte_unused, int argc __rte_unused*/)
+test_cryptodev_qat_raw_api(void)
+{
+ static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
+ int ret;
+
+ ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
+ "RAW API");
+ if (ret)
+ return ret;
+
+ global_api_test_type = CRYPTODEV_RAW_API_TEST;
+ ret = run_cryptodev_testsuite(pmd_name);
+ global_api_test_type = CRYPTODEV_API_TEST;
+
+ return ret;
+}
+
+static int
+test_cryptodev_cn9k(void)
+{
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
+}
+
+static int
+test_cryptodev_cn10k(void)
{
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
+}
+
+static int
+test_cryptodev_dpaa2_sec_raw_api(void)
+{
+ static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
+ int ret;
+
+ ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
+ "RAW API");
+ if (ret)
+ return ret;
+
+ global_api_test_type = CRYPTODEV_RAW_API_TEST;
+ ret = run_cryptodev_testsuite(pmd_name);
+ global_api_test_type = CRYPTODEV_API_TEST;
+
+ return ret;
+}
+
+static int
+test_cryptodev_dpaa_sec_raw_api(void)
+{
+ static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
int ret;
+ ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
+ "RAW API");
+ if (ret)
+ return ret;
+
global_api_test_type = CRYPTODEV_RAW_API_TEST;
- ret = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
+ ret = run_cryptodev_testsuite(pmd_name);
global_api_test_type = CRYPTODEV_API_TEST;
return ret;
}
+REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest,
+ test_cryptodev_dpaa2_sec_raw_api);
+REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest,
+ test_cryptodev_dpaa_sec_raw_api);
REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
test_cryptodev_qat_raw_api);
REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
test_cryptodev_cpu_aesni_gcm);
+REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
+REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
+REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);