X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_cryptodev_asym.c;h=e4b3c211df3e67ac9f300a968f2bad03ec92bdd4;hb=6496922368fe03be9ab4137f2d615dba1a766f39;hp=ea3005b25d26b30136c8267d8847a7f994283638;hpb=c07f19b36ca9e54dad9e63334b4da0b5bf668fdc;p=dpdk.git diff --git a/app/test/test_cryptodev_asym.c b/app/test/test_cryptodev_asym.c index ea3005b25d..e4b3c211df 100644 --- a/app/test/test_cryptodev_asym.c +++ b/app/test/test_cryptodev_asym.c @@ -12,12 +12,13 @@ #include #include -#include #include #include "test_cryptodev.h" #include "test_cryptodev_dh_test_vectors.h" #include "test_cryptodev_dsa_test_vectors.h" +#include "test_cryptodev_ecdsa_test_vectors.h" +#include "test_cryptodev_ecpm_test_vectors.h" #include "test_cryptodev_mod_test_vectors.h" #include "test_cryptodev_rsa_test_vectors.h" #include "test_cryptodev_asym_util.h" @@ -26,10 +27,6 @@ #define TEST_NUM_BUFS 10 #define TEST_NUM_SESSIONS 4 -#ifndef ARRAY_SIZE -#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) -#endif - #ifndef TEST_DATA_SIZE #define TEST_DATA_SIZE 4096 #endif @@ -37,7 +34,7 @@ #define TEST_VECTOR_SIZE 256 static int gbl_driver_id; -struct crypto_testsuite_params { +struct crypto_testsuite_params_asym { struct rte_mempool *op_mpool; struct rte_mempool *session_mpool; struct rte_cryptodev_config conf; @@ -47,13 +44,14 @@ struct crypto_testsuite_params { }; struct crypto_unittest_params { - struct rte_cryptodev_asym_session *sess; + void *sess; struct rte_crypto_op *op; }; union test_case_structure { struct modex_test_data modex; struct modinv_test_data modinv; + struct rsa_test_data_2 rsa_data; }; struct test_cases_array { @@ -64,12 +62,12 @@ static struct test_cases_array test_vector = {0, { NULL } }; static uint32_t test_index; -static struct crypto_testsuite_params testsuite_params = { NULL }; +static struct crypto_testsuite_params_asym testsuite_params = { NULL }; static int -queue_ops_rsa_sign_verify(struct rte_cryptodev_asym_session *sess) +queue_ops_rsa_sign_verify(void *sess) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *op_mpool = ts_params->op_mpool; uint8_t dev_id = ts_params->valid_devs[0]; struct rte_crypto_op *op, *result_op; @@ -94,7 +92,7 @@ queue_ops_rsa_sign_verify(struct rte_cryptodev_asym_session *sess) asym_op->rsa.message.length = rsaplaintext.len; asym_op->rsa.sign.length = 0; asym_op->rsa.sign.data = output_buf; - asym_op->rsa.pad = RTE_CRYPTO_RSA_PADDING_PKCS1_5; + asym_op->rsa.padding.type = RTE_CRYPTO_RSA_PADDING_PKCS1_5; debug_hexdump(stdout, "message", asym_op->rsa.message.data, asym_op->rsa.message.length); @@ -126,7 +124,7 @@ queue_ops_rsa_sign_verify(struct rte_cryptodev_asym_session *sess) /* Verify sign */ asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY; - asym_op->rsa.pad = RTE_CRYPTO_RSA_PADDING_PKCS1_5; + asym_op->rsa.padding.type = RTE_CRYPTO_RSA_PADDING_PKCS1_5; /* Process crypto operation */ if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { @@ -158,9 +156,9 @@ error_exit: } static int -queue_ops_rsa_enc_dec(struct rte_cryptodev_asym_session *sess) +queue_ops_rsa_enc_dec(void *sess) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *op_mpool = ts_params->op_mpool; uint8_t dev_id = ts_params->valid_devs[0]; struct rte_crypto_op *op, *result_op; @@ -185,7 +183,7 @@ queue_ops_rsa_enc_dec(struct rte_cryptodev_asym_session *sess) asym_op->rsa.cipher.data = cipher_buf; asym_op->rsa.cipher.length = 0; asym_op->rsa.message.length = rsaplaintext.len; - asym_op->rsa.pad = RTE_CRYPTO_RSA_PADDING_PKCS1_5; + asym_op->rsa.padding.type = RTE_CRYPTO_RSA_PADDING_PKCS1_5; debug_hexdump(stdout, "message", asym_op->rsa.message.data, asym_op->rsa.message.length); @@ -217,7 +215,7 @@ queue_ops_rsa_enc_dec(struct rte_cryptodev_asym_session *sess) asym_op = result_op->asym; asym_op->rsa.message.length = 0; asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_DECRYPT; - asym_op->rsa.pad = RTE_CRYPTO_RSA_PADDING_PKCS1_5; + asym_op->rsa.padding.type = RTE_CRYPTO_RSA_PADDING_PKCS1_5; /* Process crypto operation */ if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { @@ -246,10 +244,12 @@ error_exit: return status; } static int -test_cryptodev_asym_ver(union test_case_structure *data_tc, - struct rte_crypto_op *result_op) +test_cryptodev_asym_ver(struct rte_crypto_op *op, + struct rte_crypto_asym_xform *xform_tc, + union test_case_structure *data_tc, + struct rte_crypto_op *result_op) { - int status = TEST_SUCCESS; + int status = TEST_FAILED; int ret = 0; uint8_t *data_expected = NULL, *data_received = NULL; size_t data_size = 0; @@ -265,38 +265,57 @@ test_cryptodev_asym_ver(union test_case_structure *data_tc, data_received = result_op->asym->modinv.result.data; data_size = result_op->asym->modinv.result.length; break; + case RTE_CRYPTO_ASYM_XFORM_RSA: + if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_ENCRYPT) { + data_size = xform_tc->rsa.n.length; + data_received = result_op->asym->rsa.cipher.data; + data_expected = data_tc->rsa_data.ct.data; + } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_DECRYPT) { + data_size = xform_tc->rsa.n.length; + data_expected = data_tc->rsa_data.pt.data; + data_received = result_op->asym->rsa.message.data; + } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_SIGN) { + data_size = xform_tc->rsa.n.length; + data_expected = data_tc->rsa_data.sign.data; + data_received = result_op->asym->rsa.sign.data; + } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_VERIFY) { + data_size = xform_tc->rsa.n.length; + data_expected = data_tc->rsa_data.pt.data; + data_received = result_op->asym->rsa.cipher.data; + } + break; case RTE_CRYPTO_ASYM_XFORM_DH: case RTE_CRYPTO_ASYM_XFORM_DSA: - case RTE_CRYPTO_ASYM_XFORM_RSA: case RTE_CRYPTO_ASYM_XFORM_NONE: case RTE_CRYPTO_ASYM_XFORM_UNSPECIFIED: default: break; } ret = memcmp(data_expected, data_received, data_size); - if (ret) - status = TEST_FAILED; + if (!ret && data_size) + status = TEST_SUCCESS; return status; } static int -test_cryptodev_asym_op(struct crypto_testsuite_params *ts_params, +test_cryptodev_asym_op(struct crypto_testsuite_params_asym *ts_params, union test_case_structure *data_tc, - char *test_msg, int sessionless) + char *test_msg, int sessionless, enum rte_crypto_asym_op_type type, + enum rte_crypto_rsa_priv_key_type key_type) { struct rte_crypto_asym_op *asym_op = NULL; struct rte_crypto_op *op = NULL; struct rte_crypto_op *result_op = NULL; struct rte_crypto_asym_xform xform_tc; - struct rte_cryptodev_asym_session *sess = NULL; + void *sess = NULL; struct rte_cryptodev_asym_capability_idx cap_idx; const struct rte_cryptodev_asymmetric_xform_capability *capability; uint8_t dev_id = ts_params->valid_devs[0]; uint8_t input[TEST_DATA_SIZE] = {0}; uint8_t *result = NULL; - int status = TEST_SUCCESS; + int ret, status = TEST_SUCCESS; xform_tc.next = NULL; xform_tc.xform_type = data_tc->modex.xform_type; @@ -307,7 +326,7 @@ test_cryptodev_asym_op(struct crypto_testsuite_params *ts_params, if (capability == NULL) { RTE_LOG(INFO, USER1, "Device doesn't support MODEX. Test Skipped\n"); - return -ENOTSUP; + return TEST_SKIPPED; } /* Generate crypto op data structure */ @@ -368,9 +387,57 @@ test_cryptodev_asym_op(struct crypto_testsuite_params *ts_params, goto error_exit; } break; + case RTE_CRYPTO_ASYM_XFORM_RSA: + result = rte_zmalloc(NULL, data_tc->rsa_data.n.len, 0); + op->asym->rsa.op_type = type; + xform_tc.rsa.e.data = data_tc->rsa_data.e.data; + xform_tc.rsa.e.length = data_tc->rsa_data.e.len; + xform_tc.rsa.n.data = data_tc->rsa_data.n.data; + xform_tc.rsa.n.length = data_tc->rsa_data.n.len; + + if (key_type == RTE_RSA_KEY_TYPE_EXP) { + xform_tc.rsa.d.data = data_tc->rsa_data.d.data; + xform_tc.rsa.d.length = data_tc->rsa_data.d.len; + } else { + xform_tc.rsa.qt.p.data = data_tc->rsa_data.p.data; + xform_tc.rsa.qt.p.length = data_tc->rsa_data.p.len; + xform_tc.rsa.qt.q.data = data_tc->rsa_data.q.data; + xform_tc.rsa.qt.q.length = data_tc->rsa_data.q.len; + xform_tc.rsa.qt.dP.data = data_tc->rsa_data.dP.data; + xform_tc.rsa.qt.dP.length = data_tc->rsa_data.dP.len; + xform_tc.rsa.qt.dQ.data = data_tc->rsa_data.dQ.data; + xform_tc.rsa.qt.dQ.length = data_tc->rsa_data.dQ.len; + xform_tc.rsa.qt.qInv.data = data_tc->rsa_data.qInv.data; + xform_tc.rsa.qt.qInv.length = data_tc->rsa_data.qInv.len; + } + + xform_tc.rsa.key_type = key_type; + op->asym->rsa.padding.type = data_tc->rsa_data.padding; + + if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_ENCRYPT) { + asym_op->rsa.message.data = data_tc->rsa_data.pt.data; + asym_op->rsa.message.length = data_tc->rsa_data.pt.len; + asym_op->rsa.cipher.data = result; + asym_op->rsa.cipher.length = data_tc->rsa_data.n.len; + } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_DECRYPT) { + asym_op->rsa.message.data = result; + asym_op->rsa.message.length = data_tc->rsa_data.n.len; + asym_op->rsa.cipher.data = data_tc->rsa_data.ct.data; + asym_op->rsa.cipher.length = data_tc->rsa_data.ct.len; + } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_SIGN) { + asym_op->rsa.sign.data = result; + asym_op->rsa.sign.length = data_tc->rsa_data.n.len; + asym_op->rsa.message.data = data_tc->rsa_data.pt.data; + asym_op->rsa.message.length = data_tc->rsa_data.pt.len; + } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_VERIFY) { + asym_op->rsa.cipher.data = result; + asym_op->rsa.cipher.length = data_tc->rsa_data.n.len; + asym_op->rsa.sign.data = data_tc->rsa_data.sign.data; + asym_op->rsa.sign.length = data_tc->rsa_data.sign.len; + } + break; case RTE_CRYPTO_ASYM_XFORM_DH: case RTE_CRYPTO_ASYM_XFORM_DSA: - case RTE_CRYPTO_ASYM_XFORM_RSA: case RTE_CRYPTO_ASYM_XFORM_NONE: case RTE_CRYPTO_ASYM_XFORM_UNSPECIFIED: default: @@ -383,22 +450,14 @@ test_cryptodev_asym_op(struct crypto_testsuite_params *ts_params, } if (!sessionless) { - sess = rte_cryptodev_asym_session_create(ts_params->session_mpool); - if (!sess) { + ret = rte_cryptodev_asym_session_create(dev_id, &xform_tc, + ts_params->session_mpool, &sess); + if (ret < 0) { snprintf(test_msg, ASYM_TEST_MSG_LEN, "line %u " "FAILED: %s", __LINE__, "Session creation failed"); - status = TEST_FAILED; - goto error_exit; - } - - if (rte_cryptodev_asym_session_init(dev_id, sess, &xform_tc, - ts_params->session_mpool) < 0) { - snprintf(test_msg, ASYM_TEST_MSG_LEN, - "line %u FAILED: %s", - __LINE__, "unabled to config sym session"); - status = TEST_FAILED; + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } @@ -429,7 +488,7 @@ test_cryptodev_asym_op(struct crypto_testsuite_params *ts_params, goto error_exit; } - if (test_cryptodev_asym_ver(data_tc, result_op) != TEST_SUCCESS) { + if (test_cryptodev_asym_ver(op, &xform_tc, data_tc, result_op) != TEST_SUCCESS) { snprintf(test_msg, ASYM_TEST_MSG_LEN, "line %u FAILED: %s", __LINE__, "Verification failed "); @@ -443,16 +502,13 @@ test_cryptodev_asym_op(struct crypto_testsuite_params *ts_params, snprintf(test_msg, ASYM_TEST_MSG_LEN, "SESSIONLESS PASS"); error_exit: - if (sess != NULL) { - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); - } + if (sess != NULL) + rte_cryptodev_asym_session_free(dev_id, sess); if (op != NULL) rte_crypto_op_free(op); - if (result != NULL) - rte_free(result); + rte_free(result); return status; } @@ -460,18 +516,47 @@ error_exit: static int test_one_case(const void *test_case, int sessionless) { - int status = TEST_SUCCESS; + int status = TEST_SUCCESS, i = 0; char test_msg[ASYM_TEST_MSG_LEN + 1]; /* Map the case to union */ union test_case_structure tc; memcpy(&tc, test_case, sizeof(tc)); - status = test_cryptodev_asym_op(&testsuite_params, &tc, test_msg, - sessionless); - - printf(" %u) TestCase %s %s\n", test_index++, - tc.modex.description, test_msg); + if (tc.modex.xform_type == RTE_CRYPTO_ASYM_XFORM_MODEX + || tc.modex.xform_type == RTE_CRYPTO_ASYM_XFORM_MODINV) { + status = test_cryptodev_asym_op(&testsuite_params, &tc, test_msg, + sessionless, 0, 0); + printf(" %u) TestCase %s %s\n", test_index++, + tc.modex.description, test_msg); + } else { + for (i = 0; i < RTE_CRYPTO_ASYM_OP_LIST_END; i++) { + if (tc.modex.xform_type == RTE_CRYPTO_ASYM_XFORM_RSA) { + if (tc.rsa_data.op_type_flags & (1 << i)) { + if (tc.rsa_data.key_exp) { + status = test_cryptodev_asym_op( + &testsuite_params, &tc, + test_msg, sessionless, i, + RTE_RSA_KEY_TYPE_EXP); + } + if (status) + break; + if (tc.rsa_data.key_qt && (i == + RTE_CRYPTO_ASYM_OP_DECRYPT || + i == RTE_CRYPTO_ASYM_OP_SIGN)) { + status = test_cryptodev_asym_op( + &testsuite_params, + &tc, test_msg, sessionless, i, + RTE_RSA_KEY_TYPE_QT); + } + if (status) + break; + } + } + } + printf(" %u) TestCase %s %s\n", test_index++, + tc.modex.description, test_msg); + } return status; } @@ -481,7 +566,7 @@ load_test_vectors(void) { uint32_t i = 0, v_size = 0; /* Load MODEX vector*/ - v_size = ARRAY_SIZE(modex_test_case); + v_size = RTE_DIM(modex_test_case); for (i = 0; i < v_size; i++) { if (test_vector.size >= (TEST_VECTOR_SIZE)) { RTE_LOG(DEBUG, USER1, @@ -492,7 +577,7 @@ load_test_vectors(void) test_vector.size++; } /* Load MODINV vector*/ - v_size = ARRAY_SIZE(modinv_test_case); + v_size = RTE_DIM(modinv_test_case); for (i = 0; i < v_size; i++) { if (test_vector.size >= (TEST_VECTOR_SIZE)) { RTE_LOG(DEBUG, USER1, @@ -502,6 +587,17 @@ load_test_vectors(void) test_vector.address[test_vector.size] = &modinv_test_case[i]; test_vector.size++; } + /* Load RSA vector*/ + v_size = RTE_DIM(rsa_test_case_list); + for (i = 0; i < v_size; i++) { + if (test_vector.size >= (TEST_VECTOR_SIZE)) { + RTE_LOG(DEBUG, USER1, + "TEST_VECTOR_SIZE too small\n"); + return -1; + } + test_vector.address[test_vector.size] = &rsa_test_case_list[i]; + test_vector.size++; + } return 0; } @@ -509,7 +605,7 @@ static int test_one_by_one(void) { int status = TEST_SUCCESS; - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; uint32_t i = 0; uint8_t dev_id = ts_params->valid_devs[0]; struct rte_cryptodev_info dev_info; @@ -542,12 +638,12 @@ test_one_by_one(void) static int test_rsa_sign_verify(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *sess_mpool = ts_params->session_mpool; uint8_t dev_id = ts_params->valid_devs[0]; - struct rte_cryptodev_asym_session *sess; + void *sess = NULL; struct rte_cryptodev_info dev_info; - int status = TEST_SUCCESS; + int ret, status = TEST_SUCCESS; /* Test case supports op with exponent key only, * Check in PMD feature flag for RSA exponent key type support. @@ -557,31 +653,22 @@ test_rsa_sign_verify(void) RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_EXP)) { RTE_LOG(INFO, USER1, "Device doesn't support sign op with " "exponent key type. Test Skipped\n"); - return -ENOTSUP; + return TEST_SKIPPED; } - sess = rte_cryptodev_asym_session_create(sess_mpool); + ret = rte_cryptodev_asym_session_create(dev_id, &rsa_xform, sess_mpool, &sess); - if (!sess) { + if (ret < 0) { RTE_LOG(ERR, USER1, "Session creation failed for " "sign_verify\n"); - return TEST_FAILED; - } - - if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform, - sess_mpool) < 0) { - RTE_LOG(ERR, USER1, "Unable to config asym session for " - "sign_verify\n"); - status = TEST_FAILED; + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } status = queue_ops_rsa_sign_verify(sess); error_exit: - - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); + rte_cryptodev_asym_session_free(dev_id, sess); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -591,12 +678,12 @@ error_exit: static int test_rsa_enc_dec(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *sess_mpool = ts_params->session_mpool; uint8_t dev_id = ts_params->valid_devs[0]; - struct rte_cryptodev_asym_session *sess; + void *sess = NULL; struct rte_cryptodev_info dev_info; - int status = TEST_SUCCESS; + int ret, status = TEST_SUCCESS; /* Test case supports op with exponent key only, * Check in PMD feature flag for RSA exponent key type support. @@ -606,21 +693,14 @@ test_rsa_enc_dec(void) RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_EXP)) { RTE_LOG(INFO, USER1, "Device doesn't support decrypt op with " "exponent key type. Test skipped\n"); - return -ENOTSUP; + return TEST_SKIPPED; } - sess = rte_cryptodev_asym_session_create(sess_mpool); + ret = rte_cryptodev_asym_session_create(dev_id, &rsa_xform, sess_mpool, &sess); - if (!sess) { + if (ret < 0) { RTE_LOG(ERR, USER1, "Session creation failed for enc_dec\n"); - return TEST_FAILED; - } - - if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform, - sess_mpool) < 0) { - RTE_LOG(ERR, USER1, "Unable to config asym session for " - "enc_dec\n"); - status = TEST_FAILED; + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } @@ -628,8 +708,7 @@ test_rsa_enc_dec(void) error_exit: - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); + rte_cryptodev_asym_session_free(dev_id, sess); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -639,12 +718,12 @@ error_exit: static int test_rsa_sign_verify_crt(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *sess_mpool = ts_params->session_mpool; uint8_t dev_id = ts_params->valid_devs[0]; - struct rte_cryptodev_asym_session *sess; + void *sess = NULL; struct rte_cryptodev_info dev_info; - int status = TEST_SUCCESS; + int ret, status = TEST_SUCCESS; /* Test case supports op with quintuple format key only, * Check im PMD feature flag for RSA quintuple key type support. @@ -653,31 +732,23 @@ test_rsa_sign_verify_crt(void) if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_QT)) { RTE_LOG(INFO, USER1, "Device doesn't support sign op with " "quintuple key type. Test skipped\n"); - return -ENOTSUP; + return TEST_SKIPPED; } - sess = rte_cryptodev_asym_session_create(sess_mpool); + ret = rte_cryptodev_asym_session_create(dev_id, &rsa_xform_crt, sess_mpool, &sess); - if (!sess) { + if (ret < 0) { RTE_LOG(ERR, USER1, "Session creation failed for " "sign_verify_crt\n"); - status = TEST_FAILED; - return status; - } - - if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform_crt, - sess_mpool) < 0) { - RTE_LOG(ERR, USER1, "Unable to config asym session for " - "sign_verify_crt\n"); - status = TEST_FAILED; + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } + status = queue_ops_rsa_sign_verify(sess); error_exit: - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); + rte_cryptodev_asym_session_free(dev_id, sess); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -687,12 +758,12 @@ error_exit: static int test_rsa_enc_dec_crt(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *sess_mpool = ts_params->session_mpool; uint8_t dev_id = ts_params->valid_devs[0]; - struct rte_cryptodev_asym_session *sess; + void *sess = NULL; struct rte_cryptodev_info dev_info; - int status = TEST_SUCCESS; + int ret, status = TEST_SUCCESS; /* Test case supports op with quintuple format key only, * Check in PMD feature flag for RSA quintuple key type support. @@ -701,30 +772,23 @@ test_rsa_enc_dec_crt(void) if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_QT)) { RTE_LOG(INFO, USER1, "Device doesn't support decrypt op with " "quintuple key type. Test skipped\n"); - return -ENOTSUP; + return TEST_SKIPPED; } - sess = rte_cryptodev_asym_session_create(sess_mpool); + ret = rte_cryptodev_asym_session_create(dev_id, &rsa_xform_crt, sess_mpool, &sess); - if (!sess) { + if (ret < 0) { RTE_LOG(ERR, USER1, "Session creation failed for " "enc_dec_crt\n"); - return TEST_FAILED; - } - - if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform_crt, - sess_mpool) < 0) { - RTE_LOG(ERR, USER1, "Unable to config asym session for " - "enc_dec_crt\n"); - status = TEST_FAILED; + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } + status = queue_ops_rsa_enc_dec(sess); error_exit: - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); + rte_cryptodev_asym_session_free(dev_id, sess); TEST_ASSERT_EQUAL(status, 0, "Test failed"); @@ -734,7 +798,7 @@ error_exit: static int testsuite_setup(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS]; struct rte_cryptodev_info info; int ret, dev_id = -1; @@ -746,6 +810,7 @@ testsuite_setup(void) test_vector.size = 0; load_test_vectors(); + /* Device, op pool and session configuration for asymmetric crypto. 8< */ ts_params->op_mpool = rte_crypto_op_pool_create( "CRYPTO_ASYM_OP_POOL", RTE_CRYPTO_OP_TYPE_ASYMMETRIC, @@ -817,7 +882,6 @@ testsuite_setup(void) /* configure qp */ ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; ts_params->qp_conf.mp_session = ts_params->session_mpool; - ts_params->qp_conf.mp_session_private = ts_params->session_mpool; for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) { TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( dev_id, qp_id, &ts_params->qp_conf, @@ -826,31 +890,20 @@ testsuite_setup(void) qp_id, dev_id); } - /* setup asym session pool */ - unsigned int session_size = - rte_cryptodev_asym_get_private_session_size(dev_id); - /* - * Create mempool with TEST_NUM_SESSIONS * 2, - * to include the session headers - */ - ts_params->session_mpool = rte_mempool_create( - "test_asym_sess_mp", - TEST_NUM_SESSIONS * 2, - session_size, - 0, 0, NULL, NULL, NULL, - NULL, SOCKET_ID_ANY, - 0); + ts_params->session_mpool = rte_cryptodev_asym_session_pool_create( + "test_asym_sess_mp", TEST_NUM_SESSIONS, 0, 0, + SOCKET_ID_ANY); TEST_ASSERT_NOT_NULL(ts_params->session_mpool, "session mempool allocation failed"); - + /* >8 End of device, op pool and session configuration for asymmetric crypto section. */ return TEST_SUCCESS; } static void testsuite_teardown(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; if (ts_params->op_mpool != NULL) { RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n", @@ -865,9 +918,9 @@ testsuite_teardown(void) } static int -ut_setup(void) +ut_setup_asym(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; uint16_t qp_id; @@ -899,9 +952,9 @@ ut_setup(void) } static void -ut_teardown(void) +ut_teardown_asym(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_cryptodev_stats stats; rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats); @@ -921,30 +974,36 @@ static inline void print_asym_capa( for (i = 0; i < RTE_CRYPTO_ASYM_OP_LIST_END; i++) { /* check supported operations */ - if (rte_cryptodev_asym_xform_capability_check_optype(capa, i)) - printf(" %s", - rte_crypto_asym_op_strings[i]); + if (rte_cryptodev_asym_xform_capability_check_optype(capa, i)) { + if (capa->xform_type == RTE_CRYPTO_ASYM_XFORM_DH) + printf(" %s", rte_crypto_asym_ke_strings[i]); + else + printf(" %s", rte_crypto_asym_op_strings[i]); } - switch (capa->xform_type) { - case RTE_CRYPTO_ASYM_XFORM_RSA: - case RTE_CRYPTO_ASYM_XFORM_MODINV: - case RTE_CRYPTO_ASYM_XFORM_MODEX: - case RTE_CRYPTO_ASYM_XFORM_DH: - case RTE_CRYPTO_ASYM_XFORM_DSA: - printf(" modlen: min %d max %d increment %d\n", - capa->modlen.min, - capa->modlen.max, - capa->modlen.increment); + } + switch (capa->xform_type) { + case RTE_CRYPTO_ASYM_XFORM_RSA: + case RTE_CRYPTO_ASYM_XFORM_MODINV: + case RTE_CRYPTO_ASYM_XFORM_MODEX: + case RTE_CRYPTO_ASYM_XFORM_DH: + case RTE_CRYPTO_ASYM_XFORM_DSA: + printf(" modlen: min %d max %d increment %d", + capa->modlen.min, + capa->modlen.max, + capa->modlen.increment); + break; + case RTE_CRYPTO_ASYM_XFORM_ECDSA: + case RTE_CRYPTO_ASYM_XFORM_ECPM: + default: break; - default: - break; - } + } + printf("\n"); } static int test_capability(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; uint8_t dev_id = ts_params->valid_devs[0]; struct rte_cryptodev_info dev_info; const struct rte_cryptodev_capabilities *dev_capa; @@ -981,26 +1040,18 @@ test_capability(void) static int test_dh_gen_shared_sec(struct rte_crypto_asym_xform *xfrm) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *op_mpool = ts_params->op_mpool; struct rte_mempool *sess_mpool = ts_params->session_mpool; uint8_t dev_id = ts_params->valid_devs[0]; struct rte_crypto_asym_op *asym_op = NULL; struct rte_crypto_op *op = NULL, *result_op = NULL; - struct rte_cryptodev_asym_session *sess = NULL; - int status = TEST_SUCCESS; + void *sess = NULL; + int ret, status = TEST_SUCCESS; uint8_t output[TEST_DH_MOD_LEN]; struct rte_crypto_asym_xform xform = *xfrm; uint8_t peer[] = "01234567890123456789012345678901234567890123456789"; - sess = rte_cryptodev_asym_session_create(sess_mpool); - if (sess == NULL) { - RTE_LOG(ERR, USER1, - "line %u FAILED: %s", __LINE__, - "Session creation failed"); - status = TEST_FAILED; - goto error_exit; - } /* set up crypto op data structure */ op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC); if (!op) { @@ -1014,8 +1065,8 @@ test_dh_gen_shared_sec(struct rte_crypto_asym_xform *xfrm) asym_op = op->asym; /* Setup a xform and op to generate private key only */ - xform.dh.type = RTE_CRYPTO_ASYM_OP_SHARED_SECRET_COMPUTE; xform.next = NULL; + asym_op->dh.ke_type = RTE_CRYPTO_ASYM_KE_SHARED_SECRET_COMPUTE; asym_op->dh.priv_key.data = dh_test_params.priv_key.data; asym_op->dh.priv_key.length = dh_test_params.priv_key.length; asym_op->dh.pub_key.data = (uint8_t *)peer; @@ -1023,12 +1074,12 @@ test_dh_gen_shared_sec(struct rte_crypto_asym_xform *xfrm) asym_op->dh.shared_secret.data = output; asym_op->dh.shared_secret.length = sizeof(output); - if (rte_cryptodev_asym_session_init(dev_id, sess, &xform, - sess_mpool) < 0) { + ret = rte_cryptodev_asym_session_create(dev_id, &xform, sess_mpool, &sess); + if (ret < 0) { RTE_LOG(ERR, USER1, - "line %u FAILED: %s", - __LINE__, "unabled to config sym session"); - status = TEST_FAILED; + "line %u FAILED: %s", __LINE__, + "Session creation failed"); + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } @@ -1062,10 +1113,8 @@ test_dh_gen_shared_sec(struct rte_crypto_asym_xform *xfrm) asym_op->dh.shared_secret.length); error_exit: - if (sess != NULL) { - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); - } + if (sess != NULL) + rte_cryptodev_asym_session_free(dev_id, sess); if (op != NULL) rte_crypto_op_free(op); return status; @@ -1074,25 +1123,17 @@ error_exit: static int test_dh_gen_priv_key(struct rte_crypto_asym_xform *xfrm) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *op_mpool = ts_params->op_mpool; struct rte_mempool *sess_mpool = ts_params->session_mpool; uint8_t dev_id = ts_params->valid_devs[0]; struct rte_crypto_asym_op *asym_op = NULL; struct rte_crypto_op *op = NULL, *result_op = NULL; - struct rte_cryptodev_asym_session *sess = NULL; - int status = TEST_SUCCESS; + void *sess = NULL; + int ret, status = TEST_SUCCESS; uint8_t output[TEST_DH_MOD_LEN]; struct rte_crypto_asym_xform xform = *xfrm; - sess = rte_cryptodev_asym_session_create(sess_mpool); - if (sess == NULL) { - RTE_LOG(ERR, USER1, - "line %u FAILED: %s", __LINE__, - "Session creation failed"); - status = TEST_FAILED; - goto error_exit; - } /* set up crypto op data structure */ op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC); if (!op) { @@ -1106,17 +1147,17 @@ test_dh_gen_priv_key(struct rte_crypto_asym_xform *xfrm) asym_op = op->asym; /* Setup a xform and op to generate private key only */ - xform.dh.type = RTE_CRYPTO_ASYM_OP_PRIVATE_KEY_GENERATE; xform.next = NULL; + asym_op->dh.ke_type = RTE_CRYPTO_ASYM_KE_PRIV_KEY_GENERATE; asym_op->dh.priv_key.data = output; asym_op->dh.priv_key.length = sizeof(output); - if (rte_cryptodev_asym_session_init(dev_id, sess, &xform, - sess_mpool) < 0) { + ret = rte_cryptodev_asym_session_create(dev_id, &xform, sess_mpool, &sess); + if (ret < 0) { RTE_LOG(ERR, USER1, - "line %u FAILED: %s", - __LINE__, "unabled to config sym session"); - status = TEST_FAILED; + "line %u FAILED: %s", __LINE__, + "Session creation failed"); + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } @@ -1151,10 +1192,8 @@ test_dh_gen_priv_key(struct rte_crypto_asym_xform *xfrm) error_exit: - if (sess != NULL) { - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); - } + if (sess != NULL) + rte_cryptodev_asym_session_free(dev_id, sess); if (op != NULL) rte_crypto_op_free(op); @@ -1165,25 +1204,17 @@ error_exit: static int test_dh_gen_pub_key(struct rte_crypto_asym_xform *xfrm) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *op_mpool = ts_params->op_mpool; struct rte_mempool *sess_mpool = ts_params->session_mpool; uint8_t dev_id = ts_params->valid_devs[0]; struct rte_crypto_asym_op *asym_op = NULL; struct rte_crypto_op *op = NULL, *result_op = NULL; - struct rte_cryptodev_asym_session *sess = NULL; - int status = TEST_SUCCESS; + void *sess = NULL; + int ret, status = TEST_SUCCESS; uint8_t output[TEST_DH_MOD_LEN]; struct rte_crypto_asym_xform xform = *xfrm; - sess = rte_cryptodev_asym_session_create(sess_mpool); - if (sess == NULL) { - RTE_LOG(ERR, USER1, - "line %u FAILED: %s", __LINE__, - "Session creation failed"); - status = TEST_FAILED; - goto error_exit; - } /* set up crypto op data structure */ op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC); if (!op) { @@ -1199,9 +1230,9 @@ test_dh_gen_pub_key(struct rte_crypto_asym_xform *xfrm) * using test private key * */ - xform.dh.type = RTE_CRYPTO_ASYM_OP_PUBLIC_KEY_GENERATE; xform.next = NULL; + asym_op->dh.ke_type = RTE_CRYPTO_ASYM_KE_PUB_KEY_GENERATE; asym_op->dh.pub_key.data = output; asym_op->dh.pub_key.length = sizeof(output); /* load pre-defined private key */ @@ -1210,12 +1241,12 @@ test_dh_gen_pub_key(struct rte_crypto_asym_xform *xfrm) 0); asym_op->dh.priv_key = dh_test_params.priv_key; - if (rte_cryptodev_asym_session_init(dev_id, sess, &xform, - sess_mpool) < 0) { + ret = rte_cryptodev_asym_session_create(dev_id, &xform, sess_mpool, &sess); + if (ret < 0) { RTE_LOG(ERR, USER1, - "line %u FAILED: %s", - __LINE__, "unabled to config sym session"); - status = TEST_FAILED; + "line %u FAILED: %s", __LINE__, + "Session creation failed"); + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } @@ -1251,10 +1282,8 @@ test_dh_gen_pub_key(struct rte_crypto_asym_xform *xfrm) asym_op->dh.priv_key.data, asym_op->dh.priv_key.length); error_exit: - if (sess != NULL) { - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); - } + if (sess != NULL) + rte_cryptodev_asym_session_free(dev_id, sess); if (op != NULL) rte_crypto_op_free(op); @@ -1264,28 +1293,19 @@ error_exit: static int test_dh_gen_kp(struct rte_crypto_asym_xform *xfrm) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *op_mpool = ts_params->op_mpool; struct rte_mempool *sess_mpool = ts_params->session_mpool; uint8_t dev_id = ts_params->valid_devs[0]; struct rte_crypto_asym_op *asym_op = NULL; struct rte_crypto_op *op = NULL, *result_op = NULL; - struct rte_cryptodev_asym_session *sess = NULL; - int status = TEST_SUCCESS; + void *sess = NULL; + int ret, status = TEST_SUCCESS; uint8_t out_pub_key[TEST_DH_MOD_LEN]; uint8_t out_prv_key[TEST_DH_MOD_LEN]; struct rte_crypto_asym_xform pub_key_xform; struct rte_crypto_asym_xform xform = *xfrm; - sess = rte_cryptodev_asym_session_create(sess_mpool); - if (sess == NULL) { - RTE_LOG(ERR, USER1, - "line %u FAILED: %s", __LINE__, - "Session creation failed"); - status = TEST_FAILED; - goto error_exit; - } - /* set up crypto op data structure */ op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC); if (!op) { @@ -1300,21 +1320,22 @@ test_dh_gen_kp(struct rte_crypto_asym_xform *xfrm) /* Setup a xform chain to generate * private key first followed by * public key - */xform.dh.type = RTE_CRYPTO_ASYM_OP_PRIVATE_KEY_GENERATE; + */ pub_key_xform.xform_type = RTE_CRYPTO_ASYM_XFORM_DH; - pub_key_xform.dh.type = RTE_CRYPTO_ASYM_OP_PUBLIC_KEY_GENERATE; xform.next = &pub_key_xform; + asym_op->dh.ke_type = RTE_CRYPTO_ASYM_KE_PUB_KEY_GENERATE; asym_op->dh.pub_key.data = out_pub_key; asym_op->dh.pub_key.length = sizeof(out_pub_key); asym_op->dh.priv_key.data = out_prv_key; - asym_op->dh.priv_key.length = sizeof(out_prv_key); - if (rte_cryptodev_asym_session_init(dev_id, sess, &xform, - sess_mpool) < 0) { + asym_op->dh.priv_key.length = 0; + + ret = rte_cryptodev_asym_session_create(dev_id, &xform, sess_mpool, &sess); + if (ret < 0) { RTE_LOG(ERR, USER1, - "line %u FAILED: %s", - __LINE__, "unabled to config sym session"); - status = TEST_FAILED; + "line %u FAILED: %s", __LINE__, + "Session creation failed"); + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } @@ -1348,10 +1369,8 @@ test_dh_gen_kp(struct rte_crypto_asym_xform *xfrm) out_pub_key, asym_op->dh.pub_key.length); error_exit: - if (sess != NULL) { - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); - } + if (sess != NULL) + rte_cryptodev_asym_session_free(dev_id, sess); if (op != NULL) rte_crypto_op_free(op); @@ -1361,13 +1380,13 @@ error_exit: static int test_mod_inv(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *op_mpool = ts_params->op_mpool; struct rte_mempool *sess_mpool = ts_params->session_mpool; uint8_t dev_id = ts_params->valid_devs[0]; struct rte_crypto_asym_op *asym_op = NULL; struct rte_crypto_op *op = NULL, *result_op = NULL; - struct rte_cryptodev_asym_session *sess = NULL; + void *sess = NULL; int status = TEST_SUCCESS; struct rte_cryptodev_asym_capability_idx cap_idx; const struct rte_cryptodev_asymmetric_xform_capability *capability; @@ -1389,7 +1408,7 @@ test_mod_inv(void) if (capability == NULL) { RTE_LOG(INFO, USER1, "Device doesn't support MOD INV. Test Skipped\n"); - return -ENOTSUP; + return TEST_SKIPPED; } if (rte_cryptodev_asym_xform_capability_check_modlen( @@ -1397,24 +1416,15 @@ test_mod_inv(void) modinv_xform.modinv.modulus.length)) { RTE_LOG(ERR, USER1, "Invalid MODULUS length specified\n"); - return -ENOTSUP; + return TEST_SKIPPED; } - sess = rte_cryptodev_asym_session_create(sess_mpool); - if (!sess) { + ret = rte_cryptodev_asym_session_create(dev_id, &modinv_xform, sess_mpool, &sess); + if (ret < 0) { RTE_LOG(ERR, USER1, "line %u " "FAILED: %s", __LINE__, "Session creation failed"); - status = TEST_FAILED; - goto error_exit; - } - - if (rte_cryptodev_asym_session_init(dev_id, sess, &modinv_xform, - sess_mpool) < 0) { - RTE_LOG(ERR, USER1, - "line %u FAILED: %s", - __LINE__, "unabled to config sym session"); - status = TEST_FAILED; + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } @@ -1469,10 +1479,8 @@ test_mod_inv(void) } error_exit: - if (sess) { - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); - } + if (sess) + rte_cryptodev_asym_session_free(dev_id, sess); if (op) rte_crypto_op_free(op); @@ -1485,13 +1493,13 @@ error_exit: static int test_mod_exp(void) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *op_mpool = ts_params->op_mpool; struct rte_mempool *sess_mpool = ts_params->session_mpool; uint8_t dev_id = ts_params->valid_devs[0]; struct rte_crypto_asym_op *asym_op = NULL; struct rte_crypto_op *op = NULL, *result_op = NULL; - struct rte_cryptodev_asym_session *sess = NULL; + void *sess = NULL; int status = TEST_SUCCESS; struct rte_cryptodev_asym_capability_idx cap_idx; const struct rte_cryptodev_asymmetric_xform_capability *capability; @@ -1514,17 +1522,17 @@ test_mod_exp(void) if (capability == NULL) { RTE_LOG(INFO, USER1, "Device doesn't support MOD EXP. Test Skipped\n"); - return -ENOTSUP; + return TEST_SKIPPED; } if (rte_cryptodev_asym_xform_capability_check_modlen( capability, modex_xform.modex.modulus.length)) { RTE_LOG(ERR, USER1, "Invalid MODULUS length specified\n"); - return -ENOTSUP; + return TEST_SKIPPED; } - /* generate crypto op data structure */ + /* Create op, create session, and process packets. 8< */ op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC); if (!op) { RTE_LOG(ERR, USER1, @@ -1535,22 +1543,13 @@ test_mod_exp(void) goto error_exit; } - sess = rte_cryptodev_asym_session_create(sess_mpool); - if (!sess) { + ret = rte_cryptodev_asym_session_create(dev_id, &modex_xform, sess_mpool, &sess); + if (ret < 0) { RTE_LOG(ERR, USER1, "line %u " "FAILED: %s", __LINE__, "Session creation failed"); - status = TEST_FAILED; - goto error_exit; - } - - if (rte_cryptodev_asym_session_init(dev_id, sess, &modex_xform, - sess_mpool) < 0) { - RTE_LOG(ERR, USER1, - "line %u FAILED: %s", - __LINE__, "unabled to config sym session"); - status = TEST_FAILED; + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } @@ -1583,7 +1582,7 @@ test_mod_exp(void) status = TEST_FAILED; goto error_exit; } - + /* >8 End of create op, create session, and process packets section. */ ret = verify_modexp(mod_exp, result_op); if (ret) { RTE_LOG(ERR, USER1, @@ -1592,10 +1591,8 @@ test_mod_exp(void) } error_exit: - if (sess != NULL) { - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); - } + if (sess != NULL) + rte_cryptodev_asym_session_free(dev_id, sess); if (op != NULL) rte_crypto_op_free(op); @@ -1643,26 +1640,24 @@ test_dh_keygenration(void) } static int -test_dsa_sign(void) +test_dsa_sign(struct rte_crypto_dsa_op_param *dsa_op) { - struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; struct rte_mempool *op_mpool = ts_params->op_mpool; struct rte_mempool *sess_mpool = ts_params->session_mpool; uint8_t dev_id = ts_params->valid_devs[0]; struct rte_crypto_asym_op *asym_op = NULL; struct rte_crypto_op *op = NULL, *result_op = NULL; - struct rte_cryptodev_asym_session *sess = NULL; + void *sess = NULL; int status = TEST_SUCCESS; - uint8_t r[TEST_DH_MOD_LEN]; - uint8_t s[TEST_DH_MOD_LEN]; - uint8_t dgst[] = "35d81554afaad2cf18f3a1770d5fedc4ea5be344"; + int ret; - sess = rte_cryptodev_asym_session_create(sess_mpool); - if (sess == NULL) { + ret = rte_cryptodev_asym_session_create(dev_id, &dsa_xform, sess_mpool, &sess); + if (ret < 0) { RTE_LOG(ERR, USER1, "line %u FAILED: %s", __LINE__, "Session creation failed"); - status = TEST_FAILED; + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; goto error_exit; } /* set up crypto op data structure */ @@ -1676,6 +1671,7 @@ test_dsa_sign(void) goto error_exit; } asym_op = op->asym; + asym_op->dsa = *dsa_op; debug_hexdump(stdout, "p: ", dsa_xform.dsa.p.data, dsa_xform.dsa.p.length); @@ -1686,25 +1682,9 @@ test_dsa_sign(void) debug_hexdump(stdout, "priv_key: ", dsa_xform.dsa.x.data, dsa_xform.dsa.x.length); - if (rte_cryptodev_asym_session_init(dev_id, sess, &dsa_xform, - sess_mpool) < 0) { - RTE_LOG(ERR, USER1, - "line %u FAILED: %s", - __LINE__, "unabled to config sym session"); - status = TEST_FAILED; - goto error_exit; - } - /* attach asymmetric crypto session to crypto operations */ rte_crypto_op_attach_asym_session(op, sess); asym_op->dsa.op_type = RTE_CRYPTO_ASYM_OP_SIGN; - asym_op->dsa.message.data = dgst; - asym_op->dsa.message.length = sizeof(dgst); - asym_op->dsa.r.length = sizeof(r); - asym_op->dsa.r.data = r; - asym_op->dsa.s.length = sizeof(s); - asym_op->dsa.s.data = s; - RTE_LOG(DEBUG, USER1, "Process ASYM operation"); /* Process crypto operation */ @@ -1728,12 +1708,71 @@ test_dsa_sign(void) } asym_op = result_op->asym; + dsa_op->r.length = asym_op->dsa.r.length; + dsa_op->s.length = asym_op->dsa.s.length; debug_hexdump(stdout, "r:", asym_op->dsa.r.data, asym_op->dsa.r.length); debug_hexdump(stdout, "s:", asym_op->dsa.s.data, asym_op->dsa.s.length); +error_exit: + if (sess != NULL) + rte_cryptodev_asym_session_free(dev_id, sess); + if (op != NULL) + rte_crypto_op_free(op); + return status; +} +static int +test_dsa_verify(struct rte_crypto_dsa_op_param *dsa_op) +{ + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; + struct rte_mempool *op_mpool = ts_params->op_mpool; + struct rte_mempool *sess_mpool = ts_params->session_mpool; + uint8_t dev_id = ts_params->valid_devs[0]; + struct rte_crypto_asym_op *asym_op = NULL; + struct rte_crypto_op *op = NULL, *result_op = NULL; + void *sess = NULL; + int status = TEST_SUCCESS; + int ret; + + ret = rte_cryptodev_asym_session_create(dev_id, &dsa_xform, sess_mpool, &sess); + if (ret < 0) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Session creation failed"); + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; + goto error_exit; + } + /* set up crypto op data structure */ + op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC); + if (!op) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", + __LINE__, "Failed to allocate asymmetric crypto " + "operation struct"); + status = TEST_FAILED; + goto error_exit; + } + asym_op = op->asym; + asym_op->dsa = *dsa_op; + + debug_hexdump(stdout, "p: ", dsa_xform.dsa.p.data, + dsa_xform.dsa.p.length); + debug_hexdump(stdout, "q: ", dsa_xform.dsa.q.data, + dsa_xform.dsa.q.length); + debug_hexdump(stdout, "g: ", dsa_xform.dsa.g.data, + dsa_xform.dsa.g.length); + + /* attach asymmetric crypto session to crypto operations */ + rte_crypto_op_attach_asym_session(op, sess); + + debug_hexdump(stdout, "r:", + asym_op->dsa.r.data, asym_op->dsa.r.length); + debug_hexdump(stdout, "s:", + asym_op->dsa.s.data, asym_op->dsa.s.length); + + RTE_LOG(DEBUG, USER1, "Process ASYM verify operation"); /* Test PMD DSA sign verification using signer public key */ asym_op->dsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY; @@ -1768,10 +1807,8 @@ test_dsa_sign(void) status = TEST_FAILED; } error_exit: - if (sess != NULL) { - rte_cryptodev_asym_session_clear(dev_id, sess); - rte_cryptodev_asym_session_free(sess); - } + if (sess != NULL) + rte_cryptodev_asym_session_free(dev_id, sess); if (op != NULL) rte_crypto_op_free(op); return status; @@ -1781,27 +1818,408 @@ static int test_dsa(void) { int status; - status = test_dsa_sign(); - TEST_ASSERT_EQUAL(status, 0, "Test failed"); + uint8_t r[TEST_DH_MOD_LEN]; + uint8_t s[TEST_DH_MOD_LEN]; + struct rte_crypto_dsa_op_param dsa_op; + uint8_t dgst[] = "35d81554afaad2cf18f3a1770d5fedc4ea5be344"; + + dsa_op.message.data = dgst; + dsa_op.message.length = sizeof(dgst); + dsa_op.r.data = r; + dsa_op.s.data = s; + dsa_op.r.length = sizeof(r); + dsa_op.s.length = sizeof(s); + + status = test_dsa_sign(&dsa_op); + TEST_ASSERT_EQUAL(status, 0, "DSA sign test failed"); + status = test_dsa_verify(&dsa_op); + TEST_ASSERT_EQUAL(status, 0, "DSA verify test failed"); return status; } +static int +test_ecdsa_sign_verify(enum curve curve_id) +{ + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; + struct rte_mempool *sess_mpool = ts_params->session_mpool; + struct rte_mempool *op_mpool = ts_params->op_mpool; + struct crypto_testsuite_ecdsa_params input_params; + void *sess = NULL; + uint8_t dev_id = ts_params->valid_devs[0]; + struct rte_crypto_op *result_op = NULL; + uint8_t output_buf_r[TEST_DATA_SIZE]; + uint8_t output_buf_s[TEST_DATA_SIZE]; + struct rte_crypto_asym_xform xform; + struct rte_crypto_asym_op *asym_op; + struct rte_cryptodev_info dev_info; + struct rte_crypto_op *op = NULL; + int ret, status = TEST_SUCCESS; + + switch (curve_id) { + case SECP192R1: + input_params = ecdsa_param_secp192r1; + break; + case SECP224R1: + input_params = ecdsa_param_secp224r1; + break; + case SECP256R1: + input_params = ecdsa_param_secp256r1; + break; + case SECP384R1: + input_params = ecdsa_param_secp384r1; + break; + case SECP521R1: + input_params = ecdsa_param_secp521r1; + break; + default: + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Unsupported curve id\n"); + status = TEST_FAILED; + goto exit; + } + + rte_cryptodev_info_get(dev_id, &dev_info); + + /* Setup crypto op data structure */ + op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC); + if (op == NULL) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Failed to allocate asymmetric crypto " + "operation struct\n"); + status = TEST_FAILED; + goto exit; + } + asym_op = op->asym; + + /* Setup asym xform */ + xform.next = NULL; + xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ECDSA; + xform.ec.curve_id = input_params.curve; + + ret = rte_cryptodev_asym_session_create(dev_id, &xform, sess_mpool, &sess); + if (ret < 0) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Session creation failed\n"); + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; + goto exit; + } + + /* Attach asymmetric crypto session to crypto operations */ + rte_crypto_op_attach_asym_session(op, sess); + + /* Compute sign */ + + /* Populate op with operational details */ + op->asym->ecdsa.op_type = RTE_CRYPTO_ASYM_OP_SIGN; + op->asym->ecdsa.message.data = input_params.digest.data; + op->asym->ecdsa.message.length = input_params.digest.length; + op->asym->ecdsa.k.data = input_params.scalar.data; + op->asym->ecdsa.k.length = input_params.scalar.length; + op->asym->ecdsa.pkey.data = input_params.pkey.data; + op->asym->ecdsa.pkey.length = input_params.pkey.length; + + /* Init out buf */ + op->asym->ecdsa.r.data = output_buf_r; + op->asym->ecdsa.s.data = output_buf_s; + + RTE_LOG(DEBUG, USER1, "Process ASYM operation\n"); + + /* Process crypto operation */ + if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Error sending packet for operation\n"); + status = TEST_FAILED; + goto exit; + } + + while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0) + rte_pause(); + + if (result_op == NULL) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Failed to process asym crypto op\n"); + status = TEST_FAILED; + goto exit; + } + + if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Failed to process asym crypto op\n"); + status = TEST_FAILED; + goto exit; + } + + asym_op = result_op->asym; + + debug_hexdump(stdout, "r:", + asym_op->ecdsa.r.data, asym_op->ecdsa.r.length); + debug_hexdump(stdout, "s:", + asym_op->ecdsa.s.data, asym_op->ecdsa.s.length); + + ret = verify_ecdsa_sign(input_params.sign_r.data, + input_params.sign_s.data, result_op); + if (ret) { + status = TEST_FAILED; + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "ECDSA sign failed.\n"); + goto exit; + } + + /* Verify sign */ + + /* Populate op with operational details */ + op->asym->ecdsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY; + op->asym->ecdsa.q.x.data = input_params.pubkey_qx.data; + op->asym->ecdsa.q.x.length = input_params.pubkey_qx.length; + op->asym->ecdsa.q.y.data = input_params.pubkey_qy.data; + op->asym->ecdsa.q.y.length = input_params.pubkey_qx.length; + op->asym->ecdsa.r.data = asym_op->ecdsa.r.data; + op->asym->ecdsa.r.length = asym_op->ecdsa.r.length; + op->asym->ecdsa.s.data = asym_op->ecdsa.s.data; + op->asym->ecdsa.s.length = asym_op->ecdsa.s.length; + + /* Enqueue sign result for verify */ + if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { + status = TEST_FAILED; + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Error sending packet for operation\n"); + goto exit; + } + + while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0) + rte_pause(); + + if (result_op == NULL) { + status = TEST_FAILED; + goto exit; + } + if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { + status = TEST_FAILED; + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "ECDSA verify failed.\n"); + goto exit; + } + +exit: + if (sess != NULL) + rte_cryptodev_asym_session_free(dev_id, sess); + if (op != NULL) + rte_crypto_op_free(op); + return status; +}; + +static int +test_ecdsa_sign_verify_all_curve(void) +{ + int status, overall_status = TEST_SUCCESS; + enum curve curve_id; + int test_index = 0; + const char *msg; + + for (curve_id = SECP192R1; curve_id < END_OF_CURVE_LIST; curve_id++) { + status = test_ecdsa_sign_verify(curve_id); + if (status == TEST_SUCCESS) { + msg = "succeeded"; + } else { + msg = "failed"; + overall_status = status; + } + printf(" %u) TestCase Sign/Veriy Curve %s %s\n", + test_index ++, curve[curve_id], msg); + } + return overall_status; +} + +static int +test_ecpm(enum curve curve_id) +{ + struct crypto_testsuite_params_asym *ts_params = &testsuite_params; + struct rte_mempool *sess_mpool = ts_params->session_mpool; + struct rte_mempool *op_mpool = ts_params->op_mpool; + struct crypto_testsuite_ecpm_params input_params; + void *sess = NULL; + uint8_t dev_id = ts_params->valid_devs[0]; + struct rte_crypto_op *result_op = NULL; + uint8_t output_buf_x[TEST_DATA_SIZE]; + uint8_t output_buf_y[TEST_DATA_SIZE]; + struct rte_crypto_asym_xform xform; + struct rte_crypto_asym_op *asym_op; + struct rte_cryptodev_info dev_info; + struct rte_crypto_op *op = NULL; + int ret, status = TEST_SUCCESS; + + switch (curve_id) { + case SECP192R1: + input_params = ecpm_param_secp192r1; + break; + case SECP224R1: + input_params = ecpm_param_secp224r1; + break; + case SECP256R1: + input_params = ecpm_param_secp256r1; + break; + case SECP384R1: + input_params = ecpm_param_secp384r1; + break; + case SECP521R1: + input_params = ecpm_param_secp521r1; + break; + default: + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Unsupported curve id\n"); + status = TEST_FAILED; + goto exit; + } + + rte_cryptodev_info_get(dev_id, &dev_info); + + /* Setup crypto op data structure */ + op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC); + if (op == NULL) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Failed to allocate asymmetric crypto " + "operation struct\n"); + status = TEST_FAILED; + goto exit; + } + asym_op = op->asym; + + /* Setup asym xform */ + xform.next = NULL; + xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ECPM; + xform.ec.curve_id = input_params.curve; + + ret = rte_cryptodev_asym_session_create(dev_id, &xform, sess_mpool, &sess); + if (ret < 0) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Session creation failed\n"); + status = (ret == -ENOTSUP) ? TEST_SKIPPED : TEST_FAILED; + goto exit; + } + + /* Attach asymmetric crypto session to crypto operations */ + rte_crypto_op_attach_asym_session(op, sess); + + /* Populate op with operational details */ + op->asym->ecpm.p.x.data = input_params.gen_x.data; + op->asym->ecpm.p.x.length = input_params.gen_x.length; + op->asym->ecpm.p.y.data = input_params.gen_y.data; + op->asym->ecpm.p.y.length = input_params.gen_y.length; + op->asym->ecpm.scalar.data = input_params.privkey.data; + op->asym->ecpm.scalar.length = input_params.privkey.length; + + /* Init out buf */ + op->asym->ecpm.r.x.data = output_buf_x; + op->asym->ecpm.r.y.data = output_buf_y; + + RTE_LOG(DEBUG, USER1, "Process ASYM operation\n"); + + /* Process crypto operation */ + if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Error sending packet for operation\n"); + status = TEST_FAILED; + goto exit; + } + + while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0) + rte_pause(); + + if (result_op == NULL) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Failed to process asym crypto op\n"); + status = TEST_FAILED; + goto exit; + } + + if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "Failed to process asym crypto op\n"); + status = TEST_FAILED; + goto exit; + } + + asym_op = result_op->asym; + + debug_hexdump(stdout, "r x:", + asym_op->ecpm.r.x.data, asym_op->ecpm.r.x.length); + debug_hexdump(stdout, "r y:", + asym_op->ecpm.r.y.data, asym_op->ecpm.r.y.length); + + ret = verify_ecpm(input_params.pubkey_x.data, + input_params.pubkey_y.data, result_op); + if (ret) { + status = TEST_FAILED; + RTE_LOG(ERR, USER1, + "line %u FAILED: %s", __LINE__, + "EC Point Multiplication failed.\n"); + goto exit; + } + +exit: + if (sess != NULL) + rte_cryptodev_asym_session_free(dev_id, sess); + if (op != NULL) + rte_crypto_op_free(op); + return status; +} + +static int +test_ecpm_all_curve(void) +{ + int status, overall_status = TEST_SUCCESS; + enum curve curve_id; + int test_index = 0; + const char *msg; + + for (curve_id = SECP192R1; curve_id < END_OF_CURVE_LIST; curve_id++) { + status = test_ecpm(curve_id); + if (status == TEST_SUCCESS) { + msg = "succeeded"; + } else { + msg = "failed"; + overall_status = status; + } + printf(" %u) TestCase EC Point Mul Curve %s %s\n", + test_index ++, curve[curve_id], msg); + } + return overall_status; +} static struct unit_test_suite cryptodev_openssl_asym_testsuite = { .suite_name = "Crypto Device OPENSSL ASYM Unit Test Suite", .setup = testsuite_setup, .teardown = testsuite_teardown, .unit_test_cases = { - TEST_CASE_ST(ut_setup, ut_teardown, test_capability), - TEST_CASE_ST(ut_setup, ut_teardown, test_dsa), - TEST_CASE_ST(ut_setup, ut_teardown, test_dh_keygenration), - TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_enc_dec), - TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_sign_verify), - TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_enc_dec_crt), - TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_sign_verify_crt), - TEST_CASE_ST(ut_setup, ut_teardown, test_mod_inv), - TEST_CASE_ST(ut_setup, ut_teardown, test_mod_exp), - TEST_CASE_ST(ut_setup, ut_teardown, test_one_by_one), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_capability), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_dsa), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, + test_dh_keygenration), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_rsa_enc_dec), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, + test_rsa_sign_verify), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, + test_rsa_enc_dec_crt), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, + test_rsa_sign_verify_crt), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mod_inv), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mod_exp), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_one_by_one), TEST_CASES_END() /**< NULL terminate unit test array */ } }; @@ -1811,7 +2229,7 @@ static struct unit_test_suite cryptodev_qat_asym_testsuite = { .setup = testsuite_setup, .teardown = testsuite_teardown, .unit_test_cases = { - TEST_CASE_ST(ut_setup, ut_teardown, test_one_by_one), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_one_by_one), TEST_CASES_END() /**< NULL terminate unit test array */ } }; @@ -1821,10 +2239,16 @@ static struct unit_test_suite cryptodev_octeontx_asym_testsuite = { .setup = testsuite_setup, .teardown = testsuite_teardown, .unit_test_cases = { - TEST_CASE_ST(ut_setup, ut_teardown, test_capability), - TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_enc_dec_crt), - TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_sign_verify_crt), - TEST_CASE_ST(ut_setup, ut_teardown, test_mod_exp), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_capability), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, + test_rsa_enc_dec_crt), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, + test_rsa_sign_verify_crt), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, test_mod_exp), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, + test_ecdsa_sign_verify_all_curve), + TEST_CASE_ST(ut_setup_asym, ut_teardown_asym, + test_ecpm_all_curve), TEST_CASES_END() /**< NULL terminate unit test array */ } }; @@ -1836,9 +2260,7 @@ test_cryptodev_openssl_asym(void) RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)); if (gbl_driver_id == -1) { - RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if " - "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled " - "in config file to run this testsuite.\n"); + RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded.\n"); return TEST_FAILED; } @@ -1852,9 +2274,7 @@ test_cryptodev_qat_asym(void) RTE_STR(CRYPTODEV_NAME_QAT_ASYM_PMD)); if (gbl_driver_id == -1) { - RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if " - "CONFIG_RTE_LIBRTE_PMD_QAT_ASYM is enabled " - "in config file to run this testsuite.\n"); + RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n"); return TEST_FAILED; } @@ -1867,25 +2287,33 @@ test_cryptodev_octeontx_asym(void) gbl_driver_id = rte_cryptodev_driver_id_get( RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)); if (gbl_driver_id == -1) { - RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded. Check if " - "CONFIG_RTE_LIBRTE_PMD_OCTEONTX_CRYPTO is " - "enabled in config file to run this " - "testsuite.\n"); + RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded.\n"); return TEST_FAILED; } return unit_test_suite_runner(&cryptodev_octeontx_asym_testsuite); } static int -test_cryptodev_octeontx2_asym(void) +test_cryptodev_cn9k_asym(void) { gbl_driver_id = rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)); + RTE_STR(CRYPTODEV_NAME_CN9K_PMD)); if (gbl_driver_id == -1) { - RTE_LOG(ERR, USER1, "OCTEONTX2 PMD must be loaded. Check if " - "CONFIG_RTE_LIBRTE_PMD_OCTEONTX2_CRYPTO is " - "enabled in config file to run this " - "testsuite.\n"); + RTE_LOG(ERR, USER1, "CN9K PMD must be loaded.\n"); + return TEST_FAILED; + } + + /* Use test suite registered for crypto_octeontx PMD */ + return unit_test_suite_runner(&cryptodev_octeontx_asym_testsuite); +} + +static int +test_cryptodev_cn10k_asym(void) +{ + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_CN10K_PMD)); + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "CN10K PMD must be loaded.\n"); return TEST_FAILED; } @@ -1900,6 +2328,5 @@ REGISTER_TEST_COMMAND(cryptodev_qat_asym_autotest, test_cryptodev_qat_asym); REGISTER_TEST_COMMAND(cryptodev_octeontx_asym_autotest, test_cryptodev_octeontx_asym); - -REGISTER_TEST_COMMAND(cryptodev_octeontx2_asym_autotest, - test_cryptodev_octeontx2_asym); +REGISTER_TEST_COMMAND(cryptodev_cn9k_asym_autotest, test_cryptodev_cn9k_asym); +REGISTER_TEST_COMMAND(cryptodev_cn10k_asym_autotest, test_cryptodev_cn10k_asym);