git.droids-corp.org / dpdk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
test/crypto: check auth parameters
[dpdk.git] / app / test / test_cryptodev.c
diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index 73c6430..f2c3c1f 100644 (file)
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -379,6 +379,7 @@ process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
        }
 
        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;
 
@@ -4210,6 +4211,16 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
        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;
@@ -4265,7 +4276,11 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
        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");
 
@@ -4325,6 +4340,12 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
                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;
+       }
+
        /* Create SNOW 3G session */
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -4359,7 +4380,11 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
        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");
 
@@ -4486,7 +4511,11 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
        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");
 
@@ -4617,7 +4646,16 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
        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;
@@ -4675,7 +4713,11 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
        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;
@@ -5840,6 +5882,61 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
        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)
 {
@@ -5864,14 +5961,9 @@ test_zuc_encryption(const struct wireless_test_data *tdata)
        if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
                return TEST_SKIPPED;
 
-       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)
+       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 */
@@ -5946,14 +6038,9 @@ test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
        uint8_t ciphertext_buffer[2048];
        struct rte_cryptodev_info dev_info;
 
-       struct rte_cryptodev_sym_capability_idx cap_idx;
-
        /* Check if device supports ZUC EEA3 */
-       cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-       cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
-
-       if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
-                       &cap_idx) == NULL)
+       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)
@@ -6047,7 +6134,6 @@ test_zuc_authentication(const struct wireless_test_data *tdata)
        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);
@@ -6069,11 +6155,9 @@ test_zuc_authentication(const struct wireless_test_data *tdata)
                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)
+       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 */
@@ -6145,14 +6229,16 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata,
        unsigned int ciphertext_len;
 
        struct rte_cryptodev_info dev_info;
-       struct rte_cryptodev_sym_capability_idx cap_idx;
 
-       /* Check if device supports ZUC EIA3 */
-       cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-       cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
+       /* 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)
+       /* 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);
@@ -6343,14 +6429,16 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
        uint8_t digest_buffer[10000];
 
        struct rte_cryptodev_info dev_info;
-       struct rte_cryptodev_sym_capability_idx cap_idx;
 
-       /* Check if device supports ZUC EIA3 */
-       cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-       cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
+       /* 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)
+       /* 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);
@@ -12997,10 +13085,13 @@ test_authentication_verify_fail_when_data_corruption(
        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
DPDK repo used for reviews