app/test/test_cryptodev_asym.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Cavium Networks
   3  * Copyright (c) 2019 Intel Corporation
   4  */
   5
   6 #include <rte_bus_vdev.h>
   7 #include <rte_common.h>
   8 #include <rte_hexdump.h>
   9 #include <rte_mbuf.h>
  10 #include <rte_malloc.h>
  11 #include <rte_memcpy.h>
  12 #include <rte_pause.h>
  13
  14 #include <rte_cryptodev.h>
  15 #include <rte_cryptodev_pmd.h>
  16 #include <rte_crypto.h>
  17
  18 #include "test_cryptodev.h"
  19 #include "test_cryptodev_dh_test_vectors.h"
  20 #include "test_cryptodev_dsa_test_vectors.h"
  21 #include "test_cryptodev_ecdsa_test_vectors.h"
  22 #include "test_cryptodev_ecpm_test_vectors.h"
  23 #include "test_cryptodev_mod_test_vectors.h"
  24 #include "test_cryptodev_rsa_test_vectors.h"
  25 #include "test_cryptodev_asym_util.h"
  26 #include "test.h"
  27
  28 #define TEST_NUM_BUFS 10
  29 #define TEST_NUM_SESSIONS 4
  30
  31 #ifndef TEST_DATA_SIZE
  32         #define TEST_DATA_SIZE 4096
  33 #endif
  34 #define ASYM_TEST_MSG_LEN 256
  35 #define TEST_VECTOR_SIZE 256
  36
  37 static int gbl_driver_id;
  38 struct crypto_testsuite_params {
  39         struct rte_mempool *op_mpool;
  40         struct rte_mempool *session_mpool;
  41         struct rte_cryptodev_config conf;
  42         struct rte_cryptodev_qp_conf qp_conf;
  43         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  44         uint8_t valid_dev_count;
  45 };
  46
  47 struct crypto_unittest_params {
  48         struct rte_cryptodev_asym_session *sess;
  49         struct rte_crypto_op *op;
  50 };
  51
  52 union test_case_structure {
  53         struct modex_test_data modex;
  54         struct modinv_test_data modinv;
  55         struct rsa_test_data_2 rsa_data;
  56 };
  57
  58 struct test_cases_array {
  59         uint32_t size;
  60         const void *address[TEST_VECTOR_SIZE];
  61 };
  62 static struct test_cases_array test_vector = {0, { NULL } };
  63
  64 static uint32_t test_index;
  65
  66 static struct crypto_testsuite_params testsuite_params = { NULL };
  67
  68 static int
  69 queue_ops_rsa_sign_verify(struct rte_cryptodev_asym_session *sess)
  70 {
  71         struct crypto_testsuite_params *ts_params = &testsuite_params;
  72         struct rte_mempool *op_mpool = ts_params->op_mpool;
  73         uint8_t dev_id = ts_params->valid_devs[0];
  74         struct rte_crypto_op *op, *result_op;
  75         struct rte_crypto_asym_op *asym_op;
  76         uint8_t output_buf[TEST_DATA_SIZE];
  77         int status = TEST_SUCCESS;
  78
  79         /* Set up crypto op data structure */
  80         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
  81         if (!op) {
  82                 RTE_LOG(ERR, USER1, "Failed to allocate asymmetric crypto "
  83                         "operation struct\n");
  84                 return TEST_FAILED;
  85         }
  86
  87         asym_op = op->asym;
  88
  89         /* Compute sign on the test vector */
  90         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_SIGN;
  91
  92         asym_op->rsa.message.data = rsaplaintext.data;
  93         asym_op->rsa.message.length = rsaplaintext.len;
  94         asym_op->rsa.sign.length = 0;
  95         asym_op->rsa.sign.data = output_buf;
  96         asym_op->rsa.pad = RTE_CRYPTO_RSA_PADDING_PKCS1_5;
  97
  98         debug_hexdump(stdout, "message", asym_op->rsa.message.data,
  99                       asym_op->rsa.message.length);
 100
 101         /* Attach asymmetric crypto session to crypto operations */
 102         rte_crypto_op_attach_asym_session(op, sess);
 103
 104         RTE_LOG(DEBUG, USER1, "Process ASYM operation\n");
 105
 106         /* Process crypto operation */
 107         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 108                 RTE_LOG(ERR, USER1, "Error sending packet for sign\n");
 109                 status = TEST_FAILED;
 110                 goto error_exit;
 111         }
 112
 113         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 114                 rte_pause();
 115
 116         if (result_op == NULL) {
 117                 RTE_LOG(ERR, USER1, "Failed to process sign op\n");
 118                 status = TEST_FAILED;
 119                 goto error_exit;
 120         }
 121
 122         debug_hexdump(stdout, "signed message", asym_op->rsa.sign.data,
 123                       asym_op->rsa.sign.length);
 124         asym_op = result_op->asym;
 125
 126         /* Verify sign */
 127         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY;
 128         asym_op->rsa.pad = RTE_CRYPTO_RSA_PADDING_PKCS1_5;
 129
 130         /* Process crypto operation */
 131         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 132                 RTE_LOG(ERR, USER1, "Error sending packet for verify\n");
 133                 status = TEST_FAILED;
 134                 goto error_exit;
 135         }
 136
 137         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 138                 rte_pause();
 139
 140         if (result_op == NULL) {
 141                 RTE_LOG(ERR, USER1, "Failed to process verify op\n");
 142                 status = TEST_FAILED;
 143                 goto error_exit;
 144         }
 145
 146         status = TEST_SUCCESS;
 147         if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 148                 RTE_LOG(ERR, USER1, "Failed to process sign-verify op\n");
 149                 status = TEST_FAILED;
 150         }
 151
 152 error_exit:
 153
 154         rte_crypto_op_free(op);
 155
 156         return status;
 157 }
 158
 159 static int
 160 queue_ops_rsa_enc_dec(struct rte_cryptodev_asym_session *sess)
 161 {
 162         struct crypto_testsuite_params *ts_params = &testsuite_params;
 163         struct rte_mempool *op_mpool = ts_params->op_mpool;
 164         uint8_t dev_id = ts_params->valid_devs[0];
 165         struct rte_crypto_op *op, *result_op;
 166         struct rte_crypto_asym_op *asym_op;
 167         uint8_t cipher_buf[TEST_DATA_SIZE] = {0};
 168         int ret, status = TEST_SUCCESS;
 169
 170         /* Set up crypto op data structure */
 171         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
 172         if (!op) {
 173                 RTE_LOG(ERR, USER1, "Failed to allocate asymmetric crypto "
 174                         "operation struct\n");
 175                 return TEST_FAILED;
 176         }
 177
 178         asym_op = op->asym;
 179
 180         /* Compute encryption on the test vector */
 181         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_ENCRYPT;
 182
 183         asym_op->rsa.message.data = rsaplaintext.data;
 184         asym_op->rsa.cipher.data = cipher_buf;
 185         asym_op->rsa.cipher.length = 0;
 186         asym_op->rsa.message.length = rsaplaintext.len;
 187         asym_op->rsa.pad = RTE_CRYPTO_RSA_PADDING_PKCS1_5;
 188
 189         debug_hexdump(stdout, "message", asym_op->rsa.message.data,
 190                       asym_op->rsa.message.length);
 191
 192         /* Attach asymmetric crypto session to crypto operations */
 193         rte_crypto_op_attach_asym_session(op, sess);
 194
 195         RTE_LOG(DEBUG, USER1, "Process ASYM operation\n");
 196
 197         /* Process crypto operation */
 198         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 199                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 200                 status = TEST_FAILED;
 201                 goto error_exit;
 202         }
 203
 204         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 205                 rte_pause();
 206
 207         if (result_op == NULL) {
 208                 RTE_LOG(ERR, USER1, "Failed to process encryption op\n");
 209                 status = TEST_FAILED;
 210                 goto error_exit;
 211         }
 212         debug_hexdump(stdout, "encrypted message", asym_op->rsa.message.data,
 213                       asym_op->rsa.message.length);
 214
 215         /* Use the resulted output as decryption Input vector*/
 216         asym_op = result_op->asym;
 217         asym_op->rsa.message.length = 0;
 218         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_DECRYPT;
 219         asym_op->rsa.pad = RTE_CRYPTO_RSA_PADDING_PKCS1_5;
 220
 221         /* Process crypto operation */
 222         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 223                 RTE_LOG(ERR, USER1, "Error sending packet for decryption\n");
 224                 status = TEST_FAILED;
 225                 goto error_exit;
 226         }
 227
 228         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 229                 rte_pause();
 230
 231         if (result_op == NULL) {
 232                 RTE_LOG(ERR, USER1, "Failed to process decryption op\n");
 233                 status = TEST_FAILED;
 234                 goto error_exit;
 235         }
 236         status = TEST_SUCCESS;
 237         ret = rsa_verify(&rsaplaintext, result_op);
 238         if (ret)
 239                 status = TEST_FAILED;
 240
 241 error_exit:
 242
 243         rte_crypto_op_free(op);
 244
 245         return status;
 246 }
 247 static int
 248 test_cryptodev_asym_ver(struct rte_crypto_op *op,
 249                                 struct rte_crypto_asym_xform *xform_tc,
 250                                 union test_case_structure *data_tc,
 251                                 struct rte_crypto_op *result_op)
 252 {
 253         int status = TEST_FAILED;
 254         int ret = 0;
 255         uint8_t *data_expected = NULL, *data_received = NULL;
 256         size_t data_size = 0;
 257
 258         switch (data_tc->modex.xform_type) {
 259         case RTE_CRYPTO_ASYM_XFORM_MODEX:
 260                 data_expected = data_tc->modex.reminder.data;
 261                 data_received = result_op->asym->modex.result.data;
 262                 data_size = result_op->asym->modex.result.length;
 263                 break;
 264         case RTE_CRYPTO_ASYM_XFORM_MODINV:
 265                 data_expected = data_tc->modinv.inverse.data;
 266                 data_received = result_op->asym->modinv.result.data;
 267                 data_size = result_op->asym->modinv.result.length;
 268                 break;
 269         case RTE_CRYPTO_ASYM_XFORM_RSA:
 270                 if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_ENCRYPT) {
 271                         data_size = xform_tc->rsa.n.length;
 272                         data_received = result_op->asym->rsa.cipher.data;
 273                         data_expected = data_tc->rsa_data.ct.data;
 274                 } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_DECRYPT) {
 275                         data_size = xform_tc->rsa.n.length;
 276                         data_expected = data_tc->rsa_data.pt.data;
 277                         data_received = result_op->asym->rsa.message.data;
 278                 } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_SIGN) {
 279                         data_size = xform_tc->rsa.n.length;
 280                         data_expected = data_tc->rsa_data.sign.data;
 281                         data_received = result_op->asym->rsa.sign.data;
 282                 } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_VERIFY) {
 283                         data_size = xform_tc->rsa.n.length;
 284                         data_expected = data_tc->rsa_data.pt.data;
 285                         data_received = result_op->asym->rsa.cipher.data;
 286                 }
 287                 break;
 288         case RTE_CRYPTO_ASYM_XFORM_DH:
 289         case RTE_CRYPTO_ASYM_XFORM_DSA:
 290         case RTE_CRYPTO_ASYM_XFORM_NONE:
 291         case RTE_CRYPTO_ASYM_XFORM_UNSPECIFIED:
 292         default:
 293                 break;
 294         }
 295         ret = memcmp(data_expected, data_received, data_size);
 296         if (!ret && data_size)
 297                 status = TEST_SUCCESS;
 298
 299         return status;
 300 }
 301
 302 static int
 303 test_cryptodev_asym_op(struct crypto_testsuite_params *ts_params,
 304         union test_case_structure *data_tc,
 305         char *test_msg, int sessionless, enum rte_crypto_asym_op_type type,
 306         enum rte_crypto_rsa_priv_key_type key_type)
 307 {
 308         struct rte_crypto_asym_op *asym_op = NULL;
 309         struct rte_crypto_op *op = NULL;
 310         struct rte_crypto_op *result_op = NULL;
 311         struct rte_crypto_asym_xform xform_tc;
 312         struct rte_cryptodev_asym_session *sess = NULL;
 313         struct rte_cryptodev_asym_capability_idx cap_idx;
 314         const struct rte_cryptodev_asymmetric_xform_capability *capability;
 315         uint8_t dev_id = ts_params->valid_devs[0];
 316         uint8_t input[TEST_DATA_SIZE] = {0};
 317         uint8_t *result = NULL;
 318
 319         int status = TEST_SUCCESS;
 320
 321         xform_tc.next = NULL;
 322         xform_tc.xform_type = data_tc->modex.xform_type;
 323
 324         cap_idx.type = xform_tc.xform_type;
 325         capability = rte_cryptodev_asym_capability_get(dev_id, &cap_idx);
 326
 327         if (capability == NULL) {
 328                 RTE_LOG(INFO, USER1,
 329                         "Device doesn't support MODEX. Test Skipped\n");
 330                 return -ENOTSUP;
 331         }
 332
 333         /* Generate crypto op data structure */
 334         op = rte_crypto_op_alloc(ts_params->op_mpool,
 335                 RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
 336
 337         if (!op) {
 338                 snprintf(test_msg, ASYM_TEST_MSG_LEN,
 339                         "line %u FAILED: %s",
 340                         __LINE__, "Failed to allocate asymmetric crypto "
 341                         "operation struct");
 342                 status = TEST_FAILED;
 343                 goto error_exit;
 344         }
 345
 346         asym_op = op->asym;
 347
 348         switch (xform_tc.xform_type) {
 349         case RTE_CRYPTO_ASYM_XFORM_MODEX:
 350                 result = rte_zmalloc(NULL, data_tc->modex.result_len, 0);
 351                 xform_tc.modex.modulus.data = data_tc->modex.modulus.data;
 352                 xform_tc.modex.modulus.length = data_tc->modex.modulus.len;
 353                 xform_tc.modex.exponent.data = data_tc->modex.exponent.data;
 354                 xform_tc.modex.exponent.length = data_tc->modex.exponent.len;
 355                 memcpy(input, data_tc->modex.base.data,
 356                         data_tc->modex.base.len);
 357                 asym_op->modex.base.data = input;
 358                 asym_op->modex.base.length = data_tc->modex.base.len;
 359                 asym_op->modex.result.data = result;
 360                 asym_op->modex.result.length = data_tc->modex.result_len;
 361                 if (rte_cryptodev_asym_xform_capability_check_modlen(capability,
 362                                 xform_tc.modex.modulus.length)) {
 363                         snprintf(test_msg, ASYM_TEST_MSG_LEN,
 364                                 "line %u "
 365                                 "FAILED: %s", __LINE__,
 366                                 "Invalid MODULUS length specified");
 367                         status = TEST_FAILED;
 368                         goto error_exit;
 369                 }
 370                 break;
 371         case RTE_CRYPTO_ASYM_XFORM_MODINV:
 372                 result = rte_zmalloc(NULL, data_tc->modinv.result_len, 0);
 373                 xform_tc.modinv.modulus.data = data_tc->modinv.modulus.data;
 374                 xform_tc.modinv.modulus.length = data_tc->modinv.modulus.len;
 375                 memcpy(input, data_tc->modinv.base.data,
 376                         data_tc->modinv.base.len);
 377                 asym_op->modinv.base.data = input;
 378                 asym_op->modinv.base.length = data_tc->modinv.base.len;
 379                 asym_op->modinv.result.data = result;
 380                 asym_op->modinv.result.length = data_tc->modinv.result_len;
 381                 if (rte_cryptodev_asym_xform_capability_check_modlen(capability,
 382                                 xform_tc.modinv.modulus.length)) {
 383                         snprintf(test_msg, ASYM_TEST_MSG_LEN,
 384                                 "line %u "
 385                                 "FAILED: %s", __LINE__,
 386                                 "Invalid MODULUS length specified");
 387                         status = TEST_FAILED;
 388                         goto error_exit;
 389                 }
 390                 break;
 391         case RTE_CRYPTO_ASYM_XFORM_RSA:
 392                 result = rte_zmalloc(NULL, data_tc->rsa_data.n.len, 0);
 393                 op->asym->rsa.op_type = type;
 394                 xform_tc.rsa.e.data = data_tc->rsa_data.e.data;
 395                 xform_tc.rsa.e.length = data_tc->rsa_data.e.len;
 396                 xform_tc.rsa.n.data = data_tc->rsa_data.n.data;
 397                 xform_tc.rsa.n.length = data_tc->rsa_data.n.len;
 398
 399                 if (key_type == RTE_RSA_KEY_TYPE_EXP) {
 400                         xform_tc.rsa.d.data = data_tc->rsa_data.d.data;
 401                         xform_tc.rsa.d.length = data_tc->rsa_data.d.len;
 402                 } else {
 403                         xform_tc.rsa.qt.p.data = data_tc->rsa_data.p.data;
 404                         xform_tc.rsa.qt.p.length = data_tc->rsa_data.p.len;
 405                         xform_tc.rsa.qt.q.data = data_tc->rsa_data.q.data;
 406                         xform_tc.rsa.qt.q.length = data_tc->rsa_data.q.len;
 407                         xform_tc.rsa.qt.dP.data = data_tc->rsa_data.dP.data;
 408                         xform_tc.rsa.qt.dP.length = data_tc->rsa_data.dP.len;
 409                         xform_tc.rsa.qt.dQ.data = data_tc->rsa_data.dQ.data;
 410                         xform_tc.rsa.qt.dQ.length = data_tc->rsa_data.dQ.len;
 411                         xform_tc.rsa.qt.qInv.data = data_tc->rsa_data.qInv.data;
 412                         xform_tc.rsa.qt.qInv.length = data_tc->rsa_data.qInv.len;
 413                 }
 414
 415                 xform_tc.rsa.key_type = key_type;
 416                 op->asym->rsa.pad = data_tc->rsa_data.padding;
 417
 418                 if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_ENCRYPT) {
 419                         asym_op->rsa.message.data = data_tc->rsa_data.pt.data;
 420                         asym_op->rsa.message.length = data_tc->rsa_data.pt.len;
 421                         asym_op->rsa.cipher.data = result;
 422                         asym_op->rsa.cipher.length = data_tc->rsa_data.n.len;
 423                 } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_DECRYPT) {
 424                         asym_op->rsa.message.data = result;
 425                         asym_op->rsa.message.length = data_tc->rsa_data.n.len;
 426                         asym_op->rsa.cipher.data = data_tc->rsa_data.ct.data;
 427                         asym_op->rsa.cipher.length = data_tc->rsa_data.ct.len;
 428                 } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_SIGN) {
 429                         asym_op->rsa.sign.data = result;
 430                         asym_op->rsa.sign.length = data_tc->rsa_data.n.len;
 431                         asym_op->rsa.message.data = data_tc->rsa_data.pt.data;
 432                         asym_op->rsa.message.length = data_tc->rsa_data.pt.len;
 433                 } else if (op->asym->rsa.op_type == RTE_CRYPTO_ASYM_OP_VERIFY) {
 434                         asym_op->rsa.cipher.data = result;
 435                         asym_op->rsa.cipher.length = data_tc->rsa_data.n.len;
 436                         asym_op->rsa.sign.data = data_tc->rsa_data.sign.data;
 437                         asym_op->rsa.sign.length = data_tc->rsa_data.sign.len;
 438                 }
 439                 break;
 440         case RTE_CRYPTO_ASYM_XFORM_DH:
 441         case RTE_CRYPTO_ASYM_XFORM_DSA:
 442         case RTE_CRYPTO_ASYM_XFORM_NONE:
 443         case RTE_CRYPTO_ASYM_XFORM_UNSPECIFIED:
 444         default:
 445                 snprintf(test_msg, ASYM_TEST_MSG_LEN,
 446                                 "line %u "
 447                                 "FAILED: %s", __LINE__,
 448                                 "Invalid ASYM algorithm specified");
 449                 status = TEST_FAILED;
 450                 goto error_exit;
 451         }
 452
 453         if (!sessionless) {
 454                 sess = rte_cryptodev_asym_session_create(ts_params->session_mpool);
 455                 if (!sess) {
 456                         snprintf(test_msg, ASYM_TEST_MSG_LEN,
 457                                         "line %u "
 458                                         "FAILED: %s", __LINE__,
 459                                         "Session creation failed");
 460                         status = TEST_FAILED;
 461                         goto error_exit;
 462                 }
 463
 464                 if (rte_cryptodev_asym_session_init(dev_id, sess, &xform_tc,
 465                                 ts_params->session_mpool) < 0) {
 466                         snprintf(test_msg, ASYM_TEST_MSG_LEN,
 467                                         "line %u FAILED: %s",
 468                                         __LINE__, "unabled to config sym session");
 469                         status = TEST_FAILED;
 470                         goto error_exit;
 471                 }
 472
 473                 rte_crypto_op_attach_asym_session(op, sess);
 474         } else {
 475                 asym_op->xform = &xform_tc;
 476                 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS;
 477         }
 478         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
 479
 480         /* Process crypto operation */
 481         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 482                 snprintf(test_msg, ASYM_TEST_MSG_LEN,
 483                                 "line %u FAILED: %s",
 484                                 __LINE__, "Error sending packet for operation");
 485                 status = TEST_FAILED;
 486                 goto error_exit;
 487         }
 488
 489         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 490                 rte_pause();
 491
 492         if (result_op == NULL) {
 493                 snprintf(test_msg, ASYM_TEST_MSG_LEN,
 494                                 "line %u FAILED: %s",
 495                                 __LINE__, "Failed to process asym crypto op");
 496                 status = TEST_FAILED;
 497                 goto error_exit;
 498         }
 499
 500         if (test_cryptodev_asym_ver(op, &xform_tc, data_tc, result_op) != TEST_SUCCESS) {
 501                 snprintf(test_msg, ASYM_TEST_MSG_LEN,
 502                         "line %u FAILED: %s",
 503                         __LINE__, "Verification failed ");
 504                 status = TEST_FAILED;
 505                 goto error_exit;
 506         }
 507
 508         if (!sessionless)
 509                 snprintf(test_msg, ASYM_TEST_MSG_LEN, "PASS");
 510         else
 511                 snprintf(test_msg, ASYM_TEST_MSG_LEN, "SESSIONLESS PASS");
 512
 513 error_exit:
 514                 if (sess != NULL) {
 515                         rte_cryptodev_asym_session_clear(dev_id, sess);
 516                         rte_cryptodev_asym_session_free(sess);
 517                 }
 518
 519                 if (op != NULL)
 520                         rte_crypto_op_free(op);
 521
 522                 if (result != NULL)
 523                         rte_free(result);
 524
 525         return status;
 526 }
 527
 528 static int
 529 test_one_case(const void *test_case, int sessionless)
 530 {
 531         int status = TEST_SUCCESS, i = 0;
 532         char test_msg[ASYM_TEST_MSG_LEN + 1];
 533
 534         /* Map the case to union */
 535         union test_case_structure tc;
 536         memcpy(&tc, test_case, sizeof(tc));
 537
 538         if (tc.modex.xform_type == RTE_CRYPTO_ASYM_XFORM_MODEX
 539                         || tc.modex.xform_type == RTE_CRYPTO_ASYM_XFORM_MODINV) {
 540                 status = test_cryptodev_asym_op(&testsuite_params, &tc, test_msg,
 541                                 sessionless, 0, 0);
 542                 printf("  %u) TestCase %s %s\n", test_index++,
 543                         tc.modex.description, test_msg);
 544         } else {
 545                 for (i = 0; i < RTE_CRYPTO_ASYM_OP_LIST_END; i++) {
 546                         if (tc.modex.xform_type == RTE_CRYPTO_ASYM_XFORM_RSA) {
 547                                 if (tc.rsa_data.op_type_flags & (1 << i)) {
 548                                         if (tc.rsa_data.key_exp) {
 549                                                 status = test_cryptodev_asym_op(
 550                                                         &testsuite_params, &tc,
 551                                                         test_msg, sessionless, i,
 552                                                         RTE_RSA_KEY_TYPE_EXP);
 553                                         }
 554                                         if (status)
 555                                                 break;
 556                                         if (tc.rsa_data.key_qt && (i ==
 557                                                         RTE_CRYPTO_ASYM_OP_DECRYPT ||
 558                                                         i == RTE_CRYPTO_ASYM_OP_SIGN)) {
 559                                                 status = test_cryptodev_asym_op(
 560                                                         &testsuite_params,
 561                                                         &tc, test_msg, sessionless, i,
 562                                                         RTE_RSA_KET_TYPE_QT);
 563                                         }
 564                                         if (status)
 565                                                 break;
 566                                 }
 567                         }
 568                 }
 569                 printf("  %u) TestCase %s %s\n", test_index++,
 570                         tc.modex.description, test_msg);
 571         }
 572
 573         return status;
 574 }
 575
 576 static int
 577 load_test_vectors(void)
 578 {
 579         uint32_t i = 0, v_size = 0;
 580         /* Load MODEX vector*/
 581         v_size = RTE_DIM(modex_test_case);
 582         for (i = 0; i < v_size; i++) {
 583                 if (test_vector.size >= (TEST_VECTOR_SIZE)) {
 584                         RTE_LOG(DEBUG, USER1,
 585                                 "TEST_VECTOR_SIZE too small\n");
 586                         return -1;
 587                 }
 588                 test_vector.address[test_vector.size] = &modex_test_case[i];
 589                 test_vector.size++;
 590         }
 591         /* Load MODINV vector*/
 592         v_size = RTE_DIM(modinv_test_case);
 593         for (i = 0; i < v_size; i++) {
 594                 if (test_vector.size >= (TEST_VECTOR_SIZE)) {
 595                         RTE_LOG(DEBUG, USER1,
 596                                 "TEST_VECTOR_SIZE too small\n");
 597                         return -1;
 598                 }
 599                 test_vector.address[test_vector.size] = &modinv_test_case[i];
 600                 test_vector.size++;
 601         }
 602         /* Load RSA vector*/
 603         v_size = RTE_DIM(rsa_test_case_list);
 604         for (i = 0; i < v_size; i++) {
 605                 if (test_vector.size >= (TEST_VECTOR_SIZE)) {
 606                         RTE_LOG(DEBUG, USER1,
 607                                 "TEST_VECTOR_SIZE too small\n");
 608                         return -1;
 609                 }
 610                 test_vector.address[test_vector.size] = &rsa_test_case_list[i];
 611                 test_vector.size++;
 612         }
 613         return 0;
 614 }
 615
 616 static int
 617 test_one_by_one(void)
 618 {
 619         int status = TEST_SUCCESS;
 620         struct crypto_testsuite_params *ts_params = &testsuite_params;
 621         uint32_t i = 0;
 622         uint8_t dev_id = ts_params->valid_devs[0];
 623         struct rte_cryptodev_info dev_info;
 624         int sessionless = 0;
 625
 626         rte_cryptodev_info_get(dev_id, &dev_info);
 627         if ((dev_info.feature_flags &
 628                         RTE_CRYPTODEV_FF_ASYM_SESSIONLESS)) {
 629                 sessionless = 1;
 630         }
 631
 632         /* Go through all test cases */
 633         test_index = 0;
 634         for (i = 0; i < test_vector.size; i++) {
 635                 if (test_one_case(test_vector.address[i], 0) != TEST_SUCCESS)
 636                         status = TEST_FAILED;
 637         }
 638         if (sessionless) {
 639                 for (i = 0; i < test_vector.size; i++) {
 640                         if (test_one_case(test_vector.address[i], 1)
 641                                         != TEST_SUCCESS)
 642                                 status = TEST_FAILED;
 643                 }
 644         }
 645
 646         TEST_ASSERT_EQUAL(status, 0, "Test failed");
 647         return status;
 648 }
 649
 650 static int
 651 test_rsa_sign_verify(void)
 652 {
 653         struct crypto_testsuite_params *ts_params = &testsuite_params;
 654         struct rte_mempool *sess_mpool = ts_params->session_mpool;
 655         uint8_t dev_id = ts_params->valid_devs[0];
 656         struct rte_cryptodev_asym_session *sess;
 657         struct rte_cryptodev_info dev_info;
 658         int status = TEST_SUCCESS;
 659
 660         /* Test case supports op with exponent key only,
 661          * Check in PMD feature flag for RSA exponent key type support.
 662          */
 663         rte_cryptodev_info_get(dev_id, &dev_info);
 664         if (!(dev_info.feature_flags &
 665                                 RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_EXP)) {
 666                 RTE_LOG(INFO, USER1, "Device doesn't support sign op with "
 667                         "exponent key type. Test Skipped\n");
 668                 return -ENOTSUP;
 669         }
 670
 671         sess = rte_cryptodev_asym_session_create(sess_mpool);
 672
 673         if (!sess) {
 674                 RTE_LOG(ERR, USER1, "Session creation failed for "
 675                         "sign_verify\n");
 676                 return TEST_FAILED;
 677         }
 678
 679         if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform,
 680                                 sess_mpool) < 0) {
 681                 RTE_LOG(ERR, USER1, "Unable to config asym session for "
 682                         "sign_verify\n");
 683                 status = TEST_FAILED;
 684                 goto error_exit;
 685         }
 686
 687         status = queue_ops_rsa_sign_verify(sess);
 688
 689 error_exit:
 690
 691         rte_cryptodev_asym_session_clear(dev_id, sess);
 692         rte_cryptodev_asym_session_free(sess);
 693
 694         TEST_ASSERT_EQUAL(status, 0, "Test failed");
 695
 696         return status;
 697 }
 698
 699 static int
 700 test_rsa_enc_dec(void)
 701 {
 702         struct crypto_testsuite_params *ts_params = &testsuite_params;
 703         struct rte_mempool *sess_mpool = ts_params->session_mpool;
 704         uint8_t dev_id = ts_params->valid_devs[0];
 705         struct rte_cryptodev_asym_session *sess;
 706         struct rte_cryptodev_info dev_info;
 707         int status = TEST_SUCCESS;
 708
 709         /* Test case supports op with exponent key only,
 710          * Check in PMD feature flag for RSA exponent key type support.
 711          */
 712         rte_cryptodev_info_get(dev_id, &dev_info);
 713         if (!(dev_info.feature_flags &
 714                                 RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_EXP)) {
 715                 RTE_LOG(INFO, USER1, "Device doesn't support decrypt op with "
 716                         "exponent key type. Test skipped\n");
 717                 return -ENOTSUP;
 718         }
 719
 720         sess = rte_cryptodev_asym_session_create(sess_mpool);
 721
 722         if (!sess) {
 723                 RTE_LOG(ERR, USER1, "Session creation failed for enc_dec\n");
 724                 return TEST_FAILED;
 725         }
 726
 727         if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform,
 728                                 sess_mpool) < 0) {
 729                 RTE_LOG(ERR, USER1, "Unable to config asym session for "
 730                         "enc_dec\n");
 731                 status = TEST_FAILED;
 732                 goto error_exit;
 733         }
 734
 735         status = queue_ops_rsa_enc_dec(sess);
 736
 737 error_exit:
 738
 739         rte_cryptodev_asym_session_clear(dev_id, sess);
 740         rte_cryptodev_asym_session_free(sess);
 741
 742         TEST_ASSERT_EQUAL(status, 0, "Test failed");
 743
 744         return status;
 745 }
 746
 747 static int
 748 test_rsa_sign_verify_crt(void)
 749 {
 750         struct crypto_testsuite_params *ts_params = &testsuite_params;
 751         struct rte_mempool *sess_mpool = ts_params->session_mpool;
 752         uint8_t dev_id = ts_params->valid_devs[0];
 753         struct rte_cryptodev_asym_session *sess;
 754         struct rte_cryptodev_info dev_info;
 755         int status = TEST_SUCCESS;
 756
 757         /* Test case supports op with quintuple format key only,
 758          * Check im PMD feature flag for RSA quintuple key type support.
 759          */
 760         rte_cryptodev_info_get(dev_id, &dev_info);
 761         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_QT)) {
 762                 RTE_LOG(INFO, USER1, "Device doesn't support sign op with "
 763                         "quintuple key type. Test skipped\n");
 764                 return -ENOTSUP;
 765         }
 766
 767         sess = rte_cryptodev_asym_session_create(sess_mpool);
 768
 769         if (!sess) {
 770                 RTE_LOG(ERR, USER1, "Session creation failed for "
 771                         "sign_verify_crt\n");
 772                 status = TEST_FAILED;
 773                 return status;
 774         }
 775
 776         if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform_crt,
 777                                 sess_mpool) < 0) {
 778                 RTE_LOG(ERR, USER1, "Unable to config asym session for "
 779                         "sign_verify_crt\n");
 780                 status = TEST_FAILED;
 781                 goto error_exit;
 782         }
 783         status = queue_ops_rsa_sign_verify(sess);
 784
 785 error_exit:
 786
 787         rte_cryptodev_asym_session_clear(dev_id, sess);
 788         rte_cryptodev_asym_session_free(sess);
 789
 790         TEST_ASSERT_EQUAL(status, 0, "Test failed");
 791
 792         return status;
 793 }
 794
 795 static int
 796 test_rsa_enc_dec_crt(void)
 797 {
 798         struct crypto_testsuite_params *ts_params = &testsuite_params;
 799         struct rte_mempool *sess_mpool = ts_params->session_mpool;
 800         uint8_t dev_id = ts_params->valid_devs[0];
 801         struct rte_cryptodev_asym_session *sess;
 802         struct rte_cryptodev_info dev_info;
 803         int status = TEST_SUCCESS;
 804
 805         /* Test case supports op with quintuple format key only,
 806          * Check in PMD feature flag for RSA quintuple key type support.
 807          */
 808         rte_cryptodev_info_get(dev_id, &dev_info);
 809         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_QT)) {
 810                 RTE_LOG(INFO, USER1, "Device doesn't support decrypt op with "
 811                         "quintuple key type. Test skipped\n");
 812                 return -ENOTSUP;
 813         }
 814
 815         sess = rte_cryptodev_asym_session_create(sess_mpool);
 816
 817         if (!sess) {
 818                 RTE_LOG(ERR, USER1, "Session creation failed for "
 819                         "enc_dec_crt\n");
 820                 return TEST_FAILED;
 821         }
 822
 823         if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform_crt,
 824                                 sess_mpool) < 0) {
 825                 RTE_LOG(ERR, USER1, "Unable to config asym session for "
 826                         "enc_dec_crt\n");
 827                 status = TEST_FAILED;
 828                 goto error_exit;
 829         }
 830         status = queue_ops_rsa_enc_dec(sess);
 831
 832 error_exit:
 833
 834         rte_cryptodev_asym_session_clear(dev_id, sess);
 835         rte_cryptodev_asym_session_free(sess);
 836
 837         TEST_ASSERT_EQUAL(status, 0, "Test failed");
 838
 839         return status;
 840 }
 841
 842 static int
 843 testsuite_setup(void)
 844 {
 845         struct crypto_testsuite_params *ts_params = &testsuite_params;
 846         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
 847         struct rte_cryptodev_info info;
 848         int ret, dev_id = -1;
 849         uint32_t i, nb_devs;
 850         uint16_t qp_id;
 851
 852         memset(ts_params, 0, sizeof(*ts_params));
 853
 854         test_vector.size = 0;
 855         load_test_vectors();
 856
 857         ts_params->op_mpool = rte_crypto_op_pool_create(
 858                         "CRYPTO_ASYM_OP_POOL",
 859                         RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
 860                         TEST_NUM_BUFS, 0,
 861                         0,
 862                         rte_socket_id());
 863         if (ts_params->op_mpool == NULL) {
 864                 RTE_LOG(ERR, USER1, "Can't create ASYM_CRYPTO_OP_POOL\n");
 865                 return TEST_FAILED;
 866         }
 867
 868         /* Create an OPENSSL device if required */
 869         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 870                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
 871                 nb_devs = rte_cryptodev_device_count_by_driver(
 872                                 rte_cryptodev_driver_id_get(
 873                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
 874                 if (nb_devs < 1) {
 875                         ret = rte_vdev_init(
 876                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
 877                                 NULL);
 878
 879                         TEST_ASSERT(ret == 0, "Failed to create "
 880                                 "instance of pmd : %s",
 881                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
 882                 }
 883         }
 884
 885         /* Get list of valid crypto devs */
 886         nb_devs = rte_cryptodev_devices_get(
 887                                 rte_cryptodev_driver_name_get(gbl_driver_id),
 888                                 valid_devs, RTE_CRYPTO_MAX_DEVS);
 889         if (nb_devs < 1) {
 890                 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
 891                 return TEST_FAILED;
 892         }
 893
 894         /*
 895          * Get first valid asymmetric device found in test suite param and
 896          * break
 897          */
 898         for (i = 0; i < nb_devs ; i++) {
 899                 rte_cryptodev_info_get(valid_devs[i], &info);
 900                 if (info.feature_flags & RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO) {
 901                         dev_id = ts_params->valid_devs[0] = valid_devs[i];
 902                         break;
 903                 }
 904         }
 905
 906         if (dev_id == -1) {
 907                 RTE_LOG(ERR, USER1, "Device doesn't support asymmetric. "
 908                         "Test skipped.\n");
 909                 return TEST_FAILED;
 910         }
 911
 912         /* Set valid device count */
 913         ts_params->valid_dev_count = nb_devs;
 914
 915         /* configure device with num qp */
 916         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 917         ts_params->conf.socket_id = SOCKET_ID_ANY;
 918         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY |
 919                         RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO;
 920         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 921                         &ts_params->conf),
 922                         "Failed to configure cryptodev %u with %u qps",
 923                         dev_id, ts_params->conf.nb_queue_pairs);
 924
 925         /* configure qp */
 926         ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 927         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 928         ts_params->qp_conf.mp_session_private = ts_params->session_mpool;
 929         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 930                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 931                         dev_id, qp_id, &ts_params->qp_conf,
 932                         rte_cryptodev_socket_id(dev_id)),
 933                         "Failed to setup queue pair %u on cryptodev %u ASYM",
 934                         qp_id, dev_id);
 935         }
 936
 937         /* setup asym session pool */
 938         unsigned int session_size = RTE_MAX(
 939                 rte_cryptodev_asym_get_private_session_size(dev_id),
 940                 rte_cryptodev_asym_get_header_session_size());
 941         /*
 942          * Create mempool with TEST_NUM_SESSIONS * 2,
 943          * to include the session headers
 944          */
 945         ts_params->session_mpool = rte_mempool_create(
 946                                 "test_asym_sess_mp",
 947                                 TEST_NUM_SESSIONS * 2,
 948                                 session_size,
 949                                 0, 0, NULL, NULL, NULL,
 950                                 NULL, SOCKET_ID_ANY,
 951                                 0);
 952
 953         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 954                         "session mempool allocation failed");
 955
 956         return TEST_SUCCESS;
 957 }
 958
 959 static void
 960 testsuite_teardown(void)
 961 {
 962         struct crypto_testsuite_params *ts_params = &testsuite_params;
 963
 964         if (ts_params->op_mpool != NULL) {
 965                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 966                 rte_mempool_avail_count(ts_params->op_mpool));
 967         }
 968
 969         /* Free session mempools */
 970         if (ts_params->session_mpool != NULL) {
 971                 rte_mempool_free(ts_params->session_mpool);
 972                 ts_params->session_mpool = NULL;
 973         }
 974 }
 975
 976 static int
 977 ut_setup(void)
 978 {
 979         struct crypto_testsuite_params *ts_params = &testsuite_params;
 980
 981         uint16_t qp_id;
 982
 983         /* Reconfigure device to default parameters */
 984         ts_params->conf.socket_id = SOCKET_ID_ANY;
 985
 986         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 987                         &ts_params->conf),
 988                         "Failed to configure cryptodev %u",
 989                         ts_params->valid_devs[0]);
 990
 991         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 992                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 993                         ts_params->valid_devs[0], qp_id,
 994                         &ts_params->qp_conf,
 995                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 996                         "Failed to setup queue pair %u on cryptodev %u",
 997                         qp_id, ts_params->valid_devs[0]);
 998         }
 999
1000         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1001
1002         /* Start the device */
1003         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1004                                                 "Failed to start cryptodev %u",
1005                                                 ts_params->valid_devs[0]);
1006
1007         return TEST_SUCCESS;
1008 }
1009
1010 static void
1011 ut_teardown(void)
1012 {
1013         struct crypto_testsuite_params *ts_params = &testsuite_params;
1014         struct rte_cryptodev_stats stats;
1015
1016         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
1017
1018         /* Stop the device */
1019         rte_cryptodev_stop(ts_params->valid_devs[0]);
1020 }
1021
1022 static inline void print_asym_capa(
1023                 const struct rte_cryptodev_asymmetric_xform_capability *capa)
1024 {
1025         int i = 0;
1026
1027         printf("\nxform type: %s\n===================\n",
1028                         rte_crypto_asym_xform_strings[capa->xform_type]);
1029         printf("operation supported -");
1030
1031         for (i = 0; i < RTE_CRYPTO_ASYM_OP_LIST_END; i++) {
1032                 /* check supported operations */
1033                 if (rte_cryptodev_asym_xform_capability_check_optype(capa, i))
1034                         printf(" %s",
1035                                         rte_crypto_asym_op_strings[i]);
1036                 }
1037                 switch (capa->xform_type) {
1038                 case RTE_CRYPTO_ASYM_XFORM_RSA:
1039                 case RTE_CRYPTO_ASYM_XFORM_MODINV:
1040                 case RTE_CRYPTO_ASYM_XFORM_MODEX:
1041                 case RTE_CRYPTO_ASYM_XFORM_DH:
1042                 case RTE_CRYPTO_ASYM_XFORM_DSA:
1043                         printf(" modlen: min %d max %d increment %d",
1044                                         capa->modlen.min,
1045                                         capa->modlen.max,
1046                                         capa->modlen.increment);
1047                 break;
1048                 case RTE_CRYPTO_ASYM_XFORM_ECDSA:
1049                 case RTE_CRYPTO_ASYM_XFORM_ECPM:
1050                 default:
1051                         break;
1052                 }
1053                 printf("\n");
1054 }
1055
1056 static int
1057 test_capability(void)
1058 {
1059         struct crypto_testsuite_params *ts_params = &testsuite_params;
1060         uint8_t dev_id = ts_params->valid_devs[0];
1061         struct rte_cryptodev_info dev_info;
1062         const struct rte_cryptodev_capabilities *dev_capa;
1063         int i = 0;
1064         struct rte_cryptodev_asym_capability_idx idx;
1065         const struct rte_cryptodev_asymmetric_xform_capability *capa;
1066
1067         rte_cryptodev_info_get(dev_id, &dev_info);
1068         if (!(dev_info.feature_flags &
1069                                 RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO)) {
1070                 RTE_LOG(INFO, USER1,
1071                                 "Device doesn't support asymmetric. Test Skipped\n");
1072                 return TEST_SUCCESS;
1073         }
1074
1075         /* print xform capability */
1076         for (i = 0;
1077                 dev_info.capabilities[i].op != RTE_CRYPTO_OP_TYPE_UNDEFINED;
1078                 i++) {
1079                 dev_capa = &(dev_info.capabilities[i]);
1080                 if (dev_info.capabilities[i].op ==
1081                                 RTE_CRYPTO_OP_TYPE_ASYMMETRIC) {
1082                         idx.type = dev_capa->asym.xform_capa.xform_type;
1083
1084                         capa = rte_cryptodev_asym_capability_get(dev_id,
1085                                 (const struct
1086                                 rte_cryptodev_asym_capability_idx *) &idx);
1087                         print_asym_capa(capa);
1088                         }
1089         }
1090         return TEST_SUCCESS;
1091 }
1092
1093 static int
1094 test_dh_gen_shared_sec(struct rte_crypto_asym_xform *xfrm)
1095 {
1096         struct crypto_testsuite_params *ts_params = &testsuite_params;
1097         struct rte_mempool *op_mpool = ts_params->op_mpool;
1098         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1099         uint8_t dev_id = ts_params->valid_devs[0];
1100         struct rte_crypto_asym_op *asym_op = NULL;
1101         struct rte_crypto_op *op = NULL, *result_op = NULL;
1102         struct rte_cryptodev_asym_session *sess = NULL;
1103         int status = TEST_SUCCESS;
1104         uint8_t output[TEST_DH_MOD_LEN];
1105         struct rte_crypto_asym_xform xform = *xfrm;
1106         uint8_t peer[] = "01234567890123456789012345678901234567890123456789";
1107
1108         sess = rte_cryptodev_asym_session_create(sess_mpool);
1109         if (sess == NULL) {
1110                 RTE_LOG(ERR, USER1,
1111                                 "line %u FAILED: %s", __LINE__,
1112                                 "Session creation failed");
1113                 status = TEST_FAILED;
1114                 goto error_exit;
1115         }
1116         /* set up crypto op data structure */
1117         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1118         if (!op) {
1119                 RTE_LOG(ERR, USER1,
1120                         "line %u FAILED: %s",
1121                         __LINE__, "Failed to allocate asymmetric crypto "
1122                         "operation struct");
1123                 status = TEST_FAILED;
1124                 goto error_exit;
1125         }
1126         asym_op = op->asym;
1127
1128         /* Setup a xform and op to generate private key only */
1129         xform.dh.type = RTE_CRYPTO_ASYM_OP_SHARED_SECRET_COMPUTE;
1130         xform.next = NULL;
1131         asym_op->dh.priv_key.data = dh_test_params.priv_key.data;
1132         asym_op->dh.priv_key.length = dh_test_params.priv_key.length;
1133         asym_op->dh.pub_key.data = (uint8_t *)peer;
1134         asym_op->dh.pub_key.length = sizeof(peer);
1135         asym_op->dh.shared_secret.data = output;
1136         asym_op->dh.shared_secret.length = sizeof(output);
1137
1138         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
1139                         sess_mpool) < 0) {
1140                 RTE_LOG(ERR, USER1,
1141                                 "line %u FAILED: %s",
1142                                 __LINE__, "unabled to config sym session");
1143                 status = TEST_FAILED;
1144                 goto error_exit;
1145         }
1146
1147         /* attach asymmetric crypto session to crypto operations */
1148         rte_crypto_op_attach_asym_session(op, sess);
1149
1150         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1151
1152         /* Process crypto operation */
1153         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1154                 RTE_LOG(ERR, USER1,
1155                         "line %u FAILED: %s",
1156                         __LINE__, "Error sending packet for operation");
1157                 status = TEST_FAILED;
1158                 goto error_exit;
1159         }
1160
1161         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1162                 rte_pause();
1163
1164         if (result_op == NULL) {
1165                 RTE_LOG(ERR, USER1,
1166                         "line %u FAILED: %s",
1167                         __LINE__, "Failed to process asym crypto op");
1168                 status = TEST_FAILED;
1169                 goto error_exit;
1170         }
1171
1172         debug_hexdump(stdout, "shared secret:",
1173                         asym_op->dh.shared_secret.data,
1174                         asym_op->dh.shared_secret.length);
1175
1176 error_exit:
1177         if (sess != NULL) {
1178                 rte_cryptodev_asym_session_clear(dev_id, sess);
1179                 rte_cryptodev_asym_session_free(sess);
1180         }
1181         if (op != NULL)
1182                 rte_crypto_op_free(op);
1183         return status;
1184 }
1185
1186 static int
1187 test_dh_gen_priv_key(struct rte_crypto_asym_xform *xfrm)
1188 {
1189         struct crypto_testsuite_params *ts_params = &testsuite_params;
1190         struct rte_mempool *op_mpool = ts_params->op_mpool;
1191         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1192         uint8_t dev_id = ts_params->valid_devs[0];
1193         struct rte_crypto_asym_op *asym_op = NULL;
1194         struct rte_crypto_op *op = NULL, *result_op = NULL;
1195         struct rte_cryptodev_asym_session *sess = NULL;
1196         int status = TEST_SUCCESS;
1197         uint8_t output[TEST_DH_MOD_LEN];
1198         struct rte_crypto_asym_xform xform = *xfrm;
1199
1200         sess = rte_cryptodev_asym_session_create(sess_mpool);
1201         if (sess == NULL) {
1202                 RTE_LOG(ERR, USER1,
1203                                  "line %u FAILED: %s", __LINE__,
1204                                 "Session creation failed");
1205                 status = TEST_FAILED;
1206                 goto error_exit;
1207         }
1208         /* set up crypto op data structure */
1209         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1210         if (!op) {
1211                 RTE_LOG(ERR, USER1,
1212                         "line %u FAILED: %s",
1213                         __LINE__, "Failed to allocate asymmetric crypto "
1214                         "operation struct");
1215                 status = TEST_FAILED;
1216                 goto error_exit;
1217         }
1218         asym_op = op->asym;
1219
1220         /* Setup a xform and op to generate private key only */
1221         xform.dh.type = RTE_CRYPTO_ASYM_OP_PRIVATE_KEY_GENERATE;
1222         xform.next = NULL;
1223         asym_op->dh.priv_key.data = output;
1224         asym_op->dh.priv_key.length = sizeof(output);
1225
1226         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
1227                         sess_mpool) < 0) {
1228                 RTE_LOG(ERR, USER1,
1229                                 "line %u FAILED: %s",
1230                                 __LINE__, "unabled to config sym session");
1231                 status = TEST_FAILED;
1232                 goto error_exit;
1233         }
1234
1235         /* attach asymmetric crypto session to crypto operations */
1236         rte_crypto_op_attach_asym_session(op, sess);
1237
1238         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1239
1240         /* Process crypto operation */
1241         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1242                 RTE_LOG(ERR, USER1,
1243                         "line %u FAILED: %s",
1244                         __LINE__, "Error sending packet for operation");
1245                 status = TEST_FAILED;
1246                 goto error_exit;
1247         }
1248
1249         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1250                 rte_pause();
1251
1252         if (result_op == NULL) {
1253                 RTE_LOG(ERR, USER1,
1254                         "line %u FAILED: %s",
1255                         __LINE__, "Failed to process asym crypto op");
1256                 status = TEST_FAILED;
1257                 goto error_exit;
1258         }
1259
1260         debug_hexdump(stdout, "private key:",
1261                         asym_op->dh.priv_key.data,
1262                         asym_op->dh.priv_key.length);
1263
1264
1265 error_exit:
1266         if (sess != NULL) {
1267                 rte_cryptodev_asym_session_clear(dev_id, sess);
1268                 rte_cryptodev_asym_session_free(sess);
1269         }
1270         if (op != NULL)
1271                 rte_crypto_op_free(op);
1272
1273         return status;
1274 }
1275
1276
1277 static int
1278 test_dh_gen_pub_key(struct rte_crypto_asym_xform *xfrm)
1279 {
1280         struct crypto_testsuite_params *ts_params = &testsuite_params;
1281         struct rte_mempool *op_mpool = ts_params->op_mpool;
1282         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1283         uint8_t dev_id = ts_params->valid_devs[0];
1284         struct rte_crypto_asym_op *asym_op = NULL;
1285         struct rte_crypto_op *op = NULL, *result_op = NULL;
1286         struct rte_cryptodev_asym_session *sess = NULL;
1287         int status = TEST_SUCCESS;
1288         uint8_t output[TEST_DH_MOD_LEN];
1289         struct rte_crypto_asym_xform xform = *xfrm;
1290
1291         sess = rte_cryptodev_asym_session_create(sess_mpool);
1292         if (sess == NULL) {
1293                 RTE_LOG(ERR, USER1,
1294                                  "line %u FAILED: %s", __LINE__,
1295                                 "Session creation failed");
1296                 status = TEST_FAILED;
1297                 goto error_exit;
1298         }
1299         /* set up crypto op data structure */
1300         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1301         if (!op) {
1302                 RTE_LOG(ERR, USER1,
1303                         "line %u FAILED: %s",
1304                         __LINE__, "Failed to allocate asymmetric crypto "
1305                         "operation struct");
1306                 status = TEST_FAILED;
1307                 goto error_exit;
1308         }
1309         asym_op = op->asym;
1310         /* Setup a xform chain to generate public key
1311          * using test private key
1312          *
1313          */
1314         xform.dh.type = RTE_CRYPTO_ASYM_OP_PUBLIC_KEY_GENERATE;
1315         xform.next = NULL;
1316
1317         asym_op->dh.pub_key.data = output;
1318         asym_op->dh.pub_key.length = sizeof(output);
1319         /* load pre-defined private key */
1320         asym_op->dh.priv_key.data = rte_malloc(NULL,
1321                                         dh_test_params.priv_key.length,
1322                                         0);
1323         asym_op->dh.priv_key = dh_test_params.priv_key;
1324
1325         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
1326                         sess_mpool) < 0) {
1327                 RTE_LOG(ERR, USER1,
1328                                 "line %u FAILED: %s",
1329                                 __LINE__, "unabled to config sym session");
1330                 status = TEST_FAILED;
1331                 goto error_exit;
1332         }
1333
1334         /* attach asymmetric crypto session to crypto operations */
1335         rte_crypto_op_attach_asym_session(op, sess);
1336
1337         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1338
1339         /* Process crypto operation */
1340         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1341                 RTE_LOG(ERR, USER1,
1342                         "line %u FAILED: %s",
1343                         __LINE__, "Error sending packet for operation");
1344                 status = TEST_FAILED;
1345                 goto error_exit;
1346         }
1347
1348         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1349                 rte_pause();
1350
1351         if (result_op == NULL) {
1352                 RTE_LOG(ERR, USER1,
1353                         "line %u FAILED: %s",
1354                         __LINE__, "Failed to process asym crypto op");
1355                 status = TEST_FAILED;
1356                 goto error_exit;
1357         }
1358
1359         debug_hexdump(stdout, "pub key:",
1360                         asym_op->dh.pub_key.data, asym_op->dh.pub_key.length);
1361
1362         debug_hexdump(stdout, "priv key:",
1363                         asym_op->dh.priv_key.data, asym_op->dh.priv_key.length);
1364
1365 error_exit:
1366         if (sess != NULL) {
1367                 rte_cryptodev_asym_session_clear(dev_id, sess);
1368                 rte_cryptodev_asym_session_free(sess);
1369         }
1370         if (op != NULL)
1371                 rte_crypto_op_free(op);
1372
1373         return status;
1374 }
1375
1376 static int
1377 test_dh_gen_kp(struct rte_crypto_asym_xform *xfrm)
1378 {
1379         struct crypto_testsuite_params *ts_params = &testsuite_params;
1380         struct rte_mempool *op_mpool = ts_params->op_mpool;
1381         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1382         uint8_t dev_id = ts_params->valid_devs[0];
1383         struct rte_crypto_asym_op *asym_op = NULL;
1384         struct rte_crypto_op *op = NULL, *result_op = NULL;
1385         struct rte_cryptodev_asym_session *sess = NULL;
1386         int status = TEST_SUCCESS;
1387         uint8_t out_pub_key[TEST_DH_MOD_LEN];
1388         uint8_t out_prv_key[TEST_DH_MOD_LEN];
1389         struct rte_crypto_asym_xform pub_key_xform;
1390         struct rte_crypto_asym_xform xform = *xfrm;
1391
1392         sess = rte_cryptodev_asym_session_create(sess_mpool);
1393         if (sess == NULL) {
1394                 RTE_LOG(ERR, USER1,
1395                                  "line %u FAILED: %s", __LINE__,
1396                                 "Session creation failed");
1397                 status = TEST_FAILED;
1398                 goto error_exit;
1399         }
1400
1401         /* set up crypto op data structure */
1402         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1403         if (!op) {
1404                 RTE_LOG(ERR, USER1,
1405                         "line %u FAILED: %s",
1406                         __LINE__, "Failed to allocate asymmetric crypto "
1407                         "operation struct");
1408                 status = TEST_FAILED;
1409                 goto error_exit;
1410         }
1411         asym_op = op->asym;
1412         /* Setup a xform chain to generate
1413          * private key first followed by
1414          * public key
1415          */xform.dh.type = RTE_CRYPTO_ASYM_OP_PRIVATE_KEY_GENERATE;
1416         pub_key_xform.xform_type = RTE_CRYPTO_ASYM_XFORM_DH;
1417         pub_key_xform.dh.type = RTE_CRYPTO_ASYM_OP_PUBLIC_KEY_GENERATE;
1418         xform.next = &pub_key_xform;
1419
1420         asym_op->dh.pub_key.data = out_pub_key;
1421         asym_op->dh.pub_key.length = sizeof(out_pub_key);
1422         asym_op->dh.priv_key.data = out_prv_key;
1423         asym_op->dh.priv_key.length = sizeof(out_prv_key);
1424         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
1425                         sess_mpool) < 0) {
1426                 RTE_LOG(ERR, USER1,
1427                                 "line %u FAILED: %s",
1428                                 __LINE__, "unabled to config sym session");
1429                 status = TEST_FAILED;
1430                 goto error_exit;
1431         }
1432
1433         /* attach asymmetric crypto session to crypto operations */
1434         rte_crypto_op_attach_asym_session(op, sess);
1435
1436         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1437
1438         /* Process crypto operation */
1439         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1440                 RTE_LOG(ERR, USER1,
1441                         "line %u FAILED: %s",
1442                         __LINE__, "Error sending packet for operation");
1443                 status = TEST_FAILED;
1444                 goto error_exit;
1445         }
1446
1447         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1448                 rte_pause();
1449
1450         if (result_op == NULL) {
1451                 RTE_LOG(ERR, USER1,
1452                         "line %u FAILED: %s",
1453                         __LINE__, "Failed to process asym crypto op");
1454                 status = TEST_FAILED;
1455                 goto error_exit;
1456         }
1457         debug_hexdump(stdout, "priv key:",
1458                         out_prv_key, asym_op->dh.priv_key.length);
1459         debug_hexdump(stdout, "pub key:",
1460                         out_pub_key, asym_op->dh.pub_key.length);
1461
1462 error_exit:
1463         if (sess != NULL) {
1464                 rte_cryptodev_asym_session_clear(dev_id, sess);
1465                 rte_cryptodev_asym_session_free(sess);
1466         }
1467         if (op != NULL)
1468                 rte_crypto_op_free(op);
1469
1470         return status;
1471 }
1472
1473 static int
1474 test_mod_inv(void)
1475 {
1476         struct crypto_testsuite_params *ts_params = &testsuite_params;
1477         struct rte_mempool *op_mpool = ts_params->op_mpool;
1478         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1479         uint8_t dev_id = ts_params->valid_devs[0];
1480         struct rte_crypto_asym_op *asym_op = NULL;
1481         struct rte_crypto_op *op = NULL, *result_op = NULL;
1482         struct rte_cryptodev_asym_session *sess = NULL;
1483         int status = TEST_SUCCESS;
1484         struct rte_cryptodev_asym_capability_idx cap_idx;
1485         const struct rte_cryptodev_asymmetric_xform_capability *capability;
1486         uint8_t input[TEST_DATA_SIZE] = {0};
1487         int ret = 0;
1488         uint8_t result[sizeof(mod_p)] = { 0 };
1489
1490         if (rte_cryptodev_asym_get_xform_enum(
1491                 &modinv_xform.xform_type, "modinv") < 0) {
1492                 RTE_LOG(ERR, USER1,
1493                                  "Invalid ASYM algorithm specified\n");
1494                 return -1;
1495         }
1496
1497         cap_idx.type = modinv_xform.xform_type;
1498         capability = rte_cryptodev_asym_capability_get(dev_id,
1499                                         &cap_idx);
1500
1501         if (capability == NULL) {
1502                 RTE_LOG(INFO, USER1,
1503                         "Device doesn't support MOD INV. Test Skipped\n");
1504                 return -ENOTSUP;
1505         }
1506
1507         if (rte_cryptodev_asym_xform_capability_check_modlen(
1508                 capability,
1509                 modinv_xform.modinv.modulus.length)) {
1510                 RTE_LOG(ERR, USER1,
1511                                  "Invalid MODULUS length specified\n");
1512                                 return -ENOTSUP;
1513                 }
1514
1515         sess = rte_cryptodev_asym_session_create(sess_mpool);
1516         if (!sess) {
1517                 RTE_LOG(ERR, USER1, "line %u "
1518                                 "FAILED: %s", __LINE__,
1519                                 "Session creation failed");
1520                 status = TEST_FAILED;
1521                 goto error_exit;
1522         }
1523
1524         if (rte_cryptodev_asym_session_init(dev_id, sess, &modinv_xform,
1525                         sess_mpool) < 0) {
1526                 RTE_LOG(ERR, USER1,
1527                                 "line %u FAILED: %s",
1528                                 __LINE__, "unabled to config sym session");
1529                 status = TEST_FAILED;
1530                 goto error_exit;
1531         }
1532
1533         /* generate crypto op data structure */
1534         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1535         if (!op) {
1536                 RTE_LOG(ERR, USER1,
1537                         "line %u FAILED: %s",
1538                         __LINE__, "Failed to allocate asymmetric crypto "
1539                         "operation struct");
1540                 status = TEST_FAILED;
1541                 goto error_exit;
1542         }
1543
1544         asym_op = op->asym;
1545         memcpy(input, base, sizeof(base));
1546         asym_op->modinv.base.data = input;
1547         asym_op->modinv.base.length = sizeof(base);
1548         asym_op->modinv.result.data = result;
1549         asym_op->modinv.result.length = sizeof(result);
1550
1551         /* attach asymmetric crypto session to crypto operations */
1552         rte_crypto_op_attach_asym_session(op, sess);
1553
1554         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1555
1556         /* Process crypto operation */
1557         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1558                 RTE_LOG(ERR, USER1,
1559                         "line %u FAILED: %s",
1560                         __LINE__, "Error sending packet for operation");
1561                 status = TEST_FAILED;
1562                 goto error_exit;
1563         }
1564
1565         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1566                 rte_pause();
1567
1568         if (result_op == NULL) {
1569                 RTE_LOG(ERR, USER1,
1570                                 "line %u FAILED: %s",
1571                                 __LINE__, "Failed to process asym crypto op");
1572                 status = TEST_FAILED;
1573                 goto error_exit;
1574         }
1575
1576         ret = verify_modinv(mod_inv, result_op);
1577         if (ret) {
1578                 RTE_LOG(ERR, USER1,
1579                          "operation verification failed\n");
1580                 status = TEST_FAILED;
1581         }
1582
1583 error_exit:
1584         if (sess) {
1585                 rte_cryptodev_asym_session_clear(dev_id, sess);
1586                 rte_cryptodev_asym_session_free(sess);
1587         }
1588
1589         if (op)
1590                 rte_crypto_op_free(op);
1591
1592         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1593
1594         return status;
1595 }
1596
1597 static int
1598 test_mod_exp(void)
1599 {
1600         struct crypto_testsuite_params *ts_params = &testsuite_params;
1601         struct rte_mempool *op_mpool = ts_params->op_mpool;
1602         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1603         uint8_t dev_id = ts_params->valid_devs[0];
1604         struct rte_crypto_asym_op *asym_op = NULL;
1605         struct rte_crypto_op *op = NULL, *result_op = NULL;
1606         struct rte_cryptodev_asym_session *sess = NULL;
1607         int status = TEST_SUCCESS;
1608         struct rte_cryptodev_asym_capability_idx cap_idx;
1609         const struct rte_cryptodev_asymmetric_xform_capability *capability;
1610         uint8_t input[TEST_DATA_SIZE] = {0};
1611         int ret = 0;
1612         uint8_t result[sizeof(mod_p)] = { 0 };
1613
1614         if (rte_cryptodev_asym_get_xform_enum(&modex_xform.xform_type,
1615                 "modexp")
1616                 < 0) {
1617                 RTE_LOG(ERR, USER1,
1618                                 "Invalid ASYM algorithm specified\n");
1619                 return -1;
1620         }
1621
1622         /* check for modlen capability */
1623         cap_idx.type = modex_xform.xform_type;
1624         capability = rte_cryptodev_asym_capability_get(dev_id, &cap_idx);
1625
1626         if (capability == NULL) {
1627                 RTE_LOG(INFO, USER1,
1628                         "Device doesn't support MOD EXP. Test Skipped\n");
1629                 return -ENOTSUP;
1630         }
1631
1632         if (rte_cryptodev_asym_xform_capability_check_modlen(
1633                         capability, modex_xform.modex.modulus.length)) {
1634                 RTE_LOG(ERR, USER1,
1635                                 "Invalid MODULUS length specified\n");
1636                                 return -ENOTSUP;
1637                 }
1638
1639         /* generate crypto op data structure */
1640         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1641         if (!op) {
1642                 RTE_LOG(ERR, USER1,
1643                         "line %u FAILED: %s",
1644                         __LINE__, "Failed to allocate asymmetric crypto "
1645                         "operation struct");
1646                 status = TEST_FAILED;
1647                 goto error_exit;
1648         }
1649
1650         sess = rte_cryptodev_asym_session_create(sess_mpool);
1651         if (!sess) {
1652                 RTE_LOG(ERR, USER1,
1653                                  "line %u "
1654                                 "FAILED: %s", __LINE__,
1655                                 "Session creation failed");
1656                 status = TEST_FAILED;
1657                 goto error_exit;
1658         }
1659
1660         if (rte_cryptodev_asym_session_init(dev_id, sess, &modex_xform,
1661                         sess_mpool) < 0) {
1662                 RTE_LOG(ERR, USER1,
1663                                 "line %u FAILED: %s",
1664                                 __LINE__, "unabled to config sym session");
1665                 status = TEST_FAILED;
1666                 goto error_exit;
1667         }
1668
1669         asym_op = op->asym;
1670         memcpy(input, base, sizeof(base));
1671         asym_op->modex.base.data = input;
1672         asym_op->modex.base.length = sizeof(base);
1673         asym_op->modex.result.data = result;
1674         asym_op->modex.result.length = sizeof(result);
1675         /* attach asymmetric crypto session to crypto operations */
1676         rte_crypto_op_attach_asym_session(op, sess);
1677
1678         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1679         /* Process crypto operation */
1680         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1681                 RTE_LOG(ERR, USER1,
1682                                 "line %u FAILED: %s",
1683                                 __LINE__, "Error sending packet for operation");
1684                 status = TEST_FAILED;
1685                 goto error_exit;
1686         }
1687
1688         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1689                 rte_pause();
1690
1691         if (result_op == NULL) {
1692                 RTE_LOG(ERR, USER1,
1693                                 "line %u FAILED: %s",
1694                                 __LINE__, "Failed to process asym crypto op");
1695                 status = TEST_FAILED;
1696                 goto error_exit;
1697         }
1698
1699         ret = verify_modexp(mod_exp, result_op);
1700         if (ret) {
1701                 RTE_LOG(ERR, USER1,
1702                          "operation verification failed\n");
1703                 status = TEST_FAILED;
1704         }
1705
1706 error_exit:
1707         if (sess != NULL) {
1708                 rte_cryptodev_asym_session_clear(dev_id, sess);
1709                 rte_cryptodev_asym_session_free(sess);
1710         }
1711
1712         if (op != NULL)
1713                 rte_crypto_op_free(op);
1714
1715         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1716
1717         return status;
1718 }
1719
1720 static int
1721 test_dh_keygenration(void)
1722 {
1723         int status;
1724
1725         debug_hexdump(stdout, "p:", dh_xform.dh.p.data, dh_xform.dh.p.length);
1726         debug_hexdump(stdout, "g:", dh_xform.dh.g.data, dh_xform.dh.g.length);
1727         debug_hexdump(stdout, "priv_key:", dh_test_params.priv_key.data,
1728                         dh_test_params.priv_key.length);
1729
1730         RTE_LOG(INFO, USER1,
1731                 "Test Public and Private key pair generation\n");
1732
1733         status = test_dh_gen_kp(&dh_xform);
1734         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1735
1736         RTE_LOG(INFO, USER1,
1737                 "Test Public Key Generation using pre-defined priv key\n");
1738
1739         status = test_dh_gen_pub_key(&dh_xform);
1740         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1741
1742         RTE_LOG(INFO, USER1,
1743                 "Test Private Key Generation only\n");
1744
1745         status = test_dh_gen_priv_key(&dh_xform);
1746         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1747
1748         RTE_LOG(INFO, USER1,
1749                 "Test shared secret compute\n");
1750
1751         status = test_dh_gen_shared_sec(&dh_xform);
1752         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1753
1754         return status;
1755 }
1756
1757 static int
1758 test_dsa_sign(void)
1759 {
1760         struct crypto_testsuite_params *ts_params = &testsuite_params;
1761         struct rte_mempool *op_mpool = ts_params->op_mpool;
1762         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1763         uint8_t dev_id = ts_params->valid_devs[0];
1764         struct rte_crypto_asym_op *asym_op = NULL;
1765         struct rte_crypto_op *op = NULL, *result_op = NULL;
1766         struct rte_cryptodev_asym_session *sess = NULL;
1767         int status = TEST_SUCCESS;
1768         uint8_t r[TEST_DH_MOD_LEN];
1769         uint8_t s[TEST_DH_MOD_LEN];
1770         uint8_t dgst[] = "35d81554afaad2cf18f3a1770d5fedc4ea5be344";
1771
1772         sess = rte_cryptodev_asym_session_create(sess_mpool);
1773         if (sess == NULL) {
1774                 RTE_LOG(ERR, USER1,
1775                                  "line %u FAILED: %s", __LINE__,
1776                                 "Session creation failed");
1777                 status = TEST_FAILED;
1778                 goto error_exit;
1779         }
1780         /* set up crypto op data structure */
1781         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1782         if (!op) {
1783                 RTE_LOG(ERR, USER1,
1784                         "line %u FAILED: %s",
1785                         __LINE__, "Failed to allocate asymmetric crypto "
1786                         "operation struct");
1787                 status = TEST_FAILED;
1788                 goto error_exit;
1789         }
1790         asym_op = op->asym;
1791
1792         debug_hexdump(stdout, "p: ", dsa_xform.dsa.p.data,
1793                         dsa_xform.dsa.p.length);
1794         debug_hexdump(stdout, "q: ", dsa_xform.dsa.q.data,
1795                         dsa_xform.dsa.q.length);
1796         debug_hexdump(stdout, "g: ", dsa_xform.dsa.g.data,
1797                         dsa_xform.dsa.g.length);
1798         debug_hexdump(stdout, "priv_key: ", dsa_xform.dsa.x.data,
1799                         dsa_xform.dsa.x.length);
1800
1801         if (rte_cryptodev_asym_session_init(dev_id, sess, &dsa_xform,
1802                                 sess_mpool) < 0) {
1803                 RTE_LOG(ERR, USER1,
1804                                 "line %u FAILED: %s",
1805                                 __LINE__, "unabled to config sym session");
1806                 status = TEST_FAILED;
1807                 goto error_exit;
1808         }
1809
1810         /* attach asymmetric crypto session to crypto operations */
1811         rte_crypto_op_attach_asym_session(op, sess);
1812         asym_op->dsa.op_type = RTE_CRYPTO_ASYM_OP_SIGN;
1813         asym_op->dsa.message.data = dgst;
1814         asym_op->dsa.message.length = sizeof(dgst);
1815         asym_op->dsa.r.length = sizeof(r);
1816         asym_op->dsa.r.data = r;
1817         asym_op->dsa.s.length = sizeof(s);
1818         asym_op->dsa.s.data = s;
1819
1820         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1821
1822         /* Process crypto operation */
1823         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1824                 RTE_LOG(ERR, USER1,
1825                         "line %u FAILED: %s",
1826                         __LINE__, "Error sending packet for operation");
1827                 status = TEST_FAILED;
1828                 goto error_exit;
1829         }
1830
1831         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1832                 rte_pause();
1833
1834         if (result_op == NULL) {
1835                 RTE_LOG(ERR, USER1,
1836                         "line %u FAILED: %s",
1837                         __LINE__, "Failed to process asym crypto op");
1838                 status = TEST_FAILED;
1839                 goto error_exit;
1840         }
1841
1842         asym_op = result_op->asym;
1843
1844         debug_hexdump(stdout, "r:",
1845                         asym_op->dsa.r.data, asym_op->dsa.r.length);
1846         debug_hexdump(stdout, "s:",
1847                         asym_op->dsa.s.data, asym_op->dsa.s.length);
1848
1849         /* Test PMD DSA sign verification using signer public key */
1850         asym_op->dsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY;
1851
1852         /* copy signer public key */
1853         asym_op->dsa.y.data = dsa_test_params.y.data;
1854         asym_op->dsa.y.length = dsa_test_params.y.length;
1855
1856         /* Process crypto operation */
1857         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1858                 RTE_LOG(ERR, USER1,
1859                         "line %u FAILED: %s",
1860                         __LINE__, "Error sending packet for operation");
1861                 status = TEST_FAILED;
1862                 goto error_exit;
1863         }
1864
1865         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1866                 rte_pause();
1867
1868         if (result_op == NULL) {
1869                 RTE_LOG(ERR, USER1,
1870                         "line %u FAILED: %s",
1871                         __LINE__, "Failed to process asym crypto op");
1872                 status = TEST_FAILED;
1873                 goto error_exit;
1874         }
1875
1876         if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
1877                 RTE_LOG(ERR, USER1,
1878                                 "line %u FAILED: %s",
1879                                 __LINE__, "Failed to process asym crypto op");
1880                 status = TEST_FAILED;
1881         }
1882 error_exit:
1883         if (sess != NULL) {
1884                 rte_cryptodev_asym_session_clear(dev_id, sess);
1885                 rte_cryptodev_asym_session_free(sess);
1886         }
1887         if (op != NULL)
1888                 rte_crypto_op_free(op);
1889         return status;
1890 }
1891
1892 static int
1893 test_dsa(void)
1894 {
1895         int status;
1896         status = test_dsa_sign();
1897         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1898         return status;
1899 }
1900
1901 static int
1902 test_ecdsa_sign_verify(enum curve curve_id)
1903 {
1904         struct crypto_testsuite_params *ts_params = &testsuite_params;
1905         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1906         struct rte_mempool *op_mpool = ts_params->op_mpool;
1907         struct crypto_testsuite_ecdsa_params input_params;
1908         struct rte_cryptodev_asym_session *sess = NULL;
1909         uint8_t dev_id = ts_params->valid_devs[0];
1910         struct rte_crypto_op *result_op = NULL;
1911         uint8_t output_buf_r[TEST_DATA_SIZE];
1912         uint8_t output_buf_s[TEST_DATA_SIZE];
1913         struct rte_crypto_asym_xform xform;
1914         struct rte_crypto_asym_op *asym_op;
1915         struct rte_cryptodev_info dev_info;
1916         struct rte_crypto_op *op = NULL;
1917         int status = TEST_SUCCESS, ret;
1918
1919         switch (curve_id) {
1920         case SECP192R1:
1921                 input_params = ecdsa_param_secp192r1;
1922                 break;
1923         case SECP224R1:
1924                 input_params = ecdsa_param_secp224r1;
1925                 break;
1926         case SECP256R1:
1927                 input_params = ecdsa_param_secp256r1;
1928                 break;
1929         case SECP384R1:
1930                 input_params = ecdsa_param_secp384r1;
1931                 break;
1932         case SECP521R1:
1933                 input_params = ecdsa_param_secp521r1;
1934                 break;
1935         default:
1936                 RTE_LOG(ERR, USER1,
1937                                 "line %u FAILED: %s", __LINE__,
1938                                 "Unsupported curve id\n");
1939                 status = TEST_FAILED;
1940                 goto exit;
1941         }
1942
1943         rte_cryptodev_info_get(dev_id, &dev_info);
1944
1945         sess = rte_cryptodev_asym_session_create(sess_mpool);
1946         if (sess == NULL) {
1947                 RTE_LOG(ERR, USER1,
1948                                 "line %u FAILED: %s", __LINE__,
1949                                 "Session creation failed\n");
1950                 status = TEST_FAILED;
1951                 goto exit;
1952         }
1953
1954         /* Setup crypto op data structure */
1955         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1956         if (op == NULL) {
1957                 RTE_LOG(ERR, USER1,
1958                                 "line %u FAILED: %s", __LINE__,
1959                                 "Failed to allocate asymmetric crypto "
1960                                 "operation struct\n");
1961                 status = TEST_FAILED;
1962                 goto exit;
1963         }
1964         asym_op = op->asym;
1965
1966         /* Setup asym xform */
1967         xform.next = NULL;
1968         xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ECDSA;
1969         xform.ec.curve_id = input_params.curve;
1970
1971         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
1972                                 sess_mpool) < 0) {
1973                 RTE_LOG(ERR, USER1,
1974                                 "line %u FAILED: %s", __LINE__,
1975                                 "Unable to config asym session\n");
1976                 status = TEST_FAILED;
1977                 goto exit;
1978         }
1979
1980         /* Attach asymmetric crypto session to crypto operations */
1981         rte_crypto_op_attach_asym_session(op, sess);
1982
1983         /* Compute sign */
1984
1985         /* Populate op with operational details */
1986         op->asym->ecdsa.op_type = RTE_CRYPTO_ASYM_OP_SIGN;
1987         op->asym->ecdsa.message.data = input_params.digest.data;
1988         op->asym->ecdsa.message.length = input_params.digest.length;
1989         op->asym->ecdsa.k.data = input_params.scalar.data;
1990         op->asym->ecdsa.k.length = input_params.scalar.length;
1991         op->asym->ecdsa.pkey.data = input_params.pkey.data;
1992         op->asym->ecdsa.pkey.length = input_params.pkey.length;
1993
1994         /* Init out buf */
1995         op->asym->ecdsa.r.data = output_buf_r;
1996         op->asym->ecdsa.s.data = output_buf_s;
1997
1998         RTE_LOG(DEBUG, USER1, "Process ASYM operation\n");
1999
2000         /* Process crypto operation */
2001         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
2002                 RTE_LOG(ERR, USER1,
2003                                 "line %u FAILED: %s", __LINE__,
2004                                 "Error sending packet for operation\n");
2005                 status = TEST_FAILED;
2006                 goto exit;
2007         }
2008
2009         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
2010                 rte_pause();
2011
2012         if (result_op == NULL) {
2013                 RTE_LOG(ERR, USER1,
2014                                 "line %u FAILED: %s", __LINE__,
2015                                 "Failed to process asym crypto op\n");
2016                 status = TEST_FAILED;
2017                 goto exit;
2018         }
2019
2020         if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
2021                 RTE_LOG(ERR, USER1,
2022                                 "line %u FAILED: %s", __LINE__,
2023                                 "Failed to process asym crypto op\n");
2024                 status = TEST_FAILED;
2025                 goto exit;
2026         }
2027
2028         asym_op = result_op->asym;
2029
2030         debug_hexdump(stdout, "r:",
2031                         asym_op->ecdsa.r.data, asym_op->ecdsa.r.length);
2032         debug_hexdump(stdout, "s:",
2033                         asym_op->ecdsa.s.data, asym_op->ecdsa.s.length);
2034
2035         ret = verify_ecdsa_sign(input_params.sign_r.data,
2036                                 input_params.sign_s.data, result_op);
2037         if (ret) {
2038                 status = TEST_FAILED;
2039                 RTE_LOG(ERR, USER1,
2040                                 "line %u FAILED: %s", __LINE__,
2041                                 "ECDSA sign failed.\n");
2042                 goto exit;
2043         }
2044
2045         /* Verify sign */
2046
2047         /* Populate op with operational details */
2048         op->asym->ecdsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY;
2049         op->asym->ecdsa.q.x.data = input_params.pubkey_qx.data;
2050         op->asym->ecdsa.q.x.length = input_params.pubkey_qx.length;
2051         op->asym->ecdsa.q.y.data = input_params.pubkey_qy.data;
2052         op->asym->ecdsa.q.y.length = input_params.pubkey_qx.length;
2053         op->asym->ecdsa.r.data = asym_op->ecdsa.r.data;
2054         op->asym->ecdsa.r.length = asym_op->ecdsa.r.length;
2055         op->asym->ecdsa.s.data = asym_op->ecdsa.s.data;
2056         op->asym->ecdsa.s.length = asym_op->ecdsa.s.length;
2057
2058         /* Enqueue sign result for verify */
2059         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
2060                 status = TEST_FAILED;
2061                 RTE_LOG(ERR, USER1,
2062                                 "line %u FAILED: %s", __LINE__,
2063                                 "Error sending packet for operation\n");
2064                 goto exit;
2065         }
2066
2067         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
2068                 rte_pause();
2069
2070         if (result_op == NULL) {
2071                 status = TEST_FAILED;
2072                 goto exit;
2073         }
2074         if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
2075                 status = TEST_FAILED;
2076                 RTE_LOG(ERR, USER1,
2077                                 "line %u FAILED: %s", __LINE__,
2078                                 "ECDSA verify failed.\n");
2079                 goto exit;
2080         }
2081
2082 exit:
2083         if (sess != NULL) {
2084                 rte_cryptodev_asym_session_clear(dev_id, sess);
2085                 rte_cryptodev_asym_session_free(sess);
2086         }
2087         if (op != NULL)
2088                 rte_crypto_op_free(op);
2089         return status;
2090 };
2091
2092 static int
2093 test_ecdsa_sign_verify_all_curve(void)
2094 {
2095         int status, overall_status = TEST_SUCCESS;
2096         enum curve curve_id;
2097         int test_index = 0;
2098         const char *msg;
2099
2100         for (curve_id = SECP192R1; curve_id < END_OF_CURVE_LIST; curve_id++) {
2101                 status = test_ecdsa_sign_verify(curve_id);
2102                 if (status == TEST_SUCCESS) {
2103                         msg = "succeeded";
2104                 } else {
2105                         msg = "failed";
2106                         overall_status = status;
2107                 }
2108                 printf("  %u) TestCase Sign/Veriy Curve %s  %s\n",
2109                        test_index ++, curve[curve_id], msg);
2110         }
2111         return overall_status;
2112 }
2113
2114 static int
2115 test_ecpm(enum curve curve_id)
2116 {
2117         struct crypto_testsuite_params *ts_params = &testsuite_params;
2118         struct rte_mempool *sess_mpool = ts_params->session_mpool;
2119         struct rte_mempool *op_mpool = ts_params->op_mpool;
2120         struct crypto_testsuite_ecpm_params input_params;
2121         struct rte_cryptodev_asym_session *sess = NULL;
2122         uint8_t dev_id = ts_params->valid_devs[0];
2123         struct rte_crypto_op *result_op = NULL;
2124         uint8_t output_buf_x[TEST_DATA_SIZE];
2125         uint8_t output_buf_y[TEST_DATA_SIZE];
2126         struct rte_crypto_asym_xform xform;
2127         struct rte_crypto_asym_op *asym_op;
2128         struct rte_cryptodev_info dev_info;
2129         struct rte_crypto_op *op = NULL;
2130         int status = TEST_SUCCESS, ret;
2131
2132         switch (curve_id) {
2133         case SECP192R1:
2134                 input_params = ecpm_param_secp192r1;
2135                 break;
2136         case SECP224R1:
2137                 input_params = ecpm_param_secp224r1;
2138                 break;
2139         case SECP256R1:
2140                 input_params = ecpm_param_secp256r1;
2141                 break;
2142         case SECP384R1:
2143                 input_params = ecpm_param_secp384r1;
2144                 break;
2145         case SECP521R1:
2146                 input_params = ecpm_param_secp521r1;
2147                 break;
2148         default:
2149                 RTE_LOG(ERR, USER1,
2150                                 "line %u FAILED: %s", __LINE__,
2151                                 "Unsupported curve id\n");
2152                 status = TEST_FAILED;
2153                 goto exit;
2154         }
2155
2156         rte_cryptodev_info_get(dev_id, &dev_info);
2157
2158         sess = rte_cryptodev_asym_session_create(sess_mpool);
2159         if (sess == NULL) {
2160                 RTE_LOG(ERR, USER1,
2161                                 "line %u FAILED: %s", __LINE__,
2162                                 "Session creation failed\n");
2163                 status = TEST_FAILED;
2164                 goto exit;
2165         }
2166
2167         /* Setup crypto op data structure */
2168         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
2169         if (op == NULL) {
2170                 RTE_LOG(ERR, USER1,
2171                                 "line %u FAILED: %s", __LINE__,
2172                                 "Failed to allocate asymmetric crypto "
2173                                 "operation struct\n");
2174                 status = TEST_FAILED;
2175                 goto exit;
2176         }
2177         asym_op = op->asym;
2178
2179         /* Setup asym xform */
2180         xform.next = NULL;
2181         xform.xform_type = RTE_CRYPTO_ASYM_XFORM_ECPM;
2182         xform.ec.curve_id = input_params.curve;
2183
2184         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
2185                                 sess_mpool) < 0) {
2186                 RTE_LOG(ERR, USER1,
2187                                 "line %u FAILED: %s", __LINE__,
2188                                 "Unable to config asym session\n");
2189                 status = TEST_FAILED;
2190                 goto exit;
2191         }
2192
2193         /* Attach asymmetric crypto session to crypto operations */
2194         rte_crypto_op_attach_asym_session(op, sess);
2195
2196         /* Populate op with operational details */
2197         op->asym->ecpm.p.x.data = input_params.gen_x.data;
2198         op->asym->ecpm.p.x.length = input_params.gen_x.length;
2199         op->asym->ecpm.p.y.data = input_params.gen_y.data;
2200         op->asym->ecpm.p.y.length = input_params.gen_y.length;
2201         op->asym->ecpm.scalar.data = input_params.privkey.data;
2202         op->asym->ecpm.scalar.length = input_params.privkey.length;
2203
2204         /* Init out buf */
2205         op->asym->ecpm.r.x.data = output_buf_x;
2206         op->asym->ecpm.r.y.data = output_buf_y;
2207
2208         RTE_LOG(DEBUG, USER1, "Process ASYM operation\n");
2209
2210         /* Process crypto operation */
2211         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
2212                 RTE_LOG(ERR, USER1,
2213                                 "line %u FAILED: %s", __LINE__,
2214                                 "Error sending packet for operation\n");
2215                 status = TEST_FAILED;
2216                 goto exit;
2217         }
2218
2219         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
2220                 rte_pause();
2221
2222         if (result_op == NULL) {
2223                 RTE_LOG(ERR, USER1,
2224                                 "line %u FAILED: %s", __LINE__,
2225                                 "Failed to process asym crypto op\n");
2226                 status = TEST_FAILED;
2227                 goto exit;
2228         }
2229
2230         if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
2231                 RTE_LOG(ERR, USER1,
2232                                 "line %u FAILED: %s", __LINE__,
2233                                 "Failed to process asym crypto op\n");
2234                 status = TEST_FAILED;
2235                 goto exit;
2236         }
2237
2238         asym_op = result_op->asym;
2239
2240         debug_hexdump(stdout, "r x:",
2241                         asym_op->ecpm.r.x.data, asym_op->ecpm.r.x.length);
2242         debug_hexdump(stdout, "r y:",
2243                         asym_op->ecpm.r.y.data, asym_op->ecpm.r.y.length);
2244
2245         ret = verify_ecpm(input_params.pubkey_x.data,
2246                                 input_params.pubkey_y.data, result_op);
2247         if (ret) {
2248                 status = TEST_FAILED;
2249                 RTE_LOG(ERR, USER1,
2250                                 "line %u FAILED: %s", __LINE__,
2251                                 "EC Point Multiplication failed.\n");
2252                 goto exit;
2253         }
2254
2255 exit:
2256         if (sess != NULL) {
2257                 rte_cryptodev_asym_session_clear(dev_id, sess);
2258                 rte_cryptodev_asym_session_free(sess);
2259         }
2260         if (op != NULL)
2261                 rte_crypto_op_free(op);
2262         return status;
2263 }
2264
2265 static int
2266 test_ecpm_all_curve(void)
2267 {
2268         int status, overall_status = TEST_SUCCESS;
2269         enum curve curve_id;
2270         int test_index = 0;
2271         const char *msg;
2272
2273         for (curve_id = SECP192R1; curve_id < END_OF_CURVE_LIST; curve_id++) {
2274                 status = test_ecpm(curve_id);
2275                 if (status == TEST_SUCCESS) {
2276                         msg = "succeeded";
2277                 } else {
2278                         msg = "failed";
2279                         overall_status = status;
2280                 }
2281                 printf("  %u) TestCase EC Point Mul Curve %s  %s\n",
2282                        test_index ++, curve[curve_id], msg);
2283         }
2284         return overall_status;
2285 }
2286
2287 static struct unit_test_suite cryptodev_openssl_asym_testsuite  = {
2288         .suite_name = "Crypto Device OPENSSL ASYM Unit Test Suite",
2289         .setup = testsuite_setup,
2290         .teardown = testsuite_teardown,
2291         .unit_test_cases = {
2292                 TEST_CASE_ST(ut_setup, ut_teardown, test_capability),
2293                 TEST_CASE_ST(ut_setup, ut_teardown, test_dsa),
2294                 TEST_CASE_ST(ut_setup, ut_teardown, test_dh_keygenration),
2295                 TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_enc_dec),
2296                 TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_sign_verify),
2297                 TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_enc_dec_crt),
2298                 TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_sign_verify_crt),
2299                 TEST_CASE_ST(ut_setup, ut_teardown, test_mod_inv),
2300                 TEST_CASE_ST(ut_setup, ut_teardown, test_mod_exp),
2301                 TEST_CASE_ST(ut_setup, ut_teardown, test_one_by_one),
2302                 TEST_CASES_END() /**< NULL terminate unit test array */
2303         }
2304 };
2305
2306 static struct unit_test_suite cryptodev_qat_asym_testsuite  = {
2307         .suite_name = "Crypto Device QAT ASYM Unit Test Suite",
2308         .setup = testsuite_setup,
2309         .teardown = testsuite_teardown,
2310         .unit_test_cases = {
2311                 TEST_CASE_ST(ut_setup, ut_teardown, test_one_by_one),
2312                 TEST_CASES_END() /**< NULL terminate unit test array */
2313         }
2314 };
2315
2316 static struct unit_test_suite cryptodev_octeontx_asym_testsuite  = {
2317         .suite_name = "Crypto Device OCTEONTX ASYM Unit Test Suite",
2318         .setup = testsuite_setup,
2319         .teardown = testsuite_teardown,
2320         .unit_test_cases = {
2321                 TEST_CASE_ST(ut_setup, ut_teardown, test_capability),
2322                 TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_enc_dec_crt),
2323                 TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_sign_verify_crt),
2324                 TEST_CASE_ST(ut_setup, ut_teardown, test_mod_exp),
2325                 TEST_CASE_ST(ut_setup, ut_teardown,
2326                              test_ecdsa_sign_verify_all_curve),
2327                 TEST_CASE_ST(ut_setup, ut_teardown, test_ecpm_all_curve),
2328                 TEST_CASES_END() /**< NULL terminate unit test array */
2329         }
2330 };
2331
2332 static int
2333 test_cryptodev_openssl_asym(void)
2334 {
2335         gbl_driver_id = rte_cryptodev_driver_id_get(
2336                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
2337
2338         if (gbl_driver_id == -1) {
2339                 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded.\n");
2340                 return TEST_FAILED;
2341         }
2342
2343         return unit_test_suite_runner(&cryptodev_openssl_asym_testsuite);
2344 }
2345
2346 static int
2347 test_cryptodev_qat_asym(void)
2348 {
2349         gbl_driver_id = rte_cryptodev_driver_id_get(
2350                         RTE_STR(CRYPTODEV_NAME_QAT_ASYM_PMD));
2351
2352         if (gbl_driver_id == -1) {
2353                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n");
2354                 return TEST_FAILED;
2355         }
2356
2357         return unit_test_suite_runner(&cryptodev_qat_asym_testsuite);
2358 }
2359
2360 static int
2361 test_cryptodev_octeontx_asym(void)
2362 {
2363         gbl_driver_id = rte_cryptodev_driver_id_get(
2364                         RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
2365         if (gbl_driver_id == -1) {
2366                 RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded.\n");
2367                 return TEST_FAILED;
2368         }
2369         return unit_test_suite_runner(&cryptodev_octeontx_asym_testsuite);
2370 }
2371
2372 static int
2373 test_cryptodev_octeontx2_asym(void)
2374 {
2375         gbl_driver_id = rte_cryptodev_driver_id_get(
2376                         RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
2377         if (gbl_driver_id == -1) {
2378                 RTE_LOG(ERR, USER1, "OCTEONTX2 PMD must be loaded.\n");
2379                 return TEST_FAILED;
2380         }
2381
2382         /* Use test suite registered for crypto_octeontx PMD */
2383         return unit_test_suite_runner(&cryptodev_octeontx_asym_testsuite);
2384 }
2385
2386 REGISTER_TEST_COMMAND(cryptodev_openssl_asym_autotest,
2387                                           test_cryptodev_openssl_asym);
2388
2389 REGISTER_TEST_COMMAND(cryptodev_qat_asym_autotest, test_cryptodev_qat_asym);
2390
2391 REGISTER_TEST_COMMAND(cryptodev_octeontx_asym_autotest,
2392                                           test_cryptodev_octeontx_asym);
2393
2394 REGISTER_TEST_COMMAND(cryptodev_octeontx2_asym_autotest,
2395                                           test_cryptodev_octeontx2_asym);