app/test/test_cryptodev.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2015 Intel Corporation. All rights reserved.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *       * Redistributions of source code must retain the above copyright
  11  *         notice, this list of conditions and the following disclaimer.
  12  *       * Redistributions in binary form must reproduce the above copyright
  13  *         notice, this list of conditions and the following disclaimer in
  14  *         the documentation and/or other materials provided with the
  15  *         distribution.
  16  *       * Neither the name of Intel Corporation nor the names of its
  17  *         contributors may be used to endorse or promote products derived
  18  *         from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <rte_common.h>
  34 #include <rte_hexdump.h>
  35 #include <rte_mbuf.h>
  36 #include <rte_malloc.h>
  37 #include <rte_memcpy.h>
  38 #include <rte_mbuf_offload.h>
  39
  40 #include <rte_crypto.h>
  41 #include <rte_cryptodev.h>
  42 #include <rte_cryptodev_pmd.h>
  43
  44 #include "test.h"
  45 #include "test_cryptodev.h"
  46
  47 static enum rte_cryptodev_type gbl_cryptodev_type;
  48
  49 struct crypto_testsuite_params {
  50         struct rte_mempool *mbuf_pool;
  51         struct rte_mempool *mbuf_ol_pool;
  52         struct rte_cryptodev_config conf;
  53         struct rte_cryptodev_qp_conf qp_conf;
  54
  55         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  56         uint8_t valid_dev_count;
  57 };
  58
  59 struct crypto_unittest_params {
  60         struct rte_crypto_xform cipher_xform;
  61         struct rte_crypto_xform auth_xform;
  62
  63         struct rte_cryptodev_session *sess;
  64
  65         struct rte_mbuf_offload *ol;
  66         struct rte_crypto_op *op;
  67
  68         struct rte_mbuf *obuf, *ibuf;
  69
  70         uint8_t *digest;
  71 };
  72
  73 /*
  74  * Forward declarations.
  75  */
  76 static int
  77 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
  78                 struct crypto_unittest_params *ut_params);
  79
  80 static int
  81 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_session *sess,
  82                 struct crypto_unittest_params *ut_params,
  83                 struct crypto_testsuite_params *ts_param);
  84
  85 static struct rte_mbuf *
  86 setup_test_string(struct rte_mempool *mpool,
  87                 const char *string, size_t len, uint8_t blocksize)
  88 {
  89         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
  90         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
  91
  92         memset(m->buf_addr, 0, m->buf_len);
  93         if (m) {
  94                 char *dst = rte_pktmbuf_append(m, t_len);
  95
  96                 if (!dst) {
  97                         rte_pktmbuf_free(m);
  98                         return NULL;
  99                 }
 100
 101                 rte_memcpy(dst, string, t_len);
 102         }
 103
 104         return m;
 105 }
 106
 107 #if HEX_DUMP
 108 static void
 109 hexdump_mbuf_data(FILE *f, const char *title, struct rte_mbuf *m)
 110 {
 111         rte_hexdump(f, title, rte_pktmbuf_mtod(m, const void *), m->data_len);
 112 }
 113 #endif
 114
 115 static struct rte_mbuf *
 116 process_crypto_request(uint8_t dev_id, struct rte_mbuf *ibuf)
 117 {
 118         struct rte_mbuf *obuf = NULL;
 119 #if HEX_DUMP
 120         hexdump_mbuf_data(stdout, "Enqueued Packet", ibuf);
 121 #endif
 122
 123         if (rte_cryptodev_enqueue_burst(dev_id, 0, &ibuf, 1) != 1) {
 124                 printf("Error sending packet for encryption");
 125                 return NULL;
 126         }
 127         while (rte_cryptodev_dequeue_burst(dev_id, 0, &obuf, 1) == 0)
 128                 rte_pause();
 129
 130 #if HEX_DUMP
 131         if (obuf)
 132                 hexdump_mbuf_data(stdout, "Dequeued Packet", obuf);
 133 #endif
 134
 135         return obuf;
 136 }
 137
 138 static struct crypto_testsuite_params testsuite_params = { NULL };
 139 static struct crypto_unittest_params unittest_params;
 140
 141 static int
 142 testsuite_setup(void)
 143 {
 144         struct crypto_testsuite_params *ts_params = &testsuite_params;
 145         struct rte_cryptodev_info info;
 146         unsigned i, nb_devs, dev_id;
 147         int ret;
 148         uint16_t qp_id;
 149
 150         memset(ts_params, 0, sizeof(*ts_params));
 151
 152         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 153         if (ts_params->mbuf_pool == NULL) {
 154                 /* Not already created so create */
 155                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 156                                 "CRYPTO_MBUFPOOL",
 157                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 158                                 rte_socket_id());
 159                 if (ts_params->mbuf_pool == NULL) {
 160                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 161                         return TEST_FAILED;
 162                 }
 163         }
 164
 165         ts_params->mbuf_ol_pool = rte_pktmbuf_offload_pool_create(
 166                         "MBUF_OFFLOAD_POOL",
 167                         NUM_MBUFS, MBUF_CACHE_SIZE,
 168                         DEFAULT_NUM_XFORMS *
 169                         sizeof(struct rte_crypto_xform),
 170                         rte_socket_id());
 171         if (ts_params->mbuf_ol_pool == NULL) {
 172                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 173                 return TEST_FAILED;
 174         }
 175
 176         /* Create 2 AESNI MB devices if required */
 177         if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) {
 178                 nb_devs = rte_cryptodev_count_devtype(
 179                                 RTE_CRYPTODEV_AESNI_MB_PMD);
 180                 if (nb_devs < 2) {
 181                         for (i = nb_devs; i < 2; i++) {
 182                                 ret = rte_eal_vdev_init(
 183                                         CRYPTODEV_NAME_AESNI_MB_PMD, NULL);
 184
 185                                 TEST_ASSERT(ret == 0,
 186                                         "Failed to create instance %u of"
 187                                         " pmd : %s",
 188                                         i, CRYPTODEV_NAME_AESNI_MB_PMD);
 189                         }
 190                 }
 191         }
 192
 193         nb_devs = rte_cryptodev_count();
 194         if (nb_devs < 1) {
 195                 RTE_LOG(ERR, USER1, "No crypto devices found?");
 196                 return TEST_FAILED;
 197         }
 198
 199         /* Create list of valid crypto devs */
 200         for (i = 0; i < nb_devs; i++) {
 201                 rte_cryptodev_info_get(i, &info);
 202                 if (info.dev_type == gbl_cryptodev_type)
 203                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 204         }
 205
 206         if (ts_params->valid_dev_count < 1)
 207                 return TEST_FAILED;
 208
 209         /* Set up all the qps on the first of the valid devices found */
 210         for (i = 0; i < 1; i++) {
 211                 dev_id = ts_params->valid_devs[i];
 212
 213                 rte_cryptodev_info_get(dev_id, &info);
 214
 215                 /*
 216                  * Since we can't free and re-allocate queue memory always set
 217                  * the queues on this device up to max size first so enough
 218                  * memory is allocated for any later re-configures needed by
 219                  * other tests
 220                  */
 221
 222                 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 223                 ts_params->conf.socket_id = SOCKET_ID_ANY;
 224                 ts_params->conf.session_mp.nb_objs = info.max_nb_sessions;
 225
 226                 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 227                                 &ts_params->conf),
 228                                 "Failed to configure cryptodev %u with %u qps",
 229                                 dev_id, ts_params->conf.nb_queue_pairs);
 230
 231                 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 232
 233                 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 234                         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 235                                         dev_id, qp_id, &ts_params->qp_conf,
 236                                         rte_cryptodev_socket_id(dev_id)),
 237                                         "Failed to setup queue pair %u on "
 238                                         "cryptodev %u",
 239                                         qp_id, dev_id);
 240                 }
 241         }
 242
 243         return TEST_SUCCESS;
 244 }
 245
 246 static void
 247 testsuite_teardown(void)
 248 {
 249         struct crypto_testsuite_params *ts_params = &testsuite_params;
 250
 251         if (ts_params->mbuf_pool != NULL) {
 252                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 253                 rte_mempool_count(ts_params->mbuf_pool));
 254         }
 255
 256
 257         if (ts_params->mbuf_ol_pool != NULL) {
 258                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 259                 rte_mempool_count(ts_params->mbuf_ol_pool));
 260         }
 261
 262 }
 263
 264 static int
 265 ut_setup(void)
 266 {
 267         struct crypto_testsuite_params *ts_params = &testsuite_params;
 268         struct crypto_unittest_params *ut_params = &unittest_params;
 269
 270         uint16_t qp_id;
 271
 272         /* Clear unit test parameters before running test */
 273         memset(ut_params, 0, sizeof(*ut_params));
 274
 275         /* Reconfigure device to default parameters */
 276         ts_params->conf.nb_queue_pairs = DEFAULT_NUM_QPS_PER_QAT_DEVICE;
 277         ts_params->conf.socket_id = SOCKET_ID_ANY;
 278         ts_params->conf.session_mp.nb_objs =
 279                         (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_PMD) ?
 280                                         DEFAULT_NUM_OPS_INFLIGHT :
 281                                         DEFAULT_NUM_OPS_INFLIGHT;
 282
 283         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 284                         &ts_params->conf),
 285                         "Failed to configure cryptodev %u",
 286                         ts_params->valid_devs[0]);
 287
 288         /*
 289          * Now reconfigure queues to size we actually want to use in this
 290          * test suite.
 291          */
 292         ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 293
 294         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 295                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 296                         ts_params->valid_devs[0], qp_id,
 297                         &ts_params->qp_conf,
 298                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 299                         "Failed to setup queue pair %u on cryptodev %u",
 300                         qp_id, ts_params->valid_devs[0]);
 301         }
 302
 303
 304         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 305
 306         /* Start the device */
 307         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
 308                         "Failed to start cryptodev %u",
 309                         ts_params->valid_devs[0]);
 310
 311         return TEST_SUCCESS;
 312 }
 313
 314 static void
 315 ut_teardown(void)
 316 {
 317         struct crypto_testsuite_params *ts_params = &testsuite_params;
 318         struct crypto_unittest_params *ut_params = &unittest_params;
 319         struct rte_cryptodev_stats stats;
 320
 321         /* free crypto session structure */
 322         if (ut_params->sess) {
 323                 rte_cryptodev_session_free(ts_params->valid_devs[0],
 324                                 ut_params->sess);
 325                 ut_params->sess = NULL;
 326         }
 327
 328         /* free crypto operation structure */
 329         if (ut_params->ol)
 330                 rte_pktmbuf_offload_free(ut_params->ol);
 331
 332         /*
 333          * free mbuf - both obuf and ibuf are usually the same,
 334          * but rte copes even if we call free twice
 335          */
 336         if (ut_params->obuf) {
 337                 rte_pktmbuf_free(ut_params->obuf);
 338                 ut_params->obuf = 0;
 339         }
 340         if (ut_params->ibuf) {
 341                 rte_pktmbuf_free(ut_params->ibuf);
 342                 ut_params->ibuf = 0;
 343         }
 344
 345         if (ts_params->mbuf_pool != NULL)
 346                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 347                                 rte_mempool_count(ts_params->mbuf_pool));
 348
 349         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
 350
 351         /* Stop the device */
 352         rte_cryptodev_stop(ts_params->valid_devs[0]);
 353 }
 354
 355 static int
 356 test_device_configure_invalid_dev_id(void)
 357 {
 358         struct crypto_testsuite_params *ts_params = &testsuite_params;
 359         uint16_t dev_id, num_devs = 0;
 360
 361         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
 362                         "Need at least %d devices for test", 1);
 363
 364         /* valid dev_id values */
 365         dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
 366
 367         /* Stop the device in case it's started so it can be configured */
 368         rte_cryptodev_stop(ts_params->valid_devs[dev_id]);
 369
 370         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
 371                         "Failed test for rte_cryptodev_configure: "
 372                         "invalid dev_num %u", dev_id);
 373
 374         /* invalid dev_id values */
 375         dev_id = num_devs;
 376
 377         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 378                         "Failed test for rte_cryptodev_configure: "
 379                         "invalid dev_num %u", dev_id);
 380
 381         dev_id = 0xff;
 382
 383         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 384                         "Failed test for rte_cryptodev_configure:"
 385                         "invalid dev_num %u", dev_id);
 386
 387         return TEST_SUCCESS;
 388 }
 389
 390 static int
 391 test_device_configure_invalid_queue_pair_ids(void)
 392 {
 393         struct crypto_testsuite_params *ts_params = &testsuite_params;
 394
 395         /* Stop the device in case it's started so it can be configured */
 396         rte_cryptodev_stop(ts_params->valid_devs[0]);
 397
 398         /* valid - one queue pairs */
 399         ts_params->conf.nb_queue_pairs = 1;
 400
 401         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 402                         &ts_params->conf),
 403                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 404                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 405
 406
 407         /* valid - max value queue pairs */
 408         ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
 409
 410         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 411                         &ts_params->conf),
 412                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 413                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 414
 415
 416         /* invalid - zero queue pairs */
 417         ts_params->conf.nb_queue_pairs = 0;
 418
 419         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 420                         &ts_params->conf),
 421                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 422                         " invalid qps: %u",
 423                         ts_params->valid_devs[0],
 424                         ts_params->conf.nb_queue_pairs);
 425
 426
 427         /* invalid - max value supported by field queue pairs */
 428         ts_params->conf.nb_queue_pairs = UINT16_MAX;
 429
 430         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 431                         &ts_params->conf),
 432                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 433                         " invalid qps: %u",
 434                         ts_params->valid_devs[0],
 435                         ts_params->conf.nb_queue_pairs);
 436
 437
 438         /* invalid - max value + 1 queue pairs */
 439         ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
 440
 441         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 442                         &ts_params->conf),
 443                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 444                         " invalid qps: %u",
 445                         ts_params->valid_devs[0],
 446                         ts_params->conf.nb_queue_pairs);
 447
 448         return TEST_SUCCESS;
 449 }
 450
 451 static int
 452 test_queue_pair_descriptor_setup(void)
 453 {
 454         struct crypto_testsuite_params *ts_params = &testsuite_params;
 455         struct rte_cryptodev_info dev_info;
 456         struct rte_cryptodev_qp_conf qp_conf = {
 457                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
 458         };
 459
 460         uint16_t qp_id;
 461
 462         /* Stop the device in case it's started so it can be configured */
 463         rte_cryptodev_stop(ts_params->valid_devs[0]);
 464
 465
 466         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 467
 468         ts_params->conf.session_mp.nb_objs = dev_info.max_nb_sessions;
 469
 470         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 471                         &ts_params->conf), "Failed to configure cryptodev %u",
 472                         ts_params->valid_devs[0]);
 473
 474
 475         /*
 476          * Test various ring sizes on this device. memzones can't be
 477          * freed so are re-used if ring is released and re-created.
 478          */
 479         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
 480
 481         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 482                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 483                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 484                                 rte_cryptodev_socket_id(
 485                                                 ts_params->valid_devs[0])),
 486                                 "Failed test for "
 487                                 "rte_cryptodev_queue_pair_setup: num_inflights "
 488                                 "%u on qp %u on cryptodev %u",
 489                                 qp_conf.nb_descriptors, qp_id,
 490                                 ts_params->valid_devs[0]);
 491         }
 492
 493         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
 494
 495         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 496                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 497                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 498                                 rte_cryptodev_socket_id(
 499                                                 ts_params->valid_devs[0])),
 500                                 "Failed test for"
 501                                 " rte_cryptodev_queue_pair_setup: num_inflights"
 502                                 " %u on qp %u on cryptodev %u",
 503                                 qp_conf.nb_descriptors, qp_id,
 504                                 ts_params->valid_devs[0]);
 505         }
 506
 507         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
 508
 509         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 510                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 511                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 512                                 rte_cryptodev_socket_id(
 513                                                 ts_params->valid_devs[0])),
 514                                 "Failed test for "
 515                                 "rte_cryptodev_queue_pair_setup: num_inflights"
 516                                 " %u on qp %u on cryptodev %u",
 517                                 qp_conf.nb_descriptors, qp_id,
 518                                 ts_params->valid_devs[0]);
 519         }
 520
 521         /* invalid number of descriptors - max supported + 2 */
 522         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
 523
 524         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 525                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 526                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 527                                 rte_cryptodev_socket_id(
 528                                                 ts_params->valid_devs[0])),
 529                                 "Unexpectedly passed test for "
 530                                 "rte_cryptodev_queue_pair_setup:"
 531                                 "num_inflights %u on qp %u on cryptodev %u",
 532                                 qp_conf.nb_descriptors, qp_id,
 533                                 ts_params->valid_devs[0]);
 534         }
 535
 536         /* invalid number of descriptors - max value of parameter */
 537         qp_conf.nb_descriptors = UINT32_MAX-1;
 538
 539         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 540                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 541                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 542                                 rte_cryptodev_socket_id(
 543                                                 ts_params->valid_devs[0])),
 544                                 "Unexpectedly passed test for "
 545                                 "rte_cryptodev_queue_pair_setup:"
 546                                 "num_inflights %u on qp %u on cryptodev %u",
 547                                 qp_conf.nb_descriptors, qp_id,
 548                                 ts_params->valid_devs[0]);
 549         }
 550
 551         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 552
 553         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 554                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 555                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 556                                 rte_cryptodev_socket_id(
 557                                                 ts_params->valid_devs[0])),
 558                                 "Failed test for"
 559                                 " rte_cryptodev_queue_pair_setup:"
 560                                 "num_inflights %u on qp %u on cryptodev %u",
 561                                 qp_conf.nb_descriptors, qp_id,
 562                                 ts_params->valid_devs[0]);
 563         }
 564
 565         /* invalid number of descriptors - max supported + 1 */
 566         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
 567
 568         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 569                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 570                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 571                                 rte_cryptodev_socket_id(
 572                                                 ts_params->valid_devs[0])),
 573                                 "Unexpectedly passed test for "
 574                                 "rte_cryptodev_queue_pair_setup:"
 575                                 "num_inflights %u on qp %u on cryptodev %u",
 576                                 qp_conf.nb_descriptors, qp_id,
 577                                 ts_params->valid_devs[0]);
 578         }
 579
 580         /* test invalid queue pair id */
 581         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
 582
 583         qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE;         /*invalid */
 584
 585         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 586                         ts_params->valid_devs[0],
 587                         qp_id, &qp_conf,
 588                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 589                         "Failed test for rte_cryptodev_queue_pair_setup:"
 590                         "invalid qp %u on cryptodev %u",
 591                         qp_id, ts_params->valid_devs[0]);
 592
 593         qp_id = 0xffff; /*invalid*/
 594
 595         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 596                         ts_params->valid_devs[0],
 597                         qp_id, &qp_conf,
 598                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 599                         "Failed test for rte_cryptodev_queue_pair_setup:"
 600                         "invalid qp %u on cryptodev %u",
 601                         qp_id, ts_params->valid_devs[0]);
 602
 603         return TEST_SUCCESS;
 604 }
 605
 606 /* ***** Plaintext data for tests ***** */
 607
 608 const char catch_22_quote_1[] =
 609                 "There was only one catch and that was Catch-22, which "
 610                 "specified that a concern for one's safety in the face of "
 611                 "dangers that were real and immediate was the process of a "
 612                 "rational mind. Orr was crazy and could be grounded. All he "
 613                 "had to do was ask; and as soon as he did, he would no longer "
 614                 "be crazy and would have to fly more missions. Orr would be "
 615                 "crazy to fly more missions and sane if he didn't, but if he "
 616                 "was sane he had to fly them. If he flew them he was crazy "
 617                 "and didn't have to; but if he didn't want to he was sane and "
 618                 "had to. Yossarian was moved very deeply by the absolute "
 619                 "simplicity of this clause of Catch-22 and let out a "
 620                 "respectful whistle. \"That's some catch, that Catch-22\", he "
 621                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
 622
 623 const char catch_22_quote[] =
 624                 "What a lousy earth! He wondered how many people were "
 625                 "destitute that same night even in his own prosperous country, "
 626                 "how many homes were shanties, how many husbands were drunk "
 627                 "and wives socked, and how many children were bullied, abused, "
 628                 "or abandoned. How many families hungered for food they could "
 629                 "not afford to buy? How many hearts were broken? How many "
 630                 "suicides would take place that same night, how many people "
 631                 "would go insane? How many cockroaches and landlords would "
 632                 "triumph? How many winners were losers, successes failures, "
 633                 "and rich men poor men? How many wise guys were stupid? How "
 634                 "many happy endings were unhappy endings? How many honest men "
 635                 "were liars, brave men cowards, loyal men traitors, how many "
 636                 "sainted men were corrupt, how many people in positions of "
 637                 "trust had sold their souls to bodyguards, how many had never "
 638                 "had souls? How many straight-and-narrow paths were crooked "
 639                 "paths? How many best families were worst families and how "
 640                 "many good people were bad people? When you added them all up "
 641                 "and then subtracted, you might be left with only the children, "
 642                 "and perhaps with Albert Einstein and an old violinist or "
 643                 "sculptor somewhere.";
 644
 645 #define QUOTE_480_BYTES         (480)
 646 #define QUOTE_512_BYTES         (512)
 647 #define QUOTE_768_BYTES         (768)
 648 #define QUOTE_1024_BYTES        (1024)
 649
 650
 651
 652 /* ***** SHA1 Hash Tests ***** */
 653
 654 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
 655
 656 static uint8_t hmac_sha1_key[] = {
 657         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 658         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 659         0xDE, 0xF4, 0xDE, 0xAD };
 660
 661 /* ***** SHA224 Hash Tests ***** */
 662
 663 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
 664
 665
 666 /* ***** AES-CBC Cipher Tests ***** */
 667
 668 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
 669 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
 670
 671 static uint8_t aes_cbc_key[] = {
 672         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 673         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
 674
 675 static uint8_t aes_cbc_iv[] = {
 676         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 677         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
 678
 679
 680 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
 681
 682 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
 683         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
 684         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
 685         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
 686         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
 687         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
 688         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
 689         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
 690         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
 691         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
 692         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
 693         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
 694         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
 695         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
 696         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
 697         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
 698         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
 699         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
 700         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
 701         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
 702         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
 703         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
 704         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
 705         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 706         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
 707         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
 708         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
 709         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
 710         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
 711         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
 712         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
 713         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
 714         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
 715         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
 716         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
 717         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
 718         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
 719         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
 720         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
 721         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
 722         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
 723         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
 724         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
 725         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
 726         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
 727         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
 728         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
 729         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
 730         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
 731         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
 732         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
 733         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
 734         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
 735         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
 736         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
 737         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
 738         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
 739         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
 740         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
 741         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
 742         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
 743         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
 744         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
 745         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
 746         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
 747 };
 748
 749 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
 750         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
 751         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
 752         0x18, 0x8c, 0x1d, 0x32
 753 };
 754
 755
 756 static int
 757 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
 758 {
 759         struct crypto_testsuite_params *ts_params = &testsuite_params;
 760         struct crypto_unittest_params *ut_params = &unittest_params;
 761
 762         /* Generate test mbuf data and space for digest */
 763         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
 764                         catch_22_quote, QUOTE_512_BYTES, 0);
 765
 766         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
 767                         DIGEST_BYTE_LENGTH_SHA1);
 768         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
 769
 770         /* Setup Cipher Parameters */
 771         ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER;
 772         ut_params->cipher_xform.next = &ut_params->auth_xform;
 773
 774         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
 775         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
 776         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
 777         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
 778
 779         /* Setup HMAC Parameters */
 780         ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH;
 781         ut_params->auth_xform.next = NULL;
 782
 783         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 784         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
 785         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
 786         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
 787         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
 788
 789         /* Create crypto session*/
 790         ut_params->sess = rte_cryptodev_session_create(
 791                         ts_params->valid_devs[0],
 792                         &ut_params->cipher_xform);
 793         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 794
 795         /* Generate Crypto op data structure */
 796         ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool,
 797                                 RTE_PKTMBUF_OL_CRYPTO);
 798         TEST_ASSERT_NOT_NULL(ut_params->ol,
 799                         "Failed to allocate pktmbuf offload");
 800
 801         ut_params->op = &ut_params->ol->op.crypto;
 802
 803         /* Set crypto operation data parameters */
 804         rte_crypto_op_attach_session(ut_params->op, ut_params->sess);
 805
 806         ut_params->op->digest.data = ut_params->digest;
 807         ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset(
 808                         ut_params->ibuf, QUOTE_512_BYTES);
 809         ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA1;
 810
 811         ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
 812                         CIPHER_IV_LENGTH_AES_CBC);
 813         ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
 814         ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC;
 815
 816         rte_memcpy(ut_params->op->iv.data, aes_cbc_iv,
 817                         CIPHER_IV_LENGTH_AES_CBC);
 818
 819         ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC;
 820         ut_params->op->data.to_cipher.length = QUOTE_512_BYTES;
 821         ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC;
 822         ut_params->op->data.to_hash.length = QUOTE_512_BYTES;
 823
 824         rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol);
 825
 826         /* Process crypto operation */
 827         ut_params->obuf = process_crypto_request(ts_params->valid_devs[0],
 828                         ut_params->ibuf);
 829         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
 830
 831         /* Validate obuf */
 832         TEST_ASSERT_BUFFERS_ARE_EQUAL(
 833                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
 834                         CIPHER_IV_LENGTH_AES_CBC,
 835                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
 836                         QUOTE_512_BYTES,
 837                         "ciphertext data not as expected");
 838
 839         TEST_ASSERT_BUFFERS_ARE_EQUAL(
 840                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
 841                         CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES,
 842                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
 843                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
 844                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
 845                                         DIGEST_BYTE_LENGTH_SHA1,
 846                         "Generated digest data not as expected");
 847
 848         return TEST_SUCCESS;
 849 }
 850
 851 static int
 852 test_AES_CBC_HMAC_SHA1_encrypt_digest_sessionless(void)
 853 {
 854         struct crypto_testsuite_params *ts_params = &testsuite_params;
 855         struct crypto_unittest_params *ut_params = &unittest_params;
 856
 857         /* Generate test mbuf data and space for digest */
 858         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
 859                         catch_22_quote, QUOTE_512_BYTES, 0);
 860
 861         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
 862                         DIGEST_BYTE_LENGTH_SHA1);
 863         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
 864
 865         /* Generate Crypto op data structure */
 866         ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool,
 867                                 RTE_PKTMBUF_OL_CRYPTO);
 868         TEST_ASSERT_NOT_NULL(ut_params->ol,
 869                         "Failed to allocate pktmbuf offload");
 870
 871         ut_params->op = &ut_params->ol->op.crypto;
 872
 873         TEST_ASSERT_NOT_NULL(rte_pktmbuf_offload_alloc_crypto_xforms(
 874                         ut_params->ol, 2),
 875                         "failed to allocate space for crypto transforms");
 876
 877         /* Set crypto operation data parameters */
 878         ut_params->op->xform->type = RTE_CRYPTO_XFORM_CIPHER;
 879
 880         /* cipher parameters */
 881         ut_params->op->xform->cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
 882         ut_params->op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
 883         ut_params->op->xform->cipher.key.data = aes_cbc_key;
 884         ut_params->op->xform->cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
 885
 886         /* hash parameters */
 887         ut_params->op->xform->next->type = RTE_CRYPTO_XFORM_AUTH;
 888
 889         ut_params->op->xform->next->auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 890         ut_params->op->xform->next->auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
 891         ut_params->op->xform->next->auth.key.length = HMAC_KEY_LENGTH_SHA1;
 892         ut_params->op->xform->next->auth.key.data = hmac_sha1_key;
 893         ut_params->op->xform->next->auth.digest_length =
 894                         DIGEST_BYTE_LENGTH_SHA1;
 895
 896         ut_params->op->digest.data = ut_params->digest;
 897         ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset(
 898                         ut_params->ibuf, QUOTE_512_BYTES);
 899         ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA1;
 900
 901         ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
 902                         CIPHER_IV_LENGTH_AES_CBC);
 903         ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
 904         ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC;
 905
 906         rte_memcpy(ut_params->op->iv.data, aes_cbc_iv,
 907                         CIPHER_IV_LENGTH_AES_CBC);
 908
 909         ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC;
 910         ut_params->op->data.to_cipher.length = QUOTE_512_BYTES;
 911         ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC;
 912         ut_params->op->data.to_hash.length = QUOTE_512_BYTES;
 913
 914         rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol);
 915
 916         /* Process crypto operation */
 917         ut_params->obuf = process_crypto_request(ts_params->valid_devs[0],
 918                         ut_params->ibuf);
 919         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
 920
 921         /* Validate obuf */
 922         TEST_ASSERT_BUFFERS_ARE_EQUAL(
 923                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
 924                         CIPHER_IV_LENGTH_AES_CBC,
 925                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
 926                         QUOTE_512_BYTES,
 927                         "Ciphertext data not as expected");
 928
 929         TEST_ASSERT_BUFFERS_ARE_EQUAL(
 930                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
 931                         CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES,
 932                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
 933                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
 934                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
 935                                         DIGEST_BYTE_LENGTH_SHA1,
 936                         "Generated digest data not as expected");
 937
 938
 939         return TEST_SUCCESS;
 940 }
 941
 942 static int
 943 test_AES_CBC_HMAC_SHA1_decrypt_digest_verify(void)
 944 {
 945         struct crypto_testsuite_params *ts_params = &testsuite_params;
 946         struct crypto_unittest_params *ut_params = &unittest_params;
 947
 948         /* Generate test mbuf data and digest */
 949         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
 950                         (const char *)
 951                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
 952                         QUOTE_512_BYTES, 0);
 953
 954         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
 955                         DIGEST_BYTE_LENGTH_SHA1);
 956         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
 957
 958         rte_memcpy(ut_params->digest,
 959                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
 960                         DIGEST_BYTE_LENGTH_SHA1);
 961
 962         /* Setup Cipher Parameters */
 963         ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER;
 964         ut_params->cipher_xform.next = NULL;
 965
 966         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
 967         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
 968         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
 969         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
 970
 971         /* Setup HMAC Parameters */
 972         ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH;
 973         ut_params->auth_xform.next = &ut_params->cipher_xform;
 974
 975         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
 976         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
 977         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
 978         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
 979         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
 980
 981         /* Create Crypto session*/
 982         ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0],
 983                         &ut_params->auth_xform);
 984         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 985
 986         /* Generate Crypto op data structure */
 987         ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool,
 988                                 RTE_PKTMBUF_OL_CRYPTO);
 989         TEST_ASSERT_NOT_NULL(ut_params->ol,
 990                         "Failed to allocate pktmbuf offload");
 991
 992         ut_params->op = &ut_params->ol->op.crypto;
 993
 994
 995         /* Set crypto operation data parameters */
 996         rte_crypto_op_attach_session(ut_params->op, ut_params->sess);
 997
 998         ut_params->op->digest.data = ut_params->digest;
 999         ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset(
1000                         ut_params->ibuf, QUOTE_512_BYTES);
1001         ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA1;
1002
1003         ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1004                         CIPHER_IV_LENGTH_AES_CBC);
1005         ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1006         ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC;
1007
1008         rte_memcpy(ut_params->op->iv.data, aes_cbc_iv,
1009                         CIPHER_IV_LENGTH_AES_CBC);
1010
1011         ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC;
1012         ut_params->op->data.to_cipher.length = QUOTE_512_BYTES;
1013
1014         ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC;
1015         ut_params->op->data.to_hash.length = QUOTE_512_BYTES;
1016
1017         rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol);
1018
1019         /* Process crypto operation */
1020         ut_params->obuf = process_crypto_request(ts_params->valid_devs[0],
1021                         ut_params->ibuf);
1022         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
1023
1024         /* Validate obuf */
1025         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1026                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1027                         CIPHER_IV_LENGTH_AES_CBC,
1028                         catch_22_quote,
1029                         QUOTE_512_BYTES,
1030                         "Ciphertext data not as expected");
1031
1032         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1033                         "Digest verification failed");
1034
1035
1036         return TEST_SUCCESS;
1037 }
1038
1039
1040 /* ***** AES-CBC / HMAC-SHA256 Hash Tests ***** */
1041
1042 #define HMAC_KEY_LENGTH_SHA256  (DIGEST_BYTE_LENGTH_SHA256)
1043
1044 static uint8_t hmac_sha256_key[] = {
1045         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1046         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1047         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1048         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 };
1049
1050 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest[] = {
1051         0xc8, 0x57, 0x57, 0x31, 0x03, 0xe0, 0x03, 0x55,
1052         0x07, 0xc8, 0x9e, 0x7f, 0x48, 0x9a, 0x61, 0x9a,
1053         0x68, 0xee, 0x03, 0x0e, 0x71, 0x75, 0xc7, 0xf4,
1054         0x2e, 0x45, 0x26, 0x32, 0x7c, 0x12, 0x15, 0x15 };
1055
1056 static int
1057 test_AES_CBC_HMAC_SHA256_encrypt_digest(void)
1058 {
1059         struct crypto_testsuite_params *ts_params = &testsuite_params;
1060         struct crypto_unittest_params *ut_params = &unittest_params;
1061
1062         /* Generate test mbuf data and space for digest */
1063         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1064                         catch_22_quote, QUOTE_512_BYTES, 0);
1065
1066         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1067                         DIGEST_BYTE_LENGTH_SHA256);
1068         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1069
1070         /* Setup Cipher Parameters */
1071         ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER;
1072         ut_params->cipher_xform.next = &ut_params->auth_xform;
1073
1074         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1075         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1076         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1077         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1078
1079         /* Setup HMAC Parameters */
1080         ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH;
1081         ut_params->auth_xform.next = NULL;
1082
1083         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1084         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1085         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1086         ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1087         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1088
1089         /* Create Crypto session*/
1090         ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0],
1091                         &ut_params->cipher_xform);
1092         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1093
1094         /* Generate Crypto op data structure */
1095         ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool,
1096                                 RTE_PKTMBUF_OL_CRYPTO);
1097         TEST_ASSERT_NOT_NULL(ut_params->ol,
1098                         "Failed to allocate pktmbuf offload");
1099
1100         ut_params->op = &ut_params->ol->op.crypto;
1101
1102
1103         /* Set crypto operation data parameters */
1104         rte_crypto_op_attach_session(ut_params->op, ut_params->sess);
1105
1106         ut_params->op->digest.data = ut_params->digest;
1107         ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset(
1108                         ut_params->ibuf, QUOTE_512_BYTES);
1109         ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA256;
1110
1111         ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1112                         CIPHER_IV_LENGTH_AES_CBC);
1113         ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1114         ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC;
1115
1116         rte_memcpy(ut_params->op->iv.data, aes_cbc_iv,
1117                         CIPHER_IV_LENGTH_AES_CBC);
1118
1119         ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC;
1120         ut_params->op->data.to_cipher.length = QUOTE_512_BYTES;
1121         ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC;
1122         ut_params->op->data.to_hash.length = QUOTE_512_BYTES;
1123
1124         rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol);
1125
1126         /* Process crypto operation */
1127         ut_params->obuf = process_crypto_request(ts_params->valid_devs[0],
1128                         ut_params->ibuf);
1129         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
1130
1131         /* Validate obuf */
1132         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1133                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1134                         CIPHER_IV_LENGTH_AES_CBC,
1135                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1136                         QUOTE_512_BYTES,
1137                         "Ciphertext data not as expected");
1138
1139         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1140                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1141                         CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES,
1142                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest,
1143                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1144                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA256 :
1145                                         DIGEST_BYTE_LENGTH_SHA256,
1146                         "Generated digest data not as expected");
1147
1148
1149         return TEST_SUCCESS;
1150 }
1151
1152 static int
1153 test_AES_CBC_HMAC_SHA256_decrypt_digest_verify(void)
1154 {
1155         struct crypto_testsuite_params *ts_params = &testsuite_params;
1156         struct crypto_unittest_params *ut_params = &unittest_params;
1157
1158         /* Generate test mbuf data and digest */
1159         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1160                         (const char *)
1161                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1162                         QUOTE_512_BYTES, 0);
1163
1164         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1165                         DIGEST_BYTE_LENGTH_SHA256);
1166         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1167
1168         rte_memcpy(ut_params->digest,
1169                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest,
1170                         DIGEST_BYTE_LENGTH_SHA256);
1171
1172         /* Setup Cipher Parameters */
1173         ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER;
1174         ut_params->cipher_xform.next = NULL;
1175
1176         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1177         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1178         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1179         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1180
1181         /* Setup HMAC Parameters */
1182         ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH;
1183         ut_params->auth_xform.next = &ut_params->cipher_xform;
1184
1185         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1186         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1187         ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1188         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1189         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1190
1191         /* Create Crypto session*/
1192         ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0],
1193                         &ut_params->auth_xform);
1194         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1195
1196         /* Generate Crypto op data structure */
1197         ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool,
1198                                 RTE_PKTMBUF_OL_CRYPTO);
1199         TEST_ASSERT_NOT_NULL(ut_params->ol,
1200                         "Failed to allocate pktmbuf offload");
1201
1202         ut_params->op = &ut_params->ol->op.crypto;
1203
1204
1205         /* Set crypto operation data parameters */
1206         rte_crypto_op_attach_session(ut_params->op, ut_params->sess);
1207
1208         ut_params->op->digest.data = ut_params->digest;
1209         ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset(
1210                         ut_params->ibuf, QUOTE_512_BYTES);
1211         ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA256;
1212
1213         ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(
1214                         ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1215         ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1216         ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC;
1217
1218         rte_memcpy(ut_params->op->iv.data, aes_cbc_iv,
1219                         CIPHER_IV_LENGTH_AES_CBC);
1220
1221         ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC;
1222         ut_params->op->data.to_cipher.length = QUOTE_512_BYTES;
1223
1224         ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC;
1225         ut_params->op->data.to_hash.length = QUOTE_512_BYTES;
1226
1227         rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol);
1228
1229         /* Process crypto operation */
1230         ut_params->obuf = process_crypto_request(ts_params->valid_devs[0],
1231                         ut_params->ibuf);
1232         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
1233
1234         /* Validate obuf */
1235         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1236                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1237                         CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1238                         QUOTE_512_BYTES,
1239                         "Plaintext data not as expected");
1240
1241         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1242                         "Digest verification failed");
1243
1244         return TEST_SUCCESS;
1245 }
1246
1247 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1248
1249 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
1250
1251 static uint8_t hmac_sha512_key[] = {
1252         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1253         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1254         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1255         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1256         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1257         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1258         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1259         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1260
1261 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1262         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1263         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1264         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1265         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1266         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1267         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1268         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1269         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1270
1271 static int
1272 test_AES_CBC_HMAC_SHA512_encrypt_digest(void)
1273 {
1274         struct crypto_testsuite_params *ts_params = &testsuite_params;
1275         struct crypto_unittest_params *ut_params = &unittest_params;
1276
1277         /* Generate test mbuf data and space for digest */
1278         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1279                         catch_22_quote, QUOTE_512_BYTES, 0);
1280
1281         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1282                         DIGEST_BYTE_LENGTH_SHA512);
1283         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1284
1285         /* Setup Cipher Parameters */
1286         ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER;
1287         ut_params->cipher_xform.next = &ut_params->auth_xform;
1288
1289         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1290         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1291         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1292         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1293
1294         /* Setup HMAC Parameters */
1295         ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH;
1296         ut_params->auth_xform.next = NULL;
1297
1298         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1299         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1300         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1301         ut_params->auth_xform.auth.key.data = hmac_sha512_key;
1302         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1303
1304         /* Create Crypto session*/
1305         ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0],
1306                         &ut_params->cipher_xform);
1307
1308         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1309
1310
1311         /* Generate Crypto op data structure */
1312         ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool,
1313                                 RTE_PKTMBUF_OL_CRYPTO);
1314         TEST_ASSERT_NOT_NULL(ut_params->ol,
1315                         "Failed to allocate pktmbuf offload");
1316
1317         ut_params->op = &ut_params->ol->op.crypto;
1318
1319
1320         /* Set crypto operation data parameters */
1321         rte_crypto_op_attach_session(ut_params->op, ut_params->sess);
1322
1323         ut_params->op->digest.data = ut_params->digest;
1324         ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset(
1325                         ut_params->ibuf, QUOTE_512_BYTES);
1326         ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA512;
1327
1328         ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1329                         CIPHER_IV_LENGTH_AES_CBC);
1330         ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1331         ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC;
1332
1333         rte_memcpy(ut_params->op->iv.data, aes_cbc_iv,
1334                         CIPHER_IV_LENGTH_AES_CBC);
1335
1336         ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC;
1337         ut_params->op->data.to_cipher.length = QUOTE_512_BYTES;
1338         ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC;
1339         ut_params->op->data.to_hash.length = QUOTE_512_BYTES;
1340
1341         rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol);
1342
1343         /* Process crypto operation */
1344         ut_params->obuf = process_crypto_request(ts_params->valid_devs[0],
1345                         ut_params->ibuf);
1346         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
1347
1348         /* Validate obuf */
1349         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1350                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1351                         CIPHER_IV_LENGTH_AES_CBC,
1352                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1353                         QUOTE_512_BYTES,
1354                         "Ciphertext data not as expected");
1355
1356         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1357                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1358                         CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES,
1359                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
1360                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1361                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA512 :
1362                                         DIGEST_BYTE_LENGTH_SHA512,
1363                         "Generated digest data not as expected");
1364
1365         return TEST_SUCCESS;
1366 }
1367
1368
1369 static int
1370 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1371                 struct crypto_unittest_params *ut_params);
1372
1373 static int
1374 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_session *sess,
1375                 struct crypto_unittest_params *ut_params,
1376                 struct crypto_testsuite_params *ts_params);
1377
1378 static int
1379 test_AES_CBC_HMAC_SHA512_decrypt_digest_verify(void)
1380 {
1381         struct crypto_unittest_params *ut_params = &unittest_params;
1382         struct crypto_testsuite_params *ts_params = &testsuite_params;
1383
1384         TEST_ASSERT(test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1385                         ut_params) == TEST_SUCCESS,
1386                         "Failed to create session params");
1387
1388         /* Create Crypto session*/
1389         ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0],
1390                         &ut_params->auth_xform);
1391         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1392
1393         return test_AES_CBC_HMAC_SHA512_decrypt_perform(ut_params->sess,
1394                         ut_params, ts_params);
1395 }
1396
1397 static int
1398 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1399                 struct crypto_unittest_params *ut_params)
1400 {
1401
1402         /* Setup Cipher Parameters */
1403         ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER;
1404         ut_params->cipher_xform.next = NULL;
1405
1406         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1407         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1408         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1409         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1410
1411         /* Setup HMAC Parameters */
1412         ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH;
1413         ut_params->auth_xform.next = &ut_params->cipher_xform;
1414
1415         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1416         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1417         ut_params->auth_xform.auth.key.data = hmac_sha512_key;
1418         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1419         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1420
1421         return TEST_SUCCESS;
1422 }
1423
1424
1425 static int
1426 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_session *sess,
1427                 struct crypto_unittest_params *ut_params,
1428                 struct crypto_testsuite_params *ts_params)
1429 {
1430         /* Generate test mbuf data and digest */
1431         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1432                         (const char *)
1433                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1434                         QUOTE_512_BYTES, 0);
1435
1436         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1437                         DIGEST_BYTE_LENGTH_SHA512);
1438         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1439
1440         rte_memcpy(ut_params->digest,
1441                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
1442                         DIGEST_BYTE_LENGTH_SHA512);
1443
1444         /* Generate Crypto op data structure */
1445         ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool,
1446                                 RTE_PKTMBUF_OL_CRYPTO);
1447         TEST_ASSERT_NOT_NULL(ut_params->ol,
1448                         "Failed to allocate pktmbuf offload");
1449
1450         ut_params->op = &ut_params->ol->op.crypto;
1451
1452
1453         /* Set crypto operation data parameters */
1454         rte_crypto_op_attach_session(ut_params->op, sess);
1455
1456         ut_params->op->digest.data = ut_params->digest;
1457         ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset(
1458                         ut_params->ibuf, QUOTE_512_BYTES);
1459         ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA512;
1460
1461         ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(
1462                         ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1463         ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys_offset(
1464                         ut_params->ibuf, 0);
1465         ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC;
1466
1467         rte_memcpy(ut_params->op->iv.data, aes_cbc_iv,
1468                         CIPHER_IV_LENGTH_AES_CBC);
1469
1470         ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC;
1471         ut_params->op->data.to_cipher.length = QUOTE_512_BYTES;
1472
1473         ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC;
1474         ut_params->op->data.to_hash.length = QUOTE_512_BYTES;
1475
1476         rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol);
1477
1478         /* Process crypto operation */
1479         ut_params->obuf = process_crypto_request(ts_params->valid_devs[0],
1480                         ut_params->ibuf);
1481         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
1482
1483         /* Validate obuf */
1484         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1485                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1486                         CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1487                         QUOTE_512_BYTES,
1488                         "Plaintext data not as expected");
1489
1490         /* Validate obuf */
1491         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1492                         "Digest verification failed");
1493
1494         return TEST_SUCCESS;
1495 }
1496
1497 /* ***** AES-CBC / HMAC-AES_XCBC Chain Tests ***** */
1498
1499 static uint8_t aes_cbc_hmac_aes_xcbc_key[] = {
1500         0x87, 0x61, 0x54, 0x53, 0xC4, 0x6D, 0xDD, 0x51,
1501         0xE1, 0x9F, 0x86, 0x64, 0x39, 0x0A, 0xE6, 0x59
1502         };
1503
1504 static const uint8_t  catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest[] = {
1505         0xE0, 0xAC, 0x9A, 0xC4, 0x22, 0x64, 0x35, 0x89,
1506         0x77, 0x1D, 0x8B, 0x75
1507         };
1508
1509 static int
1510 test_AES_CBC_HMAC_AES_XCBC_encrypt_digest(void)
1511 {
1512         struct crypto_testsuite_params *ts_params = &testsuite_params;
1513         struct crypto_unittest_params *ut_params = &unittest_params;
1514
1515         /* Generate test mbuf data and space for digest */
1516         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1517                         catch_22_quote, QUOTE_512_BYTES, 0);
1518
1519         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1520                         DIGEST_BYTE_LENGTH_AES_XCBC);
1521         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1522
1523         /* Setup Cipher Parameters */
1524         ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER;
1525         ut_params->cipher_xform.next = &ut_params->auth_xform;
1526
1527         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1528         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1529         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1530         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1531
1532         /* Setup HMAC Parameters */
1533         ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH;
1534         ut_params->auth_xform.next = NULL;
1535
1536         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1537         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC;
1538         ut_params->auth_xform.auth.key.length = AES_XCBC_MAC_KEY_SZ;
1539         ut_params->auth_xform.auth.key.data = aes_cbc_hmac_aes_xcbc_key;
1540         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_AES_XCBC;
1541
1542         /* Create Crypto session*/
1543         ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0],
1544                         &ut_params->cipher_xform);
1545         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1546
1547         /* Generate Crypto op data structure */
1548         ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool,
1549                                 RTE_PKTMBUF_OL_CRYPTO);
1550         TEST_ASSERT_NOT_NULL(ut_params->ol,
1551                         "Failed to allocate pktmbuf offload");
1552
1553         ut_params->op = &ut_params->ol->op.crypto;
1554
1555
1556         /* Set crypto operation data parameters */
1557         rte_crypto_op_attach_session(ut_params->op, ut_params->sess);
1558
1559         ut_params->op->iv.data = (uint8_t *)
1560                 rte_pktmbuf_prepend(ut_params->ibuf,
1561                                 CIPHER_IV_LENGTH_AES_CBC);
1562         ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1563         ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC;
1564
1565         rte_memcpy(ut_params->op->iv.data, aes_cbc_iv,
1566                         CIPHER_IV_LENGTH_AES_CBC);
1567
1568         ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC;
1569         ut_params->op->data.to_cipher.length = QUOTE_512_BYTES;
1570         ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC;
1571         ut_params->op->data.to_hash.length = QUOTE_512_BYTES;
1572
1573         rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol);
1574
1575         /* Process crypto operation */
1576         ut_params->obuf = process_crypto_request(ts_params->valid_devs[0],
1577                         ut_params->ibuf);
1578         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
1579
1580         /* Validate obuf */
1581         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1582                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1583                         CIPHER_IV_LENGTH_AES_CBC,
1584                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1585                         QUOTE_512_BYTES,
1586                         "Ciphertext data not as expected");
1587         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1588                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1589                         CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES,
1590                         catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest,
1591                         DIGEST_BYTE_LENGTH_AES_XCBC,
1592                         "Generated digest data not as expected");
1593
1594         return TEST_SUCCESS;
1595 }
1596
1597 static int
1598 test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify(void)
1599 {
1600         struct crypto_testsuite_params *ts_params = &testsuite_params;
1601         struct crypto_unittest_params *ut_params = &unittest_params;
1602
1603         /* Generate test mbuf data and space for digest */
1604         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1605                 (const char *)catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1606                 QUOTE_512_BYTES, 0);
1607
1608         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1609                         DIGEST_BYTE_LENGTH_AES_XCBC);
1610         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1611
1612         rte_memcpy(ut_params->digest,
1613                         catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest,
1614                         DIGEST_BYTE_LENGTH_AES_XCBC);
1615
1616         /* Setup Cipher Parameters */
1617         ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER;
1618         ut_params->cipher_xform.next = NULL;
1619
1620         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1621         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1622         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1623         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1624
1625         /* Setup HMAC Parameters */
1626         ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH;
1627         ut_params->auth_xform.next = &ut_params->cipher_xform;
1628
1629         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1630         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC;
1631         ut_params->auth_xform.auth.key.length = AES_XCBC_MAC_KEY_SZ;
1632         ut_params->auth_xform.auth.key.data = aes_cbc_hmac_aes_xcbc_key;
1633         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_AES_XCBC;
1634
1635         /* Create Crypto session*/
1636         ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0],
1637                         &ut_params->auth_xform);
1638         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1639
1640         /* Generate Crypto op data structure */
1641         ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool,
1642                                 RTE_PKTMBUF_OL_CRYPTO);
1643         TEST_ASSERT_NOT_NULL(ut_params->ol,
1644                         "Failed to allocate pktmbuf offload");
1645
1646         ut_params->op = &ut_params->ol->op.crypto;
1647
1648
1649         /* Set crypto operation data parameters */
1650         rte_crypto_op_attach_session(ut_params->op, ut_params->sess);
1651
1652         ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1653                         CIPHER_IV_LENGTH_AES_CBC);
1654         ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1655         ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC;
1656
1657         rte_memcpy(ut_params->op->iv.data, aes_cbc_iv,
1658                         CIPHER_IV_LENGTH_AES_CBC);
1659
1660         ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC;
1661         ut_params->op->data.to_cipher.length = QUOTE_512_BYTES;
1662         ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC;
1663         ut_params->op->data.to_hash.length = QUOTE_512_BYTES;
1664         rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol);
1665
1666         /* Process crypto operation */
1667         ut_params->obuf = process_crypto_request(ts_params->valid_devs[0],
1668                         ut_params->ibuf);
1669         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
1670
1671         /* Validate obuf */
1672         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1673                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1674                         CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1675                         QUOTE_512_BYTES,
1676                         "Ciphertext data not as expected");
1677
1678         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1679                         "Digest verification failed");
1680
1681         return TEST_SUCCESS;
1682 }
1683
1684
1685 /* ***** AES-GCM Tests ***** */
1686
1687 static int
1688 test_stats(void)
1689 {
1690         struct crypto_testsuite_params *ts_params = &testsuite_params;
1691         struct rte_cryptodev_stats stats;
1692         struct rte_cryptodev *dev;
1693         cryptodev_stats_get_t temp_pfn;
1694
1695         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1696         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
1697                         &stats) == -ENODEV),
1698                 "rte_cryptodev_stats_get invalid dev failed");
1699         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
1700                 "rte_cryptodev_stats_get invalid Param failed");
1701         dev = &rte_cryptodevs[ts_params->valid_devs[0]];
1702         temp_pfn = dev->dev_ops->stats_get;
1703         dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
1704         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
1705                         == -ENOTSUP),
1706                 "rte_cryptodev_stats_get invalid Param failed");
1707         dev->dev_ops->stats_get = temp_pfn;
1708
1709         /* Test expected values */
1710         ut_setup();
1711         test_AES_CBC_HMAC_SHA1_encrypt_digest();
1712         ut_teardown();
1713         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
1714                         &stats),
1715                 "rte_cryptodev_stats_get failed");
1716         TEST_ASSERT((stats.enqueued_count == 1),
1717                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1718         TEST_ASSERT((stats.dequeued_count == 1),
1719                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1720         TEST_ASSERT((stats.enqueue_err_count == 0),
1721                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1722         TEST_ASSERT((stats.dequeue_err_count == 0),
1723                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1724
1725         /* invalid device but should ignore and not reset device stats*/
1726         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
1727         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
1728                         &stats),
1729                 "rte_cryptodev_stats_get failed");
1730         TEST_ASSERT((stats.enqueued_count == 1),
1731                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1732
1733         /* check that a valid reset clears stats */
1734         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1735         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
1736                         &stats),
1737                                           "rte_cryptodev_stats_get failed");
1738         TEST_ASSERT((stats.enqueued_count == 0),
1739                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1740         TEST_ASSERT((stats.dequeued_count == 0),
1741                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
1742
1743         return TEST_SUCCESS;
1744 }
1745
1746
1747 static int
1748 test_multi_session(void)
1749 {
1750         struct crypto_testsuite_params *ts_params = &testsuite_params;
1751         struct crypto_unittest_params *ut_params = &unittest_params;
1752
1753         struct rte_cryptodev_info dev_info;
1754         struct rte_cryptodev_session **sessions;
1755
1756         uint16_t i;
1757
1758         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params);
1759
1760
1761         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
1762
1763         sessions = rte_malloc(NULL, (sizeof(struct rte_cryptodev_session *) *
1764                         dev_info.max_nb_sessions) + 1, 0);
1765
1766         /* Create multiple crypto sessions*/
1767         for (i = 0; i < dev_info.max_nb_sessions; i++) {
1768                 sessions[i] = rte_cryptodev_session_create(
1769                                 ts_params->valid_devs[0],
1770                         &ut_params->auth_xform);
1771                 TEST_ASSERT_NOT_NULL(sessions[i],
1772                                 "Session creation failed at session number %u",
1773                                 i);
1774
1775                 /* Attempt to send a request on each session */
1776                 TEST_ASSERT_SUCCESS(test_AES_CBC_HMAC_SHA512_decrypt_perform(
1777                                 sessions[i], ut_params, ts_params),
1778                                 "Failed to perform decrypt on request "
1779                                 "number %u.", i);
1780         }
1781
1782         /* Next session create should fail */
1783         sessions[i] = rte_cryptodev_session_create(ts_params->valid_devs[0],
1784                         &ut_params->auth_xform);
1785         TEST_ASSERT_NULL(sessions[i],
1786                         "Session creation succeeded unexpectedly!");
1787
1788         for (i = 0; i < dev_info.max_nb_sessions; i++)
1789                 rte_cryptodev_session_free(ts_params->valid_devs[0],
1790                                 sessions[i]);
1791
1792         rte_free(sessions);
1793
1794         return TEST_SUCCESS;
1795 }
1796
1797 static int
1798 test_not_in_place_crypto(void)
1799 {
1800         struct crypto_testsuite_params *ts_params = &testsuite_params;
1801         struct crypto_unittest_params *ut_params = &unittest_params;
1802         struct rte_mbuf *dst_m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
1803
1804         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params);
1805
1806         /* Create multiple crypto sessions*/
1807
1808         ut_params->sess = rte_cryptodev_session_create(
1809                         ts_params->valid_devs[0], &ut_params->auth_xform);
1810
1811         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1812
1813
1814         /* Generate test mbuf data and digest */
1815         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1816                         (const char *)
1817                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1818                         QUOTE_512_BYTES, 0);
1819
1820         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1821                         DIGEST_BYTE_LENGTH_SHA512);
1822         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1823
1824         rte_memcpy(ut_params->digest,
1825                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
1826                         DIGEST_BYTE_LENGTH_SHA512);
1827
1828         /* Generate Crypto op data structure */
1829         ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool,
1830                                 RTE_PKTMBUF_OL_CRYPTO);
1831         TEST_ASSERT_NOT_NULL(ut_params->ol,
1832                         "Failed to allocate pktmbuf offload");
1833
1834         ut_params->op = &ut_params->ol->op.crypto;
1835
1836
1837         /* Set crypto operation data parameters */
1838         rte_crypto_op_attach_session(ut_params->op, ut_params->sess);
1839
1840         ut_params->op->digest.data = ut_params->digest;
1841         ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset(
1842                         ut_params->ibuf, QUOTE_512_BYTES);
1843         ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA512;
1844
1845         ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(
1846                         ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1847         ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys_offset(
1848                         ut_params->ibuf, 0);
1849         ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC;
1850
1851         rte_memcpy(ut_params->op->iv.data, aes_cbc_iv,
1852                         CIPHER_IV_LENGTH_AES_CBC);
1853
1854         ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC;
1855         ut_params->op->data.to_cipher.length = QUOTE_512_BYTES;
1856
1857         ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC;
1858         ut_params->op->data.to_hash.length = QUOTE_512_BYTES;
1859
1860         ut_params->op->dst.m = dst_m;
1861         ut_params->op->dst.offset = 0;
1862
1863         rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol);
1864
1865         /* Process crypto operation */
1866         ut_params->obuf = process_crypto_request(ts_params->valid_devs[0],
1867                         ut_params->ibuf);
1868         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
1869
1870         /* Validate obuf */
1871         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1872                         rte_pktmbuf_mtod(ut_params->op->dst.m, char *),
1873                         catch_22_quote,
1874                         QUOTE_512_BYTES,
1875                         "Plaintext data not as expected");
1876
1877         /* Validate obuf */
1878
1879         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1880                         "Digest verification failed");
1881
1882         return TEST_SUCCESS;
1883 }
1884
1885
1886 static struct unit_test_suite cryptodev_qat_testsuite  = {
1887         .suite_name = "Crypto QAT Unit Test Suite",
1888         .setup = testsuite_setup,
1889         .teardown = testsuite_teardown,
1890         .unit_test_cases = {
1891                 TEST_CASE_ST(ut_setup, ut_teardown,
1892                                 test_device_configure_invalid_dev_id),
1893                 TEST_CASE_ST(ut_setup, ut_teardown,
1894                                 test_device_configure_invalid_queue_pair_ids),
1895                 TEST_CASE_ST(ut_setup, ut_teardown,
1896                                 test_queue_pair_descriptor_setup),
1897                 TEST_CASE_ST(ut_setup, ut_teardown,
1898                                 test_multi_session),
1899
1900                 TEST_CASE_ST(ut_setup, ut_teardown,
1901                                 test_AES_CBC_HMAC_SHA1_encrypt_digest),
1902                 TEST_CASE_ST(ut_setup, ut_teardown,
1903                                 test_AES_CBC_HMAC_SHA1_decrypt_digest_verify),
1904
1905                 TEST_CASE_ST(ut_setup, ut_teardown,
1906                                 test_AES_CBC_HMAC_SHA256_encrypt_digest),
1907                 TEST_CASE_ST(ut_setup, ut_teardown,
1908                                 test_AES_CBC_HMAC_SHA256_decrypt_digest_verify),
1909
1910                 TEST_CASE_ST(ut_setup, ut_teardown,
1911                                 test_AES_CBC_HMAC_SHA512_encrypt_digest),
1912                 TEST_CASE_ST(ut_setup, ut_teardown,
1913                                 test_AES_CBC_HMAC_SHA512_decrypt_digest_verify),
1914
1915                 TEST_CASE_ST(ut_setup, ut_teardown,
1916                                 test_AES_CBC_HMAC_AES_XCBC_encrypt_digest),
1917                 TEST_CASE_ST(ut_setup, ut_teardown,
1918                                 test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify),
1919
1920                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
1921
1922                 TEST_CASES_END() /**< NULL terminate unit test array */
1923         }
1924 };
1925
1926 static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
1927         .suite_name = "Crypto Device AESNI MB Unit Test Suite",
1928         .setup = testsuite_setup,
1929         .teardown = testsuite_teardown,
1930         .unit_test_cases = {
1931                 TEST_CASE_ST(ut_setup, ut_teardown,
1932                         test_AES_CBC_HMAC_SHA1_encrypt_digest),
1933                 TEST_CASE_ST(ut_setup, ut_teardown,
1934                         test_AES_CBC_HMAC_SHA1_decrypt_digest_verify),
1935
1936                 TEST_CASE_ST(ut_setup, ut_teardown,
1937                         test_AES_CBC_HMAC_SHA256_encrypt_digest),
1938                 TEST_CASE_ST(ut_setup, ut_teardown,
1939                         test_AES_CBC_HMAC_SHA256_decrypt_digest_verify),
1940
1941                 TEST_CASE_ST(ut_setup, ut_teardown,
1942                         test_AES_CBC_HMAC_SHA512_encrypt_digest),
1943                 TEST_CASE_ST(ut_setup, ut_teardown,
1944                         test_AES_CBC_HMAC_SHA512_decrypt_digest_verify),
1945
1946                 TEST_CASE_ST(ut_setup, ut_teardown,
1947                         test_AES_CBC_HMAC_AES_XCBC_encrypt_digest),
1948                 TEST_CASE_ST(ut_setup, ut_teardown,
1949                         test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify),
1950
1951                 TEST_CASE_ST(ut_setup, ut_teardown,
1952                         test_AES_CBC_HMAC_SHA1_encrypt_digest_sessionless),
1953
1954                 TEST_CASE_ST(ut_setup, ut_teardown,
1955                         test_not_in_place_crypto),
1956
1957                 TEST_CASES_END() /**< NULL terminate unit test array */
1958         }
1959 };
1960
1961 static int
1962 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
1963 {
1964         gbl_cryptodev_type = RTE_CRYPTODEV_QAT_PMD;
1965         return unit_test_suite_runner(&cryptodev_qat_testsuite);
1966 }
1967 static struct test_command cryptodev_qat_cmd = {
1968         .command = "cryptodev_qat_autotest",
1969         .callback = test_cryptodev_qat,
1970 };
1971
1972 static int
1973 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
1974 {
1975         gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
1976
1977         return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
1978 }
1979
1980 static struct test_command cryptodev_aesni_mb_cmd = {
1981         .command = "cryptodev_aesni_mb_autotest",
1982         .callback = test_cryptodev_aesni_mb,
1983 };
1984
1985 REGISTER_TEST_COMMAND(cryptodev_qat_cmd);
1986 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_cmd);