test/test/test_cryptodev_asym.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Cavium Networks
   3  */
   4
   5 #include <rte_bus_vdev.h>
   6 #include <rte_common.h>
   7 #include <rte_hexdump.h>
   8 #include <rte_mbuf.h>
   9 #include <rte_malloc.h>
  10 #include <rte_memcpy.h>
  11 #include <rte_pause.h>
  12
  13 #include <rte_cryptodev.h>
  14 #include <rte_cryptodev_pmd.h>
  15 #include <rte_crypto.h>
  16
  17 #include "test_cryptodev.h"
  18 #include "test_cryptodev_dh_test_vectors.h"
  19 #include "test_cryptodev_dsa_test_vectors.h"
  20 #include "test_cryptodev_mod_test_vectors.h"
  21 #include "test_cryptodev_rsa_test_vectors.h"
  22 #include "test_cryptodev_asym_util.h"
  23 #include "test.h"
  24
  25 #define TEST_NUM_BUFS 10
  26 #define TEST_NUM_SESSIONS 4
  27
  28 static int gbl_driver_id;
  29 struct crypto_testsuite_params {
  30         struct rte_mempool *op_mpool;
  31         struct rte_mempool *session_mpool;
  32         struct rte_cryptodev_config conf;
  33         struct rte_cryptodev_qp_conf qp_conf;
  34         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  35         uint8_t valid_dev_count;
  36 };
  37
  38 struct crypto_unittest_params {
  39         struct rte_cryptodev_asym_session *sess;
  40         struct rte_crypto_op *op;
  41 };
  42
  43 static struct crypto_testsuite_params testsuite_params = { NULL };
  44
  45 static int
  46 test_rsa_sign_verify(void)
  47 {
  48         struct crypto_testsuite_params *ts_params = &testsuite_params;
  49         struct rte_mempool *op_mpool = ts_params->op_mpool;
  50         struct rte_mempool *sess_mpool = ts_params->session_mpool;
  51         uint8_t dev_id = ts_params->valid_devs[0];
  52         struct rte_crypto_asym_op *asym_op = NULL;
  53         struct rte_crypto_op *op = NULL, *result_op = NULL;
  54         struct rte_cryptodev_asym_session *sess = NULL;
  55         int status = TEST_SUCCESS;
  56         uint8_t output_buf[TEST_DATA_SIZE] = {0};
  57         uint8_t input_buf[TEST_DATA_SIZE] = {0};
  58
  59         sess = rte_cryptodev_asym_session_create(sess_mpool);
  60
  61         if (!sess) {
  62                 RTE_LOG(ERR, USER1, "line %u "
  63                                 "FAILED: %s", __LINE__,
  64                                 "Session creation failed");
  65                 status = TEST_FAILED;
  66                 goto error_exit;
  67         }
  68
  69         if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform,
  70                                 sess_mpool) < 0) {
  71                 RTE_LOG(ERR, USER1,
  72                                 "line %u FAILED: %s",
  73                                 __LINE__, "unabled to config sym session");
  74                 status = TEST_FAILED;
  75                 goto error_exit;
  76         }
  77
  78         /* set up crypto op data structure */
  79         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
  80         if (!op) {
  81                 RTE_LOG(ERR, USER1,
  82                                 "line %u FAILED: %s",
  83                                 __LINE__,
  84                                 "Failed to allocate asymmetric crypto "
  85                                 "operation struct");
  86                 status = TEST_FAILED;
  87                 goto error_exit;
  88         }
  89
  90         asym_op = op->asym;
  91         /* Compute sign on the test vector */
  92         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_SIGN;
  93
  94         memcpy(input_buf, &rsaplaintext.data,
  95                         rsaplaintext.len);
  96         asym_op->rsa.message.data = input_buf;
  97         asym_op->rsa.message.length = rsaplaintext.len;
  98         asym_op->rsa.sign.data = output_buf;
  99         asym_op->rsa.pad = RTE_CRYPTO_RSA_PKCS1_V1_5_BT1;
 100
 101         debug_hexdump(stdout, "message", asym_op->rsa.message.data,
 102                         asym_op->rsa.message.length);
 103
 104         /* attach asymmetric crypto session to crypto operations */
 105         rte_crypto_op_attach_asym_session(op, sess);
 106
 107         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
 108
 109         /* Process crypto operation */
 110         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 111                 RTE_LOG(ERR, USER1,
 112                                 "line %u FAILED: %s",
 113                                 __LINE__, "Error sending packet for operation");
 114                 status = TEST_FAILED;
 115                 goto error_exit;
 116         }
 117
 118         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 119                 rte_pause();
 120
 121         if (result_op == NULL) {
 122                 RTE_LOG(ERR, USER1,
 123                                 "line %u FAILED: %s",
 124                                 __LINE__, "Failed to process asym crypto op");
 125                 status = TEST_FAILED;
 126                 goto error_exit;
 127         }
 128         debug_hexdump(stdout, "signed message", asym_op->rsa.sign.data,
 129                         asym_op->rsa.sign.length);
 130         asym_op = result_op->asym;
 131
 132         /* Verify sign */
 133         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY;
 134         asym_op->rsa.pad = RTE_CRYPTO_RSA_PKCS1_V1_5_BT2;
 135
 136         /* Process crypto operation */
 137         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 138                 RTE_LOG(ERR, USER1,
 139                                 "line %u FAILED: %s",
 140                                 __LINE__, "Error sending packet for operation");
 141                 status = TEST_FAILED;
 142                 goto error_exit;
 143         }
 144
 145         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 146                 rte_pause();
 147
 148         if (result_op == NULL) {
 149                 RTE_LOG(ERR, USER1,
 150                                 "line %u FAILED: %s",
 151                                 __LINE__, "Failed to process asym crypto op");
 152                 status = TEST_FAILED;
 153                 goto error_exit;
 154         }
 155         status = TEST_SUCCESS;
 156         if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 157                 RTE_LOG(ERR, USER1,
 158                                 "line %u FAILED: %s",
 159                                 __LINE__, "Failed to process asym crypto op");
 160                 status = TEST_FAILED;
 161                 goto error_exit;
 162         }
 163
 164 error_exit:
 165
 166         if (sess) {
 167                 rte_cryptodev_asym_session_clear(dev_id, sess);
 168                 rte_cryptodev_asym_session_free(sess);
 169         }
 170
 171         if (op)
 172                 rte_crypto_op_free(op);
 173
 174         TEST_ASSERT_EQUAL(status, 0, "Test failed");
 175
 176         return status;
 177 }
 178
 179 static int
 180 test_rsa_enc_dec(void)
 181 {
 182         struct crypto_testsuite_params *ts_params = &testsuite_params;
 183         struct rte_mempool *op_mpool = ts_params->op_mpool;
 184         struct rte_mempool *sess_mpool = ts_params->session_mpool;
 185         uint8_t dev_id = ts_params->valid_devs[0];
 186         struct rte_crypto_asym_op *asym_op = NULL;
 187         struct rte_crypto_op *op = NULL, *result_op = NULL;
 188         struct rte_cryptodev_asym_session *sess = NULL;
 189         int status = TEST_SUCCESS;
 190         uint8_t input_buf[TEST_DATA_SIZE] = {0};
 191
 192         sess = rte_cryptodev_asym_session_create(sess_mpool);
 193
 194         if (!sess) {
 195                 RTE_LOG(ERR, USER1, "line %u "
 196                                 "FAILED: %s", __LINE__,
 197                                 "Session creation failed");
 198                 status = TEST_FAILED;
 199                 goto error_exit;
 200         }
 201
 202         if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform,
 203                                 sess_mpool) < 0) {
 204                 RTE_LOG(ERR, USER1,
 205                                 "line %u FAILED: %s",
 206                                 __LINE__, "unabled to config sym session");
 207                 status = TEST_FAILED;
 208                 goto error_exit;
 209         }
 210
 211         /* set up crypto op data structure */
 212         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
 213         if (!op) {
 214                 RTE_LOG(ERR, USER1,
 215                                 "line %u FAILED: %s",
 216                                 __LINE__,
 217                                 "Failed to allocate asymmetric crypto "
 218                                 "operation struct");
 219                 status = TEST_FAILED;
 220                 goto error_exit;
 221         }
 222
 223         asym_op = op->asym;
 224         /*Compute encryption on the test vector */
 225         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_ENCRYPT;
 226
 227         memcpy(input_buf, rsaplaintext.data,
 228                         rsaplaintext.len);
 229         asym_op->rsa.message.data = input_buf;
 230         asym_op->rsa.message.length = rsaplaintext.len;
 231         asym_op->rsa.pad = RTE_CRYPTO_RSA_PKCS1_V1_5_BT2;
 232
 233         debug_hexdump(stdout, "message", asym_op->rsa.message.data,
 234                         asym_op->rsa.message.length);
 235
 236         /* attach asymmetric crypto session to crypto operations */
 237         rte_crypto_op_attach_asym_session(op, sess);
 238
 239         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
 240
 241         /* Process crypto operation */
 242         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 243                 RTE_LOG(ERR, USER1,
 244                                 "line %u FAILED: %s",
 245                                 __LINE__, "Error sending packet for operation");
 246                 status = TEST_FAILED;
 247                 goto error_exit;
 248         }
 249
 250         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 251                 rte_pause();
 252
 253         if (result_op == NULL) {
 254                 RTE_LOG(ERR, USER1,
 255                                 "line %u FAILED: %s",
 256                                 __LINE__, "Failed to process asym crypto op");
 257                 status = TEST_FAILED;
 258                 goto error_exit;
 259         }
 260         debug_hexdump(stdout, "encrypted message", asym_op->rsa.message.data,
 261                         asym_op->rsa.message.length);
 262         /* Use the resulted output as decryption Input vector*/
 263         asym_op = result_op->asym;
 264         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_DECRYPT;
 265         asym_op->rsa.pad = RTE_CRYPTO_RSA_PKCS1_V1_5_BT1;
 266
 267         /* Process crypto operation */
 268         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 269                 RTE_LOG(ERR, USER1,
 270                                 "line %u FAILED: %s",
 271                                 __LINE__, "Error sending packet for operation");
 272                 status = TEST_FAILED;
 273                 goto error_exit;
 274         }
 275
 276         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 277                 rte_pause();
 278
 279         if (result_op == NULL) {
 280                 RTE_LOG(ERR, USER1,
 281                                 "line %u FAILED: %s",
 282                                 __LINE__, "Failed to process asym crypto op");
 283                 status = TEST_FAILED;
 284                 goto error_exit;
 285         }
 286         status = TEST_SUCCESS;
 287         int ret = 0;
 288         ret = rsa_verify(&rsaplaintext, result_op);
 289         if (ret)
 290                 status = TEST_FAILED;
 291
 292 error_exit:
 293
 294         if (sess) {
 295                 rte_cryptodev_asym_session_clear(dev_id, sess);
 296                 rte_cryptodev_asym_session_free(sess);
 297         }
 298
 299         if (op)
 300                 rte_crypto_op_free(op);
 301
 302         TEST_ASSERT_EQUAL(status, 0, "Test failed");
 303
 304         return status;
 305 }
 306
 307 static int
 308 testsuite_setup(void)
 309 {
 310         struct crypto_testsuite_params *ts_params = &testsuite_params;
 311         struct rte_cryptodev_info info;
 312         uint32_t i = 0, nb_devs, dev_id;
 313         int ret;
 314         uint16_t qp_id;
 315
 316         memset(ts_params, 0, sizeof(*ts_params));
 317
 318         ts_params->op_mpool = rte_crypto_op_pool_create(
 319                         "CRYPTO_ASYM_OP_POOL",
 320                         RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
 321                         TEST_NUM_BUFS, 0,
 322                         0,
 323                         rte_socket_id());
 324         if (ts_params->op_mpool == NULL) {
 325                 RTE_LOG(ERR, USER1, "Can't create ASYM_CRYPTO_OP_POOL\n");
 326                 return TEST_FAILED;
 327         }
 328
 329         /* Create an OPENSSL device if required */
 330         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 331                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
 332                 nb_devs = rte_cryptodev_device_count_by_driver(
 333                                 rte_cryptodev_driver_id_get(
 334                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
 335                 if (nb_devs < 1) {
 336                         ret = rte_vdev_init(
 337                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
 338                                 NULL);
 339
 340                         TEST_ASSERT(ret == 0, "Failed to create "
 341                                 "instance of pmd : %s",
 342                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
 343                 }
 344         }
 345
 346         nb_devs = rte_cryptodev_count();
 347         if (nb_devs < 1) {
 348                 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
 349                 return TEST_FAILED;
 350         }
 351
 352         /* Create list of valid crypto devs */
 353         for (i = 0; i < nb_devs; i++) {
 354                 rte_cryptodev_info_get(i, &info);
 355                 if (info.driver_id == gbl_driver_id)
 356                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 357         }
 358
 359         if (ts_params->valid_dev_count < 1)
 360                 return TEST_FAILED;
 361
 362         /* Set up all the qps on the first of the valid devices found */
 363
 364         dev_id = ts_params->valid_devs[0];
 365
 366         rte_cryptodev_info_get(dev_id, &info);
 367
 368         /* check if device support asymmetric, skip if not */
 369         if (!(info.feature_flags &
 370                                 RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO)) {
 371                 RTE_LOG(ERR, USER1, "Device doesn't support asymmetric. "
 372                                 "Test Skipped.\n");
 373                 return TEST_FAILED;
 374         }
 375
 376         /* configure device with num qp */
 377         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 378         ts_params->conf.socket_id = SOCKET_ID_ANY;
 379         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 380                         &ts_params->conf),
 381                         "Failed to configure cryptodev %u with %u qps",
 382                         dev_id, ts_params->conf.nb_queue_pairs);
 383
 384         /* configure qp */
 385         ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 386         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 387                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 388                         dev_id, qp_id, &ts_params->qp_conf,
 389                         rte_cryptodev_socket_id(dev_id),
 390                         ts_params->session_mpool),
 391                         "Failed to setup queue pair %u on cryptodev %u ASYM",
 392                         qp_id, dev_id);
 393         }
 394
 395         /* setup asym session pool */
 396         unsigned int session_size =
 397                 rte_cryptodev_asym_get_private_session_size(dev_id);
 398         /*
 399          * Create mempool with TEST_NUM_SESSIONS * 2,
 400          * to include the session headers
 401          */
 402         ts_params->session_mpool = rte_mempool_create(
 403                                 "test_asym_sess_mp",
 404                                 TEST_NUM_SESSIONS * 2,
 405                                 session_size,
 406                                 0, 0, NULL, NULL, NULL,
 407                                 NULL, SOCKET_ID_ANY,
 408                                 0);
 409
 410         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 411                         "session mempool allocation failed");
 412
 413         return TEST_SUCCESS;
 414 }
 415
 416 static void
 417 testsuite_teardown(void)
 418 {
 419         struct crypto_testsuite_params *ts_params = &testsuite_params;
 420
 421         if (ts_params->op_mpool != NULL) {
 422                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 423                 rte_mempool_avail_count(ts_params->op_mpool));
 424         }
 425
 426         /* Free session mempools */
 427         if (ts_params->session_mpool != NULL) {
 428                 rte_mempool_free(ts_params->session_mpool);
 429                 ts_params->session_mpool = NULL;
 430         }
 431 }
 432
 433 static int
 434 ut_setup(void)
 435 {
 436         struct crypto_testsuite_params *ts_params = &testsuite_params;
 437
 438         uint16_t qp_id;
 439
 440         /* Reconfigure device to default parameters */
 441         ts_params->conf.socket_id = SOCKET_ID_ANY;
 442
 443         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 444                         &ts_params->conf),
 445                         "Failed to configure cryptodev %u",
 446                         ts_params->valid_devs[0]);
 447
 448         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 449                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 450                         ts_params->valid_devs[0], qp_id,
 451                         &ts_params->qp_conf,
 452                         rte_cryptodev_socket_id(ts_params->valid_devs[0]),
 453                         ts_params->session_mpool),
 454                         "Failed to setup queue pair %u on cryptodev %u",
 455                         qp_id, ts_params->valid_devs[0]);
 456         }
 457
 458         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 459
 460         /* Start the device */
 461         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
 462                                                 "Failed to start cryptodev %u",
 463                                                 ts_params->valid_devs[0]);
 464
 465         return TEST_SUCCESS;
 466 }
 467
 468 static void
 469 ut_teardown(void)
 470 {
 471         struct crypto_testsuite_params *ts_params = &testsuite_params;
 472         struct rte_cryptodev_stats stats;
 473
 474         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
 475
 476         /* Stop the device */
 477         rte_cryptodev_stop(ts_params->valid_devs[0]);
 478 }
 479
 480 static inline void print_asym_capa(
 481                 const struct rte_cryptodev_asymmetric_xform_capability *capa)
 482 {
 483         int i = 0;
 484
 485         printf("\nxform type: %s\n===================\n",
 486                         rte_crypto_asym_xform_strings[capa->xform_type]);
 487         printf("operation supported -");
 488
 489         for (i = 0; i < RTE_CRYPTO_ASYM_OP_LIST_END; i++) {
 490                 /* check supported operations */
 491                 if (rte_cryptodev_asym_xform_capability_check_optype(capa, i))
 492                         printf(" %s",
 493                                         rte_crypto_asym_op_strings[i]);
 494                 }
 495                 switch (capa->xform_type) {
 496                 case RTE_CRYPTO_ASYM_XFORM_RSA:
 497                 case RTE_CRYPTO_ASYM_XFORM_MODINV:
 498                 case RTE_CRYPTO_ASYM_XFORM_MODEX:
 499                 case RTE_CRYPTO_ASYM_XFORM_DH:
 500                 case RTE_CRYPTO_ASYM_XFORM_DSA:
 501                         printf(" modlen: min %d max %d increment %d\n",
 502                                         capa->modlen.min,
 503                                         capa->modlen.max,
 504                                         capa->modlen.increment);
 505                 break;
 506                 default:
 507                         break;
 508                 }
 509 }
 510
 511 static int
 512 test_capability(void)
 513 {
 514         struct crypto_testsuite_params *ts_params = &testsuite_params;
 515         uint8_t dev_id = ts_params->valid_devs[0];
 516         struct rte_cryptodev_info dev_info;
 517         const struct rte_cryptodev_capabilities *dev_capa;
 518         int i = 0;
 519         struct rte_cryptodev_asym_capability_idx idx;
 520         const struct rte_cryptodev_asymmetric_xform_capability *capa;
 521
 522         rte_cryptodev_info_get(dev_id, &dev_info);
 523         if (!(dev_info.feature_flags &
 524                                 RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO)) {
 525                 RTE_LOG(INFO, USER1,
 526                                 "Device doesn't support asymmetric. Test Skipped\n");
 527                 return TEST_SUCCESS;
 528         }
 529
 530         /* print xform capability */
 531         for (i = 0;
 532                 dev_info.capabilities[i].op != RTE_CRYPTO_OP_TYPE_UNDEFINED;
 533                 i++) {
 534                 dev_capa = &(dev_info.capabilities[i]);
 535                 if (dev_info.capabilities[i].op ==
 536                                 RTE_CRYPTO_OP_TYPE_ASYMMETRIC) {
 537                         idx.type = dev_capa->asym.xform_capa.xform_type;
 538
 539                         capa = rte_cryptodev_asym_capability_get(dev_id,
 540                                 (const struct
 541                                 rte_cryptodev_asym_capability_idx *) &idx);
 542                         print_asym_capa(capa);
 543                         }
 544         }
 545         return TEST_SUCCESS;
 546 }
 547
 548 static int
 549 test_dh_gen_shared_sec(struct rte_crypto_asym_xform *xfrm)
 550 {
 551         struct crypto_testsuite_params *ts_params = &testsuite_params;
 552         struct rte_mempool *op_mpool = ts_params->op_mpool;
 553         struct rte_mempool *sess_mpool = ts_params->session_mpool;
 554         uint8_t dev_id = ts_params->valid_devs[0];
 555         struct rte_crypto_asym_op *asym_op = NULL;
 556         struct rte_crypto_op *op = NULL, *result_op = NULL;
 557         struct rte_cryptodev_asym_session *sess = NULL;
 558         int status = TEST_SUCCESS;
 559         uint8_t output[TEST_DH_MOD_LEN];
 560         struct rte_crypto_asym_xform xform = *xfrm;
 561         uint8_t peer[] = "01234567890123456789012345678901234567890123456789";
 562
 563         sess = rte_cryptodev_asym_session_create(sess_mpool);
 564         if (sess == NULL) {
 565                 RTE_LOG(ERR, USER1,
 566                                 "line %u FAILED: %s", __LINE__,
 567                                 "Session creation failed");
 568                 status = TEST_FAILED;
 569                 goto error_exit;
 570         }
 571         /* set up crypto op data structure */
 572         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
 573         if (!op) {
 574                 RTE_LOG(ERR, USER1,
 575                         "line %u FAILED: %s",
 576                         __LINE__, "Failed to allocate asymmetric crypto "
 577                         "operation struct");
 578                 status = TEST_FAILED;
 579                 goto error_exit;
 580         }
 581         asym_op = op->asym;
 582
 583         /* Setup a xform and op to generate private key only */
 584         xform.dh.type = RTE_CRYPTO_ASYM_OP_SHARED_SECRET_COMPUTE;
 585         xform.next = NULL;
 586         asym_op->dh.priv_key.data = dh_test_params.priv_key.data;
 587         asym_op->dh.priv_key.length = dh_test_params.priv_key.length;
 588         asym_op->dh.pub_key.data = (uint8_t *)peer;
 589         asym_op->dh.pub_key.length = sizeof(peer);
 590         asym_op->dh.shared_secret.data = output;
 591         asym_op->dh.shared_secret.length = sizeof(output);
 592
 593         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
 594                         sess_mpool) < 0) {
 595                 RTE_LOG(ERR, USER1,
 596                                 "line %u FAILED: %s",
 597                                 __LINE__, "unabled to config sym session");
 598                 status = TEST_FAILED;
 599                 goto error_exit;
 600         }
 601
 602         /* attach asymmetric crypto session to crypto operations */
 603         rte_crypto_op_attach_asym_session(op, sess);
 604
 605         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
 606
 607         /* Process crypto operation */
 608         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 609                 RTE_LOG(ERR, USER1,
 610                         "line %u FAILED: %s",
 611                         __LINE__, "Error sending packet for operation");
 612                 status = TEST_FAILED;
 613                 goto error_exit;
 614         }
 615
 616         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 617                 rte_pause();
 618
 619         if (result_op == NULL) {
 620                 RTE_LOG(ERR, USER1,
 621                         "line %u FAILED: %s",
 622                         __LINE__, "Failed to process asym crypto op");
 623                 status = TEST_FAILED;
 624                 goto error_exit;
 625         }
 626
 627         debug_hexdump(stdout, "shared secret:",
 628                         asym_op->dh.shared_secret.data,
 629                         asym_op->dh.shared_secret.length);
 630
 631 error_exit:
 632         if (sess != NULL) {
 633                 rte_cryptodev_asym_session_clear(dev_id, sess);
 634                 rte_cryptodev_asym_session_free(sess);
 635         }
 636         if (op != NULL)
 637                 rte_crypto_op_free(op);
 638         return status;
 639 }
 640
 641 static int
 642 test_dh_gen_priv_key(struct rte_crypto_asym_xform *xfrm)
 643 {
 644         struct crypto_testsuite_params *ts_params = &testsuite_params;
 645         struct rte_mempool *op_mpool = ts_params->op_mpool;
 646         struct rte_mempool *sess_mpool = ts_params->session_mpool;
 647         uint8_t dev_id = ts_params->valid_devs[0];
 648         struct rte_crypto_asym_op *asym_op = NULL;
 649         struct rte_crypto_op *op = NULL, *result_op = NULL;
 650         struct rte_cryptodev_asym_session *sess = NULL;
 651         int status = TEST_SUCCESS;
 652         uint8_t output[TEST_DH_MOD_LEN];
 653         struct rte_crypto_asym_xform xform = *xfrm;
 654
 655         sess = rte_cryptodev_asym_session_create(sess_mpool);
 656         if (sess == NULL) {
 657                 RTE_LOG(ERR, USER1,
 658                                  "line %u FAILED: %s", __LINE__,
 659                                 "Session creation failed");
 660                 status = TEST_FAILED;
 661                 goto error_exit;
 662         }
 663         /* set up crypto op data structure */
 664         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
 665         if (!op) {
 666                 RTE_LOG(ERR, USER1,
 667                         "line %u FAILED: %s",
 668                         __LINE__, "Failed to allocate asymmetric crypto "
 669                         "operation struct");
 670                 status = TEST_FAILED;
 671                 goto error_exit;
 672         }
 673         asym_op = op->asym;
 674
 675         /* Setup a xform and op to generate private key only */
 676         xform.dh.type = RTE_CRYPTO_ASYM_OP_PRIVATE_KEY_GENERATE;
 677         xform.next = NULL;
 678         asym_op->dh.priv_key.data = output;
 679         asym_op->dh.priv_key.length = sizeof(output);
 680
 681         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
 682                         sess_mpool) < 0) {
 683                 RTE_LOG(ERR, USER1,
 684                                 "line %u FAILED: %s",
 685                                 __LINE__, "unabled to config sym session");
 686                 status = TEST_FAILED;
 687                 goto error_exit;
 688         }
 689
 690         /* attach asymmetric crypto session to crypto operations */
 691         rte_crypto_op_attach_asym_session(op, sess);
 692
 693         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
 694
 695         /* Process crypto operation */
 696         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 697                 RTE_LOG(ERR, USER1,
 698                         "line %u FAILED: %s",
 699                         __LINE__, "Error sending packet for operation");
 700                 status = TEST_FAILED;
 701                 goto error_exit;
 702         }
 703
 704         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 705                 rte_pause();
 706
 707         if (result_op == NULL) {
 708                 RTE_LOG(ERR, USER1,
 709                         "line %u FAILED: %s",
 710                         __LINE__, "Failed to process asym crypto op");
 711                 status = TEST_FAILED;
 712                 goto error_exit;
 713         }
 714
 715         debug_hexdump(stdout, "private key:",
 716                         asym_op->dh.priv_key.data,
 717                         asym_op->dh.priv_key.length);
 718
 719
 720 error_exit:
 721         if (sess != NULL) {
 722                 rte_cryptodev_asym_session_clear(dev_id, sess);
 723                 rte_cryptodev_asym_session_free(sess);
 724         }
 725         if (op != NULL)
 726                 rte_crypto_op_free(op);
 727
 728         return status;
 729 }
 730
 731
 732 static int
 733 test_dh_gen_pub_key(struct rte_crypto_asym_xform *xfrm)
 734 {
 735         struct crypto_testsuite_params *ts_params = &testsuite_params;
 736         struct rte_mempool *op_mpool = ts_params->op_mpool;
 737         struct rte_mempool *sess_mpool = ts_params->session_mpool;
 738         uint8_t dev_id = ts_params->valid_devs[0];
 739         struct rte_crypto_asym_op *asym_op = NULL;
 740         struct rte_crypto_op *op = NULL, *result_op = NULL;
 741         struct rte_cryptodev_asym_session *sess = NULL;
 742         int status = TEST_SUCCESS;
 743         uint8_t output[TEST_DH_MOD_LEN];
 744         struct rte_crypto_asym_xform xform = *xfrm;
 745
 746         sess = rte_cryptodev_asym_session_create(sess_mpool);
 747         if (sess == NULL) {
 748                 RTE_LOG(ERR, USER1,
 749                                  "line %u FAILED: %s", __LINE__,
 750                                 "Session creation failed");
 751                 status = TEST_FAILED;
 752                 goto error_exit;
 753         }
 754         /* set up crypto op data structure */
 755         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
 756         if (!op) {
 757                 RTE_LOG(ERR, USER1,
 758                         "line %u FAILED: %s",
 759                         __LINE__, "Failed to allocate asymmetric crypto "
 760                         "operation struct");
 761                 status = TEST_FAILED;
 762                 goto error_exit;
 763         }
 764         asym_op = op->asym;
 765         /* Setup a xform chain to generate public key
 766          * using test private key
 767          *
 768          */
 769         xform.dh.type = RTE_CRYPTO_ASYM_OP_PUBLIC_KEY_GENERATE;
 770         xform.next = NULL;
 771
 772         asym_op->dh.pub_key.data = output;
 773         asym_op->dh.pub_key.length = sizeof(output);
 774         /* load pre-defined private key */
 775         asym_op->dh.priv_key.data = rte_malloc(NULL,
 776                                         dh_test_params.priv_key.length,
 777                                         0);
 778         asym_op->dh.priv_key = dh_test_params.priv_key;
 779
 780         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
 781                         sess_mpool) < 0) {
 782                 RTE_LOG(ERR, USER1,
 783                                 "line %u FAILED: %s",
 784                                 __LINE__, "unabled to config sym session");
 785                 status = TEST_FAILED;
 786                 goto error_exit;
 787         }
 788
 789         /* attach asymmetric crypto session to crypto operations */
 790         rte_crypto_op_attach_asym_session(op, sess);
 791
 792         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
 793
 794         /* Process crypto operation */
 795         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 796                 RTE_LOG(ERR, USER1,
 797                         "line %u FAILED: %s",
 798                         __LINE__, "Error sending packet for operation");
 799                 status = TEST_FAILED;
 800                 goto error_exit;
 801         }
 802
 803         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 804                 rte_pause();
 805
 806         if (result_op == NULL) {
 807                 RTE_LOG(ERR, USER1,
 808                         "line %u FAILED: %s",
 809                         __LINE__, "Failed to process asym crypto op");
 810                 status = TEST_FAILED;
 811                 goto error_exit;
 812         }
 813
 814         debug_hexdump(stdout, "pub key:",
 815                         asym_op->dh.pub_key.data, asym_op->dh.pub_key.length);
 816
 817         debug_hexdump(stdout, "priv key:",
 818                         asym_op->dh.priv_key.data, asym_op->dh.priv_key.length);
 819
 820 error_exit:
 821         if (sess != NULL) {
 822                 rte_cryptodev_asym_session_clear(dev_id, sess);
 823                 rte_cryptodev_asym_session_free(sess);
 824         }
 825         if (op != NULL)
 826                 rte_crypto_op_free(op);
 827
 828         return status;
 829 }
 830
 831 static int
 832 test_dh_gen_kp(struct rte_crypto_asym_xform *xfrm)
 833 {
 834         struct crypto_testsuite_params *ts_params = &testsuite_params;
 835         struct rte_mempool *op_mpool = ts_params->op_mpool;
 836         struct rte_mempool *sess_mpool = ts_params->session_mpool;
 837         uint8_t dev_id = ts_params->valid_devs[0];
 838         struct rte_crypto_asym_op *asym_op = NULL;
 839         struct rte_crypto_op *op = NULL, *result_op = NULL;
 840         struct rte_cryptodev_asym_session *sess = NULL;
 841         int status = TEST_SUCCESS;
 842         uint8_t out_pub_key[TEST_DH_MOD_LEN];
 843         uint8_t out_prv_key[TEST_DH_MOD_LEN];
 844         struct rte_crypto_asym_xform pub_key_xform;
 845         struct rte_crypto_asym_xform xform = *xfrm;
 846
 847         sess = rte_cryptodev_asym_session_create(sess_mpool);
 848         if (sess == NULL) {
 849                 RTE_LOG(ERR, USER1,
 850                                  "line %u FAILED: %s", __LINE__,
 851                                 "Session creation failed");
 852                 status = TEST_FAILED;
 853                 goto error_exit;
 854         }
 855
 856         /* set up crypto op data structure */
 857         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
 858         if (!op) {
 859                 RTE_LOG(ERR, USER1,
 860                         "line %u FAILED: %s",
 861                         __LINE__, "Failed to allocate asymmetric crypto "
 862                         "operation struct");
 863                 status = TEST_FAILED;
 864                 goto error_exit;
 865         }
 866         asym_op = op->asym;
 867         /* Setup a xform chain to generate
 868          * private key first followed by
 869          * public key
 870          */xform.dh.type = RTE_CRYPTO_ASYM_OP_PRIVATE_KEY_GENERATE;
 871         pub_key_xform.xform_type = RTE_CRYPTO_ASYM_XFORM_DH;
 872         pub_key_xform.dh.type = RTE_CRYPTO_ASYM_OP_PUBLIC_KEY_GENERATE;
 873         xform.next = &pub_key_xform;
 874
 875         asym_op->dh.pub_key.data = out_pub_key;
 876         asym_op->dh.pub_key.length = sizeof(out_pub_key);
 877         asym_op->dh.priv_key.data = out_prv_key;
 878         asym_op->dh.priv_key.length = sizeof(out_prv_key);
 879         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
 880                         sess_mpool) < 0) {
 881                 RTE_LOG(ERR, USER1,
 882                                 "line %u FAILED: %s",
 883                                 __LINE__, "unabled to config sym session");
 884                 status = TEST_FAILED;
 885                 goto error_exit;
 886         }
 887
 888         /* attach asymmetric crypto session to crypto operations */
 889         rte_crypto_op_attach_asym_session(op, sess);
 890
 891         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
 892
 893         /* Process crypto operation */
 894         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 895                 RTE_LOG(ERR, USER1,
 896                         "line %u FAILED: %s",
 897                         __LINE__, "Error sending packet for operation");
 898                 status = TEST_FAILED;
 899                 goto error_exit;
 900         }
 901
 902         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
 903                 rte_pause();
 904
 905         if (result_op == NULL) {
 906                 RTE_LOG(ERR, USER1,
 907                         "line %u FAILED: %s",
 908                         __LINE__, "Failed to process asym crypto op");
 909                 status = TEST_FAILED;
 910                 goto error_exit;
 911         }
 912         debug_hexdump(stdout, "priv key:",
 913                         out_prv_key, asym_op->dh.priv_key.length);
 914         debug_hexdump(stdout, "pub key:",
 915                         out_pub_key, asym_op->dh.pub_key.length);
 916
 917 error_exit:
 918         if (sess != NULL) {
 919                 rte_cryptodev_asym_session_clear(dev_id, sess);
 920                 rte_cryptodev_asym_session_free(sess);
 921         }
 922         if (op != NULL)
 923                 rte_crypto_op_free(op);
 924
 925         return status;
 926 }
 927
 928 static int
 929 test_mod_inv(void)
 930 {
 931         struct crypto_testsuite_params *ts_params = &testsuite_params;
 932         struct rte_mempool *op_mpool = ts_params->op_mpool;
 933         struct rte_mempool *sess_mpool = ts_params->session_mpool;
 934         uint8_t dev_id = ts_params->valid_devs[0];
 935         struct rte_crypto_asym_op *asym_op = NULL;
 936         struct rte_crypto_op *op = NULL, *result_op = NULL;
 937         struct rte_cryptodev_asym_session *sess = NULL;
 938         int status = TEST_SUCCESS;
 939         struct rte_cryptodev_asym_capability_idx cap_idx;
 940         const struct rte_cryptodev_asymmetric_xform_capability *capability;
 941         uint8_t input[TEST_DATA_SIZE] = {0};
 942         int ret = 0;
 943
 944         if (rte_cryptodev_asym_get_xform_enum(
 945                 &modinv_xform.xform_type, "modinv") < 0) {
 946                 RTE_LOG(ERR, USER1,
 947                                  "Invalid ASYNC algorithm specified\n");
 948                 return -1;
 949         }
 950
 951         cap_idx.type = modinv_xform.xform_type;
 952         capability = rte_cryptodev_asym_capability_get(dev_id,
 953                                         &cap_idx);
 954
 955         if (rte_cryptodev_asym_xform_capability_check_modlen(
 956                 capability,
 957                 modinv_xform.modinv.modulus.length)) {
 958                 RTE_LOG(ERR, USER1,
 959                                  "Invalid MODULOUS length specified\n");
 960                                 return -1;
 961                 }
 962
 963         sess = rte_cryptodev_asym_session_create(sess_mpool);
 964         if (!sess) {
 965                 RTE_LOG(ERR, USER1, "line %u "
 966                                 "FAILED: %s", __LINE__,
 967                                 "Session creation failed");
 968                 status = TEST_FAILED;
 969                 goto error_exit;
 970         }
 971
 972         if (rte_cryptodev_asym_session_init(dev_id, sess, &modinv_xform,
 973                         sess_mpool) < 0) {
 974                 RTE_LOG(ERR, USER1,
 975                                 "line %u FAILED: %s",
 976                                 __LINE__, "unabled to config sym session");
 977                 status = TEST_FAILED;
 978                 goto error_exit;
 979         }
 980
 981         /* generate crypto op data structure */
 982         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
 983         if (!op) {
 984                 RTE_LOG(ERR, USER1,
 985                         "line %u FAILED: %s",
 986                         __LINE__, "Failed to allocate asymmetric crypto "
 987                         "operation struct");
 988                 status = TEST_FAILED;
 989                 goto error_exit;
 990         }
 991
 992         asym_op = op->asym;
 993         memcpy(input, base, sizeof(base));
 994         asym_op->modinv.base.data = input;
 995         asym_op->modinv.base.length = sizeof(base);
 996
 997         /* attach asymmetric crypto session to crypto operations */
 998         rte_crypto_op_attach_asym_session(op, sess);
 999
1000         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1001
1002         /* Process crypto operation */
1003         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1004                 RTE_LOG(ERR, USER1,
1005                         "line %u FAILED: %s",
1006                         __LINE__, "Error sending packet for operation");
1007                 status = TEST_FAILED;
1008                 goto error_exit;
1009         }
1010
1011         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1012                 rte_pause();
1013
1014         if (result_op == NULL) {
1015                 RTE_LOG(ERR, USER1,
1016                                 "line %u FAILED: %s",
1017                                 __LINE__, "Failed to process asym crypto op");
1018                 status = TEST_FAILED;
1019                 goto error_exit;
1020         }
1021
1022         ret = verify_modinv(mod_inv, result_op);
1023         if (ret) {
1024                 RTE_LOG(ERR, USER1,
1025                          "operation verification failed\n");
1026                 status = TEST_FAILED;
1027         }
1028
1029 error_exit:
1030         if (sess) {
1031                 rte_cryptodev_asym_session_clear(dev_id, sess);
1032                 rte_cryptodev_asym_session_free(sess);
1033         }
1034
1035         if (op)
1036                 rte_crypto_op_free(op);
1037
1038         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1039
1040         return status;
1041 }
1042
1043 static int
1044 test_mod_exp(void)
1045 {
1046         struct crypto_testsuite_params *ts_params = &testsuite_params;
1047         struct rte_mempool *op_mpool = ts_params->op_mpool;
1048         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1049         uint8_t dev_id = ts_params->valid_devs[0];
1050         struct rte_crypto_asym_op *asym_op = NULL;
1051         struct rte_crypto_op *op = NULL, *result_op = NULL;
1052         struct rte_cryptodev_asym_session *sess = NULL;
1053         int status = TEST_SUCCESS;
1054         struct rte_cryptodev_asym_capability_idx cap_idx;
1055         const struct rte_cryptodev_asymmetric_xform_capability *capability;
1056         uint8_t input[TEST_DATA_SIZE] = {0};
1057         int ret = 0;
1058
1059         if (rte_cryptodev_asym_get_xform_enum(&modex_xform.xform_type,
1060                 "modexp")
1061                 < 0) {
1062                 RTE_LOG(ERR, USER1,
1063                                 "Invalid ASYNC algorithm specified\n");
1064                 return -1;
1065         }
1066
1067         /* check for modlen capability */
1068         cap_idx.type = modex_xform.xform_type;
1069         capability = rte_cryptodev_asym_capability_get(dev_id, &cap_idx);
1070
1071         if (rte_cryptodev_asym_xform_capability_check_modlen(
1072                         capability, modex_xform.modex.modulus.length)) {
1073                 RTE_LOG(ERR, USER1,
1074                                 "Invalid MODULOUS length specified\n");
1075                                 return -1;
1076                 }
1077
1078         /* generate crypto op data structure */
1079         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1080         if (!op) {
1081                 RTE_LOG(ERR, USER1,
1082                         "line %u FAILED: %s",
1083                         __LINE__, "Failed to allocate asymmetric crypto "
1084                         "operation struct");
1085                 status = TEST_FAILED;
1086                 goto error_exit;
1087         }
1088
1089         sess = rte_cryptodev_asym_session_create(sess_mpool);
1090         if (!sess) {
1091                 RTE_LOG(ERR, USER1,
1092                                  "line %u "
1093                                 "FAILED: %s", __LINE__,
1094                                 "Session creation failed");
1095                 status = TEST_FAILED;
1096                 goto error_exit;
1097         }
1098
1099         if (rte_cryptodev_asym_session_init(dev_id, sess, &modex_xform,
1100                         sess_mpool) < 0) {
1101                 RTE_LOG(ERR, USER1,
1102                                 "line %u FAILED: %s",
1103                                 __LINE__, "unabled to config sym session");
1104                 status = TEST_FAILED;
1105                 goto error_exit;
1106         }
1107
1108         asym_op = op->asym;
1109         memcpy(input, base, sizeof(base));
1110         asym_op->modex.base.data = input;
1111         asym_op->modex.base.length = sizeof(base);
1112         /* attach asymmetric crypto session to crypto operations */
1113         rte_crypto_op_attach_asym_session(op, sess);
1114
1115         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1116         /* Process crypto operation */
1117         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1118                 RTE_LOG(ERR, USER1,
1119                                 "line %u FAILED: %s",
1120                                 __LINE__, "Error sending packet for operation");
1121                 status = TEST_FAILED;
1122                 goto error_exit;
1123         }
1124
1125         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1126                 rte_pause();
1127
1128         if (result_op == NULL) {
1129                 RTE_LOG(ERR, USER1,
1130                                 "line %u FAILED: %s",
1131                                 __LINE__, "Failed to process asym crypto op");
1132                 status = TEST_FAILED;
1133                 goto error_exit;
1134         }
1135
1136         ret = verify_modexp(mod_exp, result_op);
1137         if (ret) {
1138                 RTE_LOG(ERR, USER1,
1139                          "operation verification failed\n");
1140                 status = TEST_FAILED;
1141         }
1142
1143 error_exit:
1144         if (sess != NULL) {
1145                 rte_cryptodev_asym_session_clear(dev_id, sess);
1146                 rte_cryptodev_asym_session_free(sess);
1147         }
1148
1149         if (op != NULL)
1150                 rte_crypto_op_free(op);
1151
1152         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1153
1154         return status;
1155 }
1156
1157 static int
1158 test_dh_keygenration(void)
1159 {
1160         int status;
1161
1162         debug_hexdump(stdout, "p:", dh_xform.dh.p.data, dh_xform.dh.p.length);
1163         debug_hexdump(stdout, "g:", dh_xform.dh.g.data, dh_xform.dh.g.length);
1164         debug_hexdump(stdout, "priv_key:", dh_test_params.priv_key.data,
1165                         dh_test_params.priv_key.length);
1166
1167         RTE_LOG(INFO, USER1,
1168                 "Test Public and Private key pair generation\n");
1169
1170         status = test_dh_gen_kp(&dh_xform);
1171         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1172
1173         RTE_LOG(INFO, USER1,
1174                 "Test Public Key Generation using pre-defined priv key\n");
1175
1176         status = test_dh_gen_pub_key(&dh_xform);
1177         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1178
1179         RTE_LOG(INFO, USER1,
1180                 "Test Private Key Generation only\n");
1181
1182         status = test_dh_gen_priv_key(&dh_xform);
1183         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1184
1185         RTE_LOG(INFO, USER1,
1186                 "Test shared secret compute\n");
1187
1188         status = test_dh_gen_shared_sec(&dh_xform);
1189         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1190
1191         return status;
1192 }
1193
1194 static int
1195 test_dsa_sign(void)
1196 {
1197         struct crypto_testsuite_params *ts_params = &testsuite_params;
1198         struct rte_mempool *op_mpool = ts_params->op_mpool;
1199         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1200         uint8_t dev_id = ts_params->valid_devs[0];
1201         struct rte_crypto_asym_op *asym_op = NULL;
1202         struct rte_crypto_op *op = NULL, *result_op = NULL;
1203         struct rte_cryptodev_asym_session *sess = NULL;
1204         int status = TEST_SUCCESS;
1205         uint8_t r[TEST_DH_MOD_LEN];
1206         uint8_t s[TEST_DH_MOD_LEN];
1207         uint8_t dgst[] = "35d81554afaad2cf18f3a1770d5fedc4ea5be344";
1208
1209         sess = rte_cryptodev_asym_session_create(sess_mpool);
1210         if (sess == NULL) {
1211                 RTE_LOG(ERR, USER1,
1212                                  "line %u FAILED: %s", __LINE__,
1213                                 "Session creation failed");
1214                 status = TEST_FAILED;
1215                 goto error_exit;
1216         }
1217         /* set up crypto op data structure */
1218         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1219         if (!op) {
1220                 RTE_LOG(ERR, USER1,
1221                         "line %u FAILED: %s",
1222                         __LINE__, "Failed to allocate asymmetric crypto "
1223                         "operation struct");
1224                 status = TEST_FAILED;
1225                 goto error_exit;
1226         }
1227         asym_op = op->asym;
1228
1229         debug_hexdump(stdout, "p: ", dsa_xform.dsa.p.data,
1230                         dsa_xform.dsa.p.length);
1231         debug_hexdump(stdout, "q: ", dsa_xform.dsa.q.data,
1232                         dsa_xform.dsa.q.length);
1233         debug_hexdump(stdout, "g: ", dsa_xform.dsa.g.data,
1234                         dsa_xform.dsa.g.length);
1235         debug_hexdump(stdout, "priv_key: ", dsa_xform.dsa.x.data,
1236                         dsa_xform.dsa.x.length);
1237
1238         if (rte_cryptodev_asym_session_init(dev_id, sess, &dsa_xform,
1239                                 sess_mpool) < 0) {
1240                 RTE_LOG(ERR, USER1,
1241                                 "line %u FAILED: %s",
1242                                 __LINE__, "unabled to config sym session");
1243                 status = TEST_FAILED;
1244                 goto error_exit;
1245         }
1246
1247         /* attach asymmetric crypto session to crypto operations */
1248         rte_crypto_op_attach_asym_session(op, sess);
1249         asym_op->dsa.op_type = RTE_CRYPTO_ASYM_OP_SIGN;
1250         asym_op->dsa.message.data = dgst;
1251         asym_op->dsa.message.length = sizeof(dgst);
1252         asym_op->dsa.r.length = sizeof(r);
1253         asym_op->dsa.r.data = r;
1254         asym_op->dsa.s.length = sizeof(s);
1255         asym_op->dsa.s.data = s;
1256
1257         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1258
1259         /* Process crypto operation */
1260         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1261                 RTE_LOG(ERR, USER1,
1262                         "line %u FAILED: %s",
1263                         __LINE__, "Error sending packet for operation");
1264                 status = TEST_FAILED;
1265                 goto error_exit;
1266         }
1267
1268         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1269                 rte_pause();
1270
1271         if (result_op == NULL) {
1272                 RTE_LOG(ERR, USER1,
1273                         "line %u FAILED: %s",
1274                         __LINE__, "Failed to process asym crypto op");
1275                 status = TEST_FAILED;
1276                 goto error_exit;
1277         }
1278
1279         asym_op = result_op->asym;
1280
1281         debug_hexdump(stdout, "r:",
1282                         asym_op->dsa.r.data, asym_op->dsa.r.length);
1283         debug_hexdump(stdout, "s:",
1284                         asym_op->dsa.s.data, asym_op->dsa.s.length);
1285
1286         /* Test PMD DSA sign verification using signer public key */
1287         asym_op->dsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY;
1288
1289         /* copy signer public key */
1290         asym_op->dsa.y.data = dsa_test_params.y.data;
1291         asym_op->dsa.y.length = dsa_test_params.y.length;
1292
1293         /* Process crypto operation */
1294         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1295                 RTE_LOG(ERR, USER1,
1296                         "line %u FAILED: %s",
1297                         __LINE__, "Error sending packet for operation");
1298                 status = TEST_FAILED;
1299                 goto error_exit;
1300         }
1301
1302         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1303                 rte_pause();
1304
1305         if (result_op == NULL) {
1306                 RTE_LOG(ERR, USER1,
1307                         "line %u FAILED: %s",
1308                         __LINE__, "Failed to process asym crypto op");
1309                 status = TEST_FAILED;
1310                 goto error_exit;
1311         }
1312
1313         if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
1314                 RTE_LOG(ERR, USER1,
1315                                 "line %u FAILED: %s",
1316                                 __LINE__, "Failed to process asym crypto op");
1317                 status = TEST_FAILED;
1318         }
1319 error_exit:
1320         if (sess != NULL) {
1321                 rte_cryptodev_asym_session_clear(dev_id, sess);
1322                 rte_cryptodev_asym_session_free(sess);
1323         }
1324         if (op != NULL)
1325                 rte_crypto_op_free(op);
1326         return status;
1327 }
1328
1329 static int
1330 test_dsa(void)
1331 {
1332         int status;
1333         status = test_dsa_sign();
1334         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1335         return status;
1336 }
1337
1338
1339 static struct unit_test_suite cryptodev_openssl_asym_testsuite  = {
1340         .suite_name = "Crypto Device OPENSSL ASYM Unit Test Suite",
1341         .setup = testsuite_setup,
1342         .teardown = testsuite_teardown,
1343         .unit_test_cases = {
1344                 TEST_CASE_ST(ut_setup, ut_teardown, test_capability),
1345                 TEST_CASE_ST(ut_setup, ut_teardown, test_dsa),
1346                 TEST_CASE_ST(ut_setup, ut_teardown, test_dh_keygenration),
1347                 TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_enc_dec),
1348                 TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_sign_verify),
1349                 TEST_CASE_ST(ut_setup, ut_teardown, test_mod_inv),
1350                 TEST_CASE_ST(ut_setup, ut_teardown, test_mod_exp),
1351                 TEST_CASES_END() /**< NULL terminate unit test array */
1352         }
1353 };
1354
1355 static int
1356 test_cryptodev_openssl_asym(void)
1357 {
1358         gbl_driver_id = rte_cryptodev_driver_id_get(
1359                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
1360
1361         if (gbl_driver_id == -1) {
1362                 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
1363                                 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
1364                                 "in config file to run this testsuite.\n");
1365                 return TEST_FAILED;
1366         }
1367
1368         return unit_test_suite_runner(&cryptodev_openssl_asym_testsuite);
1369 }
1370
1371 REGISTER_TEST_COMMAND(cryptodev_openssl_asym_autotest,
1372                                           test_cryptodev_openssl_asym);