app/test/test_cryptodev.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2015-2016 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
  39 #include <rte_crypto.h>
  40 #include <rte_cryptodev.h>
  41 #include <rte_cryptodev_pmd.h>
  42
  43 #include "test.h"
  44 #include "test_cryptodev.h"
  45 #include "test_cryptodev_snow3g_test_vectors.h"
  46 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  47 #include "test_cryptodev_gcm_test_vectors.h"
  48
  49 static enum rte_cryptodev_type gbl_cryptodev_type;
  50
  51 struct crypto_testsuite_params {
  52         struct rte_mempool *mbuf_pool;
  53         struct rte_mempool *op_mpool;
  54         struct rte_cryptodev_config conf;
  55         struct rte_cryptodev_qp_conf qp_conf;
  56
  57         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  58         uint8_t valid_dev_count;
  59 };
  60
  61 struct crypto_unittest_params {
  62         struct rte_crypto_sym_xform cipher_xform;
  63         struct rte_crypto_sym_xform auth_xform;
  64
  65         struct rte_cryptodev_sym_session *sess;
  66
  67         struct rte_crypto_op *op;
  68
  69         struct rte_mbuf *obuf, *ibuf;
  70
  71         uint8_t *digest;
  72 };
  73
  74 #define ALIGN_POW2_ROUNDUP(num, align) \
  75         (((num) + (align) - 1) & ~((align) - 1))
  76
  77 /*
  78  * Forward declarations.
  79  */
  80 static int
  81 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
  82                 struct crypto_unittest_params *ut_params);
  83
  84 static int
  85 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
  86                 struct crypto_unittest_params *ut_params,
  87                 struct crypto_testsuite_params *ts_param);
  88
  89 static struct rte_mbuf *
  90 setup_test_string(struct rte_mempool *mpool,
  91                 const char *string, size_t len, uint8_t blocksize)
  92 {
  93         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
  94         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
  95
  96         memset(m->buf_addr, 0, m->buf_len);
  97         if (m) {
  98                 char *dst = rte_pktmbuf_append(m, t_len);
  99
 100                 if (!dst) {
 101                         rte_pktmbuf_free(m);
 102                         return NULL;
 103                 }
 104                 if (string != NULL)
 105                         rte_memcpy(dst, string, t_len);
 106                 else
 107                         memset(dst, 0, t_len);
 108         }
 109
 110         return m;
 111 }
 112 static int
 113 setup_oop_test_mbufs(struct rte_mbuf **ibuf, struct rte_mbuf **obuf,
 114                 struct rte_mempool *mpool,      const char *string, size_t len,
 115                 uint8_t blocksize) {
 116         *ibuf = setup_test_string(mpool, string, len, blocksize);
 117         if (*ibuf == NULL)
 118                 return -(EFAULT);
 119         *obuf = setup_test_string(mpool, NULL, len, blocksize);
 120         if (*obuf == NULL)
 121                 return -(EFAULT);
 122
 123         return 0;
 124 }
 125
 126 #if HEX_DUMP
 127 static void
 128 hexdump_mbuf_data(FILE *f, const char *title, struct rte_mbuf *m)
 129 {
 130         rte_hexdump(f, title, rte_pktmbuf_mtod(m, const void *), m->data_len);
 131 }
 132 #endif
 133
 134 static struct rte_crypto_op *
 135 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 136 {
 137 #if HEX_DUMP
 138         hexdump_mbuf_data(stdout, "Enqueued Packet", ibuf);
 139 #endif
 140
 141         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 142                 printf("Error sending packet for encryption");
 143                 return NULL;
 144         }
 145
 146         op = NULL;
 147
 148         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 149                 rte_pause();
 150
 151 #if HEX_DUMP
 152         if (obuf)
 153                 hexdump_mbuf_data(stdout, "Dequeued Packet", obuf);
 154 #endif
 155
 156         return op;
 157 }
 158
 159 static struct crypto_testsuite_params testsuite_params = { NULL };
 160 static struct crypto_unittest_params unittest_params;
 161
 162 static int
 163 testsuite_setup(void)
 164 {
 165         struct crypto_testsuite_params *ts_params = &testsuite_params;
 166         struct rte_cryptodev_info info;
 167         unsigned i, nb_devs, dev_id;
 168         int ret;
 169         uint16_t qp_id;
 170
 171         memset(ts_params, 0, sizeof(*ts_params));
 172
 173         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 174         if (ts_params->mbuf_pool == NULL) {
 175                 /* Not already created so create */
 176                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 177                                 "CRYPTO_MBUFPOOL",
 178                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 179                                 rte_socket_id());
 180                 if (ts_params->mbuf_pool == NULL) {
 181                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 182                         return TEST_FAILED;
 183                 }
 184         }
 185
 186         ts_params->op_mpool = rte_crypto_op_pool_create(
 187                         "MBUF_CRYPTO_SYM_OP_POOL",
 188                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 189                         NUM_MBUFS, MBUF_CACHE_SIZE,
 190                         DEFAULT_NUM_XFORMS *
 191                         sizeof(struct rte_crypto_sym_xform),
 192                         rte_socket_id());
 193         if (ts_params->op_mpool == NULL) {
 194                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 195                 return TEST_FAILED;
 196         }
 197
 198         /* Create 2 AESNI MB devices if required */
 199         if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) {
 200                 nb_devs = rte_cryptodev_count_devtype(
 201                                 RTE_CRYPTODEV_AESNI_MB_PMD);
 202                 if (nb_devs < 2) {
 203                         for (i = nb_devs; i < 2; i++) {
 204                                 ret = rte_eal_vdev_init(
 205                                         CRYPTODEV_NAME_AESNI_MB_PMD, NULL);
 206
 207                                 TEST_ASSERT(ret == 0,
 208                                         "Failed to create instance %u of"
 209                                         " pmd : %s",
 210                                         i, CRYPTODEV_NAME_AESNI_MB_PMD);
 211                         }
 212                 }
 213         }
 214
 215         /* Create 2 AESNI GCM devices if required */
 216         if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) {
 217                 nb_devs = rte_cryptodev_count_devtype(
 218                                 RTE_CRYPTODEV_AESNI_GCM_PMD);
 219                 if (nb_devs < 2) {
 220                         for (i = nb_devs; i < 2; i++) {
 221                                 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
 222                                         CRYPTODEV_NAME_AESNI_GCM_PMD, NULL),
 223                                         "Failed to create instance %u of"
 224                                         " pmd : %s",
 225                                         i, CRYPTODEV_NAME_AESNI_GCM_PMD);
 226                         }
 227                 }
 228         }
 229
 230         /* Create 2 Snow3G devices if required */
 231         if (gbl_cryptodev_type == RTE_CRYPTODEV_SNOW3G_PMD) {
 232                 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
 233                 if (nb_devs < 2) {
 234                         for (i = nb_devs; i < 2; i++) {
 235                                 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
 236                                         CRYPTODEV_NAME_SNOW3G_PMD, NULL),
 237                                         "Failed to create instance %u of"
 238                                         " pmd : %s",
 239                                         i, CRYPTODEV_NAME_SNOW3G_PMD);
 240                         }
 241                 }
 242         }
 243
 244         /* Create 2 NULL devices if required */
 245         if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) {
 246                 nb_devs = rte_cryptodev_count_devtype(
 247                                 RTE_CRYPTODEV_NULL_PMD);
 248                 if (nb_devs < 2) {
 249                         for (i = nb_devs; i < 2; i++) {
 250                                 int dev_id = rte_eal_vdev_init(
 251                                         CRYPTODEV_NAME_NULL_PMD, NULL);
 252
 253                                 TEST_ASSERT(dev_id >= 0,
 254                                         "Failed to create instance %u of"
 255                                         " pmd : %s",
 256                                         i, CRYPTODEV_NAME_NULL_PMD);
 257                         }
 258                 }
 259         }
 260
 261         nb_devs = rte_cryptodev_count();
 262         if (nb_devs < 1) {
 263                 RTE_LOG(ERR, USER1, "No crypto devices found?");
 264                 return TEST_FAILED;
 265         }
 266
 267         /* Create list of valid crypto devs */
 268         for (i = 0; i < nb_devs; i++) {
 269                 rte_cryptodev_info_get(i, &info);
 270                 if (info.dev_type == gbl_cryptodev_type)
 271                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 272         }
 273
 274         if (ts_params->valid_dev_count < 1)
 275                 return TEST_FAILED;
 276
 277         /* Set up all the qps on the first of the valid devices found */
 278         for (i = 0; i < 1; i++) {
 279                 dev_id = ts_params->valid_devs[i];
 280
 281                 rte_cryptodev_info_get(dev_id, &info);
 282
 283                 /*
 284                  * Since we can't free and re-allocate queue memory always set
 285                  * the queues on this device up to max size first so enough
 286                  * memory is allocated for any later re-configures needed by
 287                  * other tests
 288                  */
 289
 290                 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 291                 ts_params->conf.socket_id = SOCKET_ID_ANY;
 292                 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
 293
 294                 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 295                                 &ts_params->conf),
 296                                 "Failed to configure cryptodev %u with %u qps",
 297                                 dev_id, ts_params->conf.nb_queue_pairs);
 298
 299                 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 300
 301                 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 302                         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 303                                         dev_id, qp_id, &ts_params->qp_conf,
 304                                         rte_cryptodev_socket_id(dev_id)),
 305                                         "Failed to setup queue pair %u on "
 306                                         "cryptodev %u",
 307                                         qp_id, dev_id);
 308                 }
 309         }
 310
 311         return TEST_SUCCESS;
 312 }
 313
 314 static void
 315 testsuite_teardown(void)
 316 {
 317         struct crypto_testsuite_params *ts_params = &testsuite_params;
 318
 319         if (ts_params->mbuf_pool != NULL) {
 320                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 321                 rte_mempool_count(ts_params->mbuf_pool));
 322         }
 323
 324         if (ts_params->op_mpool != NULL) {
 325                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 326                 rte_mempool_count(ts_params->op_mpool));
 327         }
 328
 329 }
 330
 331 static int
 332 ut_setup(void)
 333 {
 334         struct crypto_testsuite_params *ts_params = &testsuite_params;
 335         struct crypto_unittest_params *ut_params = &unittest_params;
 336
 337         uint16_t qp_id;
 338
 339         /* Clear unit test parameters before running test */
 340         memset(ut_params, 0, sizeof(*ut_params));
 341
 342         /* Reconfigure device to default parameters */
 343         ts_params->conf.nb_queue_pairs = DEFAULT_NUM_QPS_PER_QAT_DEVICE;
 344         ts_params->conf.socket_id = SOCKET_ID_ANY;
 345         ts_params->conf.session_mp.nb_objs =
 346                         (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) ?
 347                                         DEFAULT_NUM_OPS_INFLIGHT :
 348                                         DEFAULT_NUM_OPS_INFLIGHT;
 349
 350         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 351                         &ts_params->conf),
 352                         "Failed to configure cryptodev %u",
 353                         ts_params->valid_devs[0]);
 354
 355         /*
 356          * Now reconfigure queues to size we actually want to use in this
 357          * test suite.
 358          */
 359         ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 360
 361         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 362                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 363                         ts_params->valid_devs[0], qp_id,
 364                         &ts_params->qp_conf,
 365                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 366                         "Failed to setup queue pair %u on cryptodev %u",
 367                         qp_id, ts_params->valid_devs[0]);
 368         }
 369
 370
 371         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 372
 373         /* Start the device */
 374         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
 375                         "Failed to start cryptodev %u",
 376                         ts_params->valid_devs[0]);
 377
 378         return TEST_SUCCESS;
 379 }
 380
 381 static void
 382 ut_teardown(void)
 383 {
 384         struct crypto_testsuite_params *ts_params = &testsuite_params;
 385         struct crypto_unittest_params *ut_params = &unittest_params;
 386         struct rte_cryptodev_stats stats;
 387
 388         /* free crypto session structure */
 389         if (ut_params->sess) {
 390                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
 391                                 ut_params->sess);
 392                 ut_params->sess = NULL;
 393         }
 394
 395         /* free crypto operation structure */
 396         if (ut_params->op)
 397                 rte_crypto_op_free(ut_params->op);
 398
 399         /*
 400          * free mbuf - both obuf and ibuf are usually the same,
 401          * but rte copes even if we call free twice
 402          */
 403         if (ut_params->obuf) {
 404                 rte_pktmbuf_free(ut_params->obuf);
 405                 ut_params->obuf = 0;
 406         }
 407         if (ut_params->ibuf) {
 408                 rte_pktmbuf_free(ut_params->ibuf);
 409                 ut_params->ibuf = 0;
 410         }
 411
 412         if (ts_params->mbuf_pool != NULL)
 413                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 414                                 rte_mempool_count(ts_params->mbuf_pool));
 415
 416         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
 417
 418         /* Stop the device */
 419         rte_cryptodev_stop(ts_params->valid_devs[0]);
 420 }
 421
 422 static int
 423 test_device_configure_invalid_dev_id(void)
 424 {
 425         struct crypto_testsuite_params *ts_params = &testsuite_params;
 426         uint16_t dev_id, num_devs = 0;
 427
 428         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
 429                         "Need at least %d devices for test", 1);
 430
 431         /* valid dev_id values */
 432         dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
 433
 434         /* Stop the device in case it's started so it can be configured */
 435         rte_cryptodev_stop(ts_params->valid_devs[dev_id]);
 436
 437         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
 438                         "Failed test for rte_cryptodev_configure: "
 439                         "invalid dev_num %u", dev_id);
 440
 441         /* invalid dev_id values */
 442         dev_id = num_devs;
 443
 444         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 445                         "Failed test for rte_cryptodev_configure: "
 446                         "invalid dev_num %u", dev_id);
 447
 448         dev_id = 0xff;
 449
 450         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 451                         "Failed test for rte_cryptodev_configure:"
 452                         "invalid dev_num %u", dev_id);
 453
 454         return TEST_SUCCESS;
 455 }
 456
 457 static int
 458 test_device_configure_invalid_queue_pair_ids(void)
 459 {
 460         struct crypto_testsuite_params *ts_params = &testsuite_params;
 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         /* valid - one queue pairs */
 466         ts_params->conf.nb_queue_pairs = 1;
 467
 468         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 469                         &ts_params->conf),
 470                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 471                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 472
 473
 474         /* valid - max value queue pairs */
 475         ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
 476
 477         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 478                         &ts_params->conf),
 479                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 480                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 481
 482
 483         /* invalid - zero queue pairs */
 484         ts_params->conf.nb_queue_pairs = 0;
 485
 486         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 487                         &ts_params->conf),
 488                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 489                         " invalid qps: %u",
 490                         ts_params->valid_devs[0],
 491                         ts_params->conf.nb_queue_pairs);
 492
 493
 494         /* invalid - max value supported by field queue pairs */
 495         ts_params->conf.nb_queue_pairs = UINT16_MAX;
 496
 497         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 498                         &ts_params->conf),
 499                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 500                         " invalid qps: %u",
 501                         ts_params->valid_devs[0],
 502                         ts_params->conf.nb_queue_pairs);
 503
 504
 505         /* invalid - max value + 1 queue pairs */
 506         ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
 507
 508         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 509                         &ts_params->conf),
 510                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 511                         " invalid qps: %u",
 512                         ts_params->valid_devs[0],
 513                         ts_params->conf.nb_queue_pairs);
 514
 515         return TEST_SUCCESS;
 516 }
 517
 518 static int
 519 test_queue_pair_descriptor_setup(void)
 520 {
 521         struct crypto_testsuite_params *ts_params = &testsuite_params;
 522         struct rte_cryptodev_info dev_info;
 523         struct rte_cryptodev_qp_conf qp_conf = {
 524                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
 525         };
 526
 527         uint16_t qp_id;
 528
 529         /* Stop the device in case it's started so it can be configured */
 530         rte_cryptodev_stop(ts_params->valid_devs[0]);
 531
 532
 533         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 534
 535         ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions;
 536
 537         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 538                         &ts_params->conf), "Failed to configure cryptodev %u",
 539                         ts_params->valid_devs[0]);
 540
 541
 542         /*
 543          * Test various ring sizes on this device. memzones can't be
 544          * freed so are re-used if ring is released and re-created.
 545          */
 546         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
 547
 548         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 549                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 550                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 551                                 rte_cryptodev_socket_id(
 552                                                 ts_params->valid_devs[0])),
 553                                 "Failed test for "
 554                                 "rte_cryptodev_queue_pair_setup: num_inflights "
 555                                 "%u on qp %u on cryptodev %u",
 556                                 qp_conf.nb_descriptors, qp_id,
 557                                 ts_params->valid_devs[0]);
 558         }
 559
 560         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
 561
 562         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 563                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 564                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 565                                 rte_cryptodev_socket_id(
 566                                                 ts_params->valid_devs[0])),
 567                                 "Failed test for"
 568                                 " rte_cryptodev_queue_pair_setup: num_inflights"
 569                                 " %u on qp %u on cryptodev %u",
 570                                 qp_conf.nb_descriptors, qp_id,
 571                                 ts_params->valid_devs[0]);
 572         }
 573
 574         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
 575
 576         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 577                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 578                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 579                                 rte_cryptodev_socket_id(
 580                                                 ts_params->valid_devs[0])),
 581                                 "Failed test for "
 582                                 "rte_cryptodev_queue_pair_setup: num_inflights"
 583                                 " %u on qp %u on cryptodev %u",
 584                                 qp_conf.nb_descriptors, qp_id,
 585                                 ts_params->valid_devs[0]);
 586         }
 587
 588         /* invalid number of descriptors - max supported + 2 */
 589         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
 590
 591         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 592                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 593                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 594                                 rte_cryptodev_socket_id(
 595                                                 ts_params->valid_devs[0])),
 596                                 "Unexpectedly passed test for "
 597                                 "rte_cryptodev_queue_pair_setup:"
 598                                 "num_inflights %u on qp %u on cryptodev %u",
 599                                 qp_conf.nb_descriptors, qp_id,
 600                                 ts_params->valid_devs[0]);
 601         }
 602
 603         /* invalid number of descriptors - max value of parameter */
 604         qp_conf.nb_descriptors = UINT32_MAX-1;
 605
 606         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 607                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 608                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 609                                 rte_cryptodev_socket_id(
 610                                                 ts_params->valid_devs[0])),
 611                                 "Unexpectedly passed test for "
 612                                 "rte_cryptodev_queue_pair_setup:"
 613                                 "num_inflights %u on qp %u on cryptodev %u",
 614                                 qp_conf.nb_descriptors, qp_id,
 615                                 ts_params->valid_devs[0]);
 616         }
 617
 618         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 619
 620         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 621                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 622                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 623                                 rte_cryptodev_socket_id(
 624                                                 ts_params->valid_devs[0])),
 625                                 "Failed test for"
 626                                 " rte_cryptodev_queue_pair_setup:"
 627                                 "num_inflights %u on qp %u on cryptodev %u",
 628                                 qp_conf.nb_descriptors, qp_id,
 629                                 ts_params->valid_devs[0]);
 630         }
 631
 632         /* invalid number of descriptors - max supported + 1 */
 633         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
 634
 635         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 636                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 637                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 638                                 rte_cryptodev_socket_id(
 639                                                 ts_params->valid_devs[0])),
 640                                 "Unexpectedly passed test for "
 641                                 "rte_cryptodev_queue_pair_setup:"
 642                                 "num_inflights %u on qp %u on cryptodev %u",
 643                                 qp_conf.nb_descriptors, qp_id,
 644                                 ts_params->valid_devs[0]);
 645         }
 646
 647         /* test invalid queue pair id */
 648         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
 649
 650         qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE;         /*invalid */
 651
 652         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 653                         ts_params->valid_devs[0],
 654                         qp_id, &qp_conf,
 655                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 656                         "Failed test for rte_cryptodev_queue_pair_setup:"
 657                         "invalid qp %u on cryptodev %u",
 658                         qp_id, ts_params->valid_devs[0]);
 659
 660         qp_id = 0xffff; /*invalid*/
 661
 662         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 663                         ts_params->valid_devs[0],
 664                         qp_id, &qp_conf,
 665                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 666                         "Failed test for rte_cryptodev_queue_pair_setup:"
 667                         "invalid qp %u on cryptodev %u",
 668                         qp_id, ts_params->valid_devs[0]);
 669
 670         return TEST_SUCCESS;
 671 }
 672
 673 /* ***** Plaintext data for tests ***** */
 674
 675 const char catch_22_quote_1[] =
 676                 "There was only one catch and that was Catch-22, which "
 677                 "specified that a concern for one's safety in the face of "
 678                 "dangers that were real and immediate was the process of a "
 679                 "rational mind. Orr was crazy and could be grounded. All he "
 680                 "had to do was ask; and as soon as he did, he would no longer "
 681                 "be crazy and would have to fly more missions. Orr would be "
 682                 "crazy to fly more missions and sane if he didn't, but if he "
 683                 "was sane he had to fly them. If he flew them he was crazy "
 684                 "and didn't have to; but if he didn't want to he was sane and "
 685                 "had to. Yossarian was moved very deeply by the absolute "
 686                 "simplicity of this clause of Catch-22 and let out a "
 687                 "respectful whistle. \"That's some catch, that Catch-22\", he "
 688                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
 689
 690 const char catch_22_quote[] =
 691                 "What a lousy earth! He wondered how many people were "
 692                 "destitute that same night even in his own prosperous country, "
 693                 "how many homes were shanties, how many husbands were drunk "
 694                 "and wives socked, and how many children were bullied, abused, "
 695                 "or abandoned. How many families hungered for food they could "
 696                 "not afford to buy? How many hearts were broken? How many "
 697                 "suicides would take place that same night, how many people "
 698                 "would go insane? How many cockroaches and landlords would "
 699                 "triumph? How many winners were losers, successes failures, "
 700                 "and rich men poor men? How many wise guys were stupid? How "
 701                 "many happy endings were unhappy endings? How many honest men "
 702                 "were liars, brave men cowards, loyal men traitors, how many "
 703                 "sainted men were corrupt, how many people in positions of "
 704                 "trust had sold their souls to bodyguards, how many had never "
 705                 "had souls? How many straight-and-narrow paths were crooked "
 706                 "paths? How many best families were worst families and how "
 707                 "many good people were bad people? When you added them all up "
 708                 "and then subtracted, you might be left with only the children, "
 709                 "and perhaps with Albert Einstein and an old violinist or "
 710                 "sculptor somewhere.";
 711
 712 #define QUOTE_480_BYTES         (480)
 713 #define QUOTE_512_BYTES         (512)
 714 #define QUOTE_768_BYTES         (768)
 715 #define QUOTE_1024_BYTES        (1024)
 716
 717
 718
 719 /* ***** SHA1 Hash Tests ***** */
 720
 721 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
 722
 723 static uint8_t hmac_sha1_key[] = {
 724         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 725         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 726         0xDE, 0xF4, 0xDE, 0xAD };
 727
 728 /* ***** SHA224 Hash Tests ***** */
 729
 730 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
 731
 732
 733 /* ***** AES-CBC Cipher Tests ***** */
 734
 735 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
 736 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
 737
 738 static uint8_t aes_cbc_key[] = {
 739         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 740         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
 741
 742 static uint8_t aes_cbc_iv[] = {
 743         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 744         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
 745
 746
 747 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
 748
 749 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
 750         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
 751         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
 752         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
 753         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
 754         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
 755         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
 756         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
 757         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
 758         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
 759         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
 760         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
 761         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
 762         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
 763         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
 764         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
 765         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
 766         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
 767         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
 768         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
 769         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
 770         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
 771         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
 772         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 773         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
 774         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
 775         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
 776         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
 777         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
 778         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
 779         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
 780         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
 781         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
 782         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
 783         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
 784         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
 785         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
 786         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
 787         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
 788         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
 789         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
 790         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
 791         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
 792         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
 793         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
 794         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
 795         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
 796         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
 797         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
 798         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
 799         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
 800         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
 801         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
 802         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
 803         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
 804         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
 805         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
 806         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
 807         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
 808         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
 809         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
 810         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
 811         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
 812         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
 813         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
 814 };
 815
 816 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
 817         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
 818         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
 819         0x18, 0x8c, 0x1d, 0x32
 820 };
 821
 822
 823 static int
 824 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
 825 {
 826         struct crypto_testsuite_params *ts_params = &testsuite_params;
 827         struct crypto_unittest_params *ut_params = &unittest_params;
 828
 829         /* Generate test mbuf data and space for digest */
 830         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
 831                         catch_22_quote, QUOTE_512_BYTES, 0);
 832
 833         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
 834                         DIGEST_BYTE_LENGTH_SHA1);
 835         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
 836
 837         /* Setup Cipher Parameters */
 838         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
 839         ut_params->cipher_xform.next = &ut_params->auth_xform;
 840
 841         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
 842         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
 843         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
 844         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
 845
 846         /* Setup HMAC Parameters */
 847         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
 848
 849         ut_params->auth_xform.next = NULL;
 850
 851         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 852         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
 853         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
 854         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
 855         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
 856
 857         /* Create crypto session*/
 858         ut_params->sess = rte_cryptodev_sym_session_create(
 859                         ts_params->valid_devs[0],
 860                         &ut_params->cipher_xform);
 861         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 862
 863         /* Generate crypto op data structure */
 864         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
 865                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
 866         TEST_ASSERT_NOT_NULL(ut_params->op,
 867                         "Failed to allocate symmetric crypto operation struct");
 868
 869         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 870
 871         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 872
 873         /* set crypto operation source mbuf */
 874         sym_op->m_src = ut_params->ibuf;
 875
 876         /* Set crypto operation authentication parameters */
 877         sym_op->auth.digest.data = ut_params->digest;
 878         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
 879                         ut_params->ibuf, QUOTE_512_BYTES);
 880         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
 881
 882         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
 883         sym_op->auth.data.length = QUOTE_512_BYTES;
 884
 885         /* Set crypto operation cipher parameters */
 886         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
 887                         CIPHER_IV_LENGTH_AES_CBC);
 888         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
 889         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
 890
 891         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
 892                         CIPHER_IV_LENGTH_AES_CBC);
 893
 894         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
 895         sym_op->cipher.data.length = QUOTE_512_BYTES;
 896
 897         /* Process crypto operation */
 898         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
 899                         ut_params->op), "failed to process sym crypto op");
 900
 901         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
 902                         "crypto op processing failed");
 903
 904         /* Validate obuf */
 905         uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
 906                         uint8_t *, CIPHER_IV_LENGTH_AES_CBC);
 907
 908         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
 909                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
 910                         QUOTE_512_BYTES,
 911                         "ciphertext data not as expected");
 912
 913         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
 914
 915         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
 916                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
 917                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
 918                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
 919                                         DIGEST_BYTE_LENGTH_SHA1,
 920                         "Generated digest data not as expected");
 921
 922         return TEST_SUCCESS;
 923 }
 924
 925
 926 static int
 927 test_AES_CBC_HMAC_SHA1_encrypt_digest_oop(void)
 928 {
 929         struct crypto_testsuite_params *ts_params = &testsuite_params;
 930         struct crypto_unittest_params *ut_params = &unittest_params;
 931
 932         /* Generate test mbuf data and space for digest */
 933
 934         TEST_ASSERT_EQUAL(setup_oop_test_mbufs(&ut_params->ibuf,
 935                         &ut_params->obuf, ts_params->mbuf_pool, catch_22_quote,
 936                         QUOTE_512_BYTES, 0), 0,
 937                         "Allocation of rte_mbuf failed");
 938
 939         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->obuf,
 940                                 DIGEST_BYTE_LENGTH_SHA1);
 941
 942         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
 943
 944         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
 945         ut_params->cipher_xform.next = &ut_params->auth_xform;
 946
 947         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
 948         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
 949         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
 950         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
 951
 952         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
 953         ut_params->auth_xform.next = NULL;
 954
 955         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 956         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
 957         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
 958         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
 959         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
 960
 961         ut_params->sess = rte_cryptodev_sym_session_create(
 962                         ts_params->valid_devs[0],
 963                         &ut_params->cipher_xform);
 964
 965         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 966
 967         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
 968                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
 969
 970
 971         TEST_ASSERT_NOT_NULL(ut_params->op,
 972                         "Failed to allocate symmetric crypto operation struct");
 973
 974         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 975
 976         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 977
 978         /* set crypto operation source mbuf */
 979         sym_op->m_src = ut_params->ibuf;
 980         sym_op->m_dst = ut_params->obuf;
 981
 982         sym_op->auth.digest.data = ut_params->digest;
 983
 984         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
 985                         ut_params->obuf, QUOTE_512_BYTES);
 986
 987         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
 988         sym_op->auth.data.length = QUOTE_512_BYTES;
 989
 990         /* Set crypto operation cipher parameters */
 991         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
 992                         CIPHER_IV_LENGTH_AES_CBC);
 993
 994         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data,
 995                         "Failed to prepend place for iv input");
 996
 997         TEST_ASSERT_NOT_NULL(rte_pktmbuf_prepend(ut_params->obuf,
 998                         CIPHER_IV_LENGTH_AES_CBC),
 999                         "Failed to prepend place for iv output");
1000
1001         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1002
1003         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1004         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1005
1006         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1007                         CIPHER_IV_LENGTH_AES_CBC);
1008
1009         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1010         sym_op->cipher.data.length = QUOTE_512_BYTES;
1011
1012
1013         /* Process crypto operation */
1014         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1015                         ut_params->op), "failed to process sym crypto op");
1016
1017         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1018                         "crypto op processing failed");
1019
1020         /* Validate obuf */
1021         uint8_t *ciphertext;
1022
1023         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
1024                         uint8_t *, CIPHER_IV_LENGTH_AES_CBC);
1025
1026         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1027                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1028                         QUOTE_512_BYTES,
1029                         "ciphertext data not as expected");
1030
1031         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1032
1033         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1034                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1035                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1036                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1037                                         DIGEST_BYTE_LENGTH_SHA1,
1038                         "Generated digest data not as expected");
1039
1040
1041         return TEST_SUCCESS;
1042 }
1043
1044
1045 static int
1046 test_AES_CBC_HMAC_SHA1_decrypt_digest_oop_ver(void)
1047 {
1048         struct crypto_testsuite_params *ts_params = &testsuite_params;
1049         struct crypto_unittest_params *ut_params = &unittest_params;
1050
1051         /* Generate test mbuf data and digest */
1052
1053         TEST_ASSERT_EQUAL(setup_oop_test_mbufs(&ut_params->ibuf,
1054                         &ut_params->obuf, ts_params->mbuf_pool,
1055                         (const char *)
1056                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1057                         QUOTE_512_BYTES, 0), 0,
1058                         "Allocation of rte_mbuf failed");
1059
1060         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1061                         DIGEST_BYTE_LENGTH_SHA1);
1062
1063         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1064
1065         rte_memcpy(ut_params->digest,
1066                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1067                         DIGEST_BYTE_LENGTH_SHA1);
1068
1069         /* Setup Cipher Parameters */
1070         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1071         ut_params->cipher_xform.next = NULL;
1072
1073         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1074         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1075         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1076         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1077
1078         /* Setup HMAC Parameters */
1079         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1080         ut_params->auth_xform.next = &ut_params->cipher_xform;
1081
1082         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1083         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1084         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1085         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1086         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1087
1088         /* Create Crypto session*/
1089         ut_params->sess =
1090                 rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
1091                                                 &ut_params->auth_xform);
1092         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1093
1094         /* Generate Crypto op data structure */
1095         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1096                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1097         TEST_ASSERT_NOT_NULL(ut_params->op,
1098                         "Failed to allocate symmetric crypto operation struct");
1099
1100         /* attach symmetric crypto session to crypto operations */
1101         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1102
1103         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1104
1105         /* set crypto operation source mbuf */
1106         sym_op->m_src = ut_params->ibuf;
1107         sym_op->m_dst = ut_params->obuf;
1108
1109         sym_op->auth.digest.data = ut_params->digest;
1110         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1111                         ut_params->ibuf, QUOTE_512_BYTES);
1112         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
1113
1114         sym_op->auth.data.length = QUOTE_512_BYTES;
1115
1116         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1117                         CIPHER_IV_LENGTH_AES_CBC);
1118
1119         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data,
1120                         "Failed to prepend place for iv input");
1121
1122         TEST_ASSERT_NOT_NULL(rte_pktmbuf_prepend(ut_params->obuf,
1123                         CIPHER_IV_LENGTH_AES_CBC),
1124                         "Failed to prepend place for iv output");
1125
1126         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1127
1128         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1129         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1130
1131         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1132                         CIPHER_IV_LENGTH_AES_CBC);
1133
1134         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1135         sym_op->cipher.data.length = QUOTE_512_BYTES;
1136
1137
1138         /* Process crypto operation */
1139         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1140                         ut_params->op), "failed to process sym crypto op");
1141
1142         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1143                         "Digest verification failed");
1144
1145         ut_params->obuf = ut_params->op->sym->m_dst;
1146
1147         /* Validate obuf */
1148         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1149                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1150                         CIPHER_IV_LENGTH_AES_CBC,
1151                         catch_22_quote,
1152                         QUOTE_512_BYTES,
1153                         "Ciphertext data not as expected");
1154
1155
1156         return TEST_SUCCESS;
1157 }
1158
1159
1160 static int
1161 test_AES_CBC_HMAC_SHA1_encrypt_digest_sessionless(void)
1162 {
1163         struct crypto_testsuite_params *ts_params = &testsuite_params;
1164         struct crypto_unittest_params *ut_params = &unittest_params;
1165
1166         /* Generate test mbuf data and space for digest */
1167         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1168                         catch_22_quote, QUOTE_512_BYTES, 0);
1169
1170         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1171                         DIGEST_BYTE_LENGTH_SHA1);
1172         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1173
1174         /* Generate Crypto op data structure */
1175         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1176                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1177         TEST_ASSERT_NOT_NULL(ut_params->op,
1178                         "Failed to allocate symmetric crypto operation struct");
1179
1180         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(ut_params->op, 2),
1181                         "failed to allocate space for crypto transforms");
1182
1183         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1184
1185         /* set crypto operation source mbuf */
1186         sym_op->m_src = ut_params->ibuf;
1187
1188         /* Set crypto operation data parameters */
1189         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1190
1191         /* cipher parameters */
1192         sym_op->xform->cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1193         sym_op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1194         sym_op->xform->cipher.key.data = aes_cbc_key;
1195         sym_op->xform->cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1196
1197         /* hash parameters */
1198         sym_op->xform->next->type = RTE_CRYPTO_SYM_XFORM_AUTH;
1199
1200         sym_op->xform->next->auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1201         sym_op->xform->next->auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1202         sym_op->xform->next->auth.key.length = HMAC_KEY_LENGTH_SHA1;
1203         sym_op->xform->next->auth.key.data = hmac_sha1_key;
1204         sym_op->xform->next->auth.digest_length =
1205                         DIGEST_BYTE_LENGTH_SHA1;
1206
1207         sym_op->auth.digest.data = ut_params->digest;
1208         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1209                         ut_params->ibuf, QUOTE_512_BYTES);
1210         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
1211
1212
1213         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1214         sym_op->auth.data.length = QUOTE_512_BYTES;
1215
1216         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1217                         CIPHER_IV_LENGTH_AES_CBC);
1218         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1219         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1220
1221         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1222                         CIPHER_IV_LENGTH_AES_CBC);
1223
1224         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1225         sym_op->cipher.data.length = QUOTE_512_BYTES;
1226
1227         /* Process crypto operation */
1228         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1229                         ut_params->op), "failed to process sym crypto op");
1230
1231         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1232                         "crypto op processing failed");
1233
1234         ut_params->obuf = ut_params->op->sym->m_src;
1235
1236         /* Validate obuf */
1237         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1238                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1239                         CIPHER_IV_LENGTH_AES_CBC,
1240                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1241                         QUOTE_512_BYTES,
1242                         "Ciphertext data not as expected");
1243
1244         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1245                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1246                         CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES,
1247                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1248                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1249                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1250                                         DIGEST_BYTE_LENGTH_SHA1,
1251                         "Generated digest data not as expected");
1252
1253
1254         return TEST_SUCCESS;
1255 }
1256
1257 static int
1258 test_AES_CBC_HMAC_SHA1_decrypt_digest_verify(void)
1259 {
1260         struct crypto_testsuite_params *ts_params = &testsuite_params;
1261         struct crypto_unittest_params *ut_params = &unittest_params;
1262
1263         /* Generate test mbuf data and digest */
1264         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1265                         (const char *)
1266                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1267                         QUOTE_512_BYTES, 0);
1268
1269         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1270                         DIGEST_BYTE_LENGTH_SHA1);
1271         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1272
1273         rte_memcpy(ut_params->digest,
1274                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1275                         DIGEST_BYTE_LENGTH_SHA1);
1276
1277         /* Setup Cipher Parameters */
1278         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1279         ut_params->cipher_xform.next = NULL;
1280
1281         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1282         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1283         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1284         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1285
1286         /* Setup HMAC Parameters */
1287         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1288         ut_params->auth_xform.next = &ut_params->cipher_xform;
1289
1290         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1291         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1292         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1293         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1294         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1295
1296         /* Create Crypto session*/
1297         ut_params->sess =
1298                 rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
1299                                                 &ut_params->auth_xform);
1300         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1301
1302         /* Generate Crypto op data structure */
1303         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1304                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1305         TEST_ASSERT_NOT_NULL(ut_params->op,
1306                         "Failed to allocate symmetric crypto operation struct");
1307
1308         /* attach symmetric crypto session to crypto operations */
1309         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1310
1311         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1312
1313         /* set crypto operation source mbuf */
1314         sym_op->m_src = ut_params->ibuf;
1315
1316         sym_op->auth.digest.data = ut_params->digest;
1317         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1318                         ut_params->ibuf, QUOTE_512_BYTES);
1319         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
1320
1321         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1322         sym_op->auth.data.length = QUOTE_512_BYTES;
1323
1324         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1325                         CIPHER_IV_LENGTH_AES_CBC);
1326         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1327         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1328
1329         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1330                         CIPHER_IV_LENGTH_AES_CBC);
1331
1332         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1333         sym_op->cipher.data.length = QUOTE_512_BYTES;
1334
1335
1336         /* Process crypto operation */
1337         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1338                         ut_params->op), "failed to process sym crypto op");
1339
1340         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1341                         "crypto op processing failed");
1342
1343         ut_params->obuf = ut_params->op->sym->m_src;
1344
1345
1346         /* Validate obuf */
1347         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1348                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1349                         CIPHER_IV_LENGTH_AES_CBC,
1350                         catch_22_quote,
1351                         QUOTE_512_BYTES,
1352                         "Ciphertext data not as expected");
1353
1354         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1355                         "Digest verification failed");
1356
1357
1358         return TEST_SUCCESS;
1359 }
1360
1361
1362 /* ***** AES-CBC / HMAC-SHA256 Hash Tests ***** */
1363
1364 #define HMAC_KEY_LENGTH_SHA256  (DIGEST_BYTE_LENGTH_SHA256)
1365
1366 static uint8_t hmac_sha256_key[] = {
1367         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1368         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1369         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1370         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 };
1371
1372 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest[] = {
1373         0xc8, 0x57, 0x57, 0x31, 0x03, 0xe0, 0x03, 0x55,
1374         0x07, 0xc8, 0x9e, 0x7f, 0x48, 0x9a, 0x61, 0x9a,
1375         0x68, 0xee, 0x03, 0x0e, 0x71, 0x75, 0xc7, 0xf4,
1376         0x2e, 0x45, 0x26, 0x32, 0x7c, 0x12, 0x15, 0x15 };
1377
1378 static int
1379 test_AES_CBC_HMAC_SHA256_encrypt_digest(void)
1380 {
1381         struct crypto_testsuite_params *ts_params = &testsuite_params;
1382         struct crypto_unittest_params *ut_params = &unittest_params;
1383
1384         /* Generate test mbuf data and space for digest */
1385         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1386                         catch_22_quote, QUOTE_512_BYTES, 0);
1387
1388         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1389                         DIGEST_BYTE_LENGTH_SHA256);
1390         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1391
1392         /* Setup Cipher Parameters */
1393         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1394         ut_params->cipher_xform.next = &ut_params->auth_xform;
1395
1396         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1397         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1398         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1399         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1400
1401         /* Setup HMAC Parameters */
1402         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1403         ut_params->auth_xform.next = NULL;
1404
1405         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1406         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1407         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1408         ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1409         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1410
1411         /* Create Crypto session*/
1412         ut_params->sess = rte_cryptodev_sym_session_create(
1413                         ts_params->valid_devs[0],
1414                         &ut_params->cipher_xform);
1415         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1416
1417         /* Generate Crypto op data structure */
1418         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1419                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1420         TEST_ASSERT_NOT_NULL(ut_params->op,
1421                         "Failed to allocate symmetric crypto operation struct");
1422
1423         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1424
1425         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1426
1427         /* set crypto operation source mbuf */
1428         sym_op->m_src = ut_params->ibuf;
1429
1430         sym_op->auth.digest.data = ut_params->digest;
1431         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1432                         ut_params->ibuf, QUOTE_512_BYTES);
1433         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256;
1434
1435         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1436         sym_op->auth.data.length = QUOTE_512_BYTES;
1437
1438         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1439                         CIPHER_IV_LENGTH_AES_CBC);
1440         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1441         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1442
1443         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1444                         CIPHER_IV_LENGTH_AES_CBC);
1445
1446         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1447         sym_op->cipher.data.length = QUOTE_512_BYTES;
1448
1449         /* Process crypto operation */
1450         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1451                         ut_params->op), "failed to process sym crypto op");
1452
1453         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1454                         "crypto op processing failed");
1455
1456         ut_params->obuf = ut_params->op->sym->m_src;
1457
1458         /* Validate obuf */
1459         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1460                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1461                         CIPHER_IV_LENGTH_AES_CBC,
1462                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1463                         QUOTE_512_BYTES,
1464                         "Ciphertext data not as expected");
1465
1466         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1467                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1468                         CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES,
1469                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest,
1470                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1471                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA256 :
1472                                         DIGEST_BYTE_LENGTH_SHA256,
1473                         "Generated digest data not as expected");
1474
1475
1476         return TEST_SUCCESS;
1477 }
1478
1479 static int
1480 test_AES_CBC_HMAC_SHA256_decrypt_digest_verify(void)
1481 {
1482         struct crypto_testsuite_params *ts_params = &testsuite_params;
1483         struct crypto_unittest_params *ut_params = &unittest_params;
1484
1485         /* Generate test mbuf data and digest */
1486         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1487                         (const char *)
1488                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1489                         QUOTE_512_BYTES, 0);
1490
1491         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1492                         DIGEST_BYTE_LENGTH_SHA256);
1493         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1494
1495         rte_memcpy(ut_params->digest,
1496                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest,
1497                         DIGEST_BYTE_LENGTH_SHA256);
1498
1499         /* Setup Cipher Parameters */
1500         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1501         ut_params->cipher_xform.next = NULL;
1502
1503         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1504         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1505         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1506         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1507
1508         /* Setup HMAC Parameters */
1509         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1510         ut_params->auth_xform.next = &ut_params->cipher_xform;
1511
1512         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1513         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1514         ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1515         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1516         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1517
1518         /* Create Crypto session*/
1519         ut_params->sess =
1520                 rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
1521                                                 &ut_params->auth_xform);
1522         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1523
1524         /* Generate Crypto op data structure */
1525         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1526                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1527         TEST_ASSERT_NOT_NULL(ut_params->op,
1528                         "Failed to allocate symmetric crypto operation struct");
1529
1530
1531         /* Set crypto operation data parameters */
1532         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1533
1534         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1535
1536         /* set crypto operation source mbuf */
1537         sym_op->m_src = ut_params->ibuf;
1538
1539         sym_op->auth.digest.data = ut_params->digest;
1540         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1541                         ut_params->ibuf, QUOTE_512_BYTES);
1542         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256;
1543
1544         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1545         sym_op->auth.data.length = QUOTE_512_BYTES;
1546
1547         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1548                         ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1549         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1550         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1551
1552         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1553                         CIPHER_IV_LENGTH_AES_CBC);
1554
1555         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1556         sym_op->cipher.data.length = QUOTE_512_BYTES;
1557
1558         /* Process crypto operation */
1559         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1560                         ut_params->op), "failed to process sym crypto op");
1561
1562         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1563                         "crypto op processing failed");
1564
1565         ut_params->obuf = ut_params->op->sym->m_src;
1566
1567         /* Validate obuf */
1568         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1569                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1570                         CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1571                         QUOTE_512_BYTES,
1572                         "Plaintext data not as expected");
1573
1574         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1575                         "Digest verification failed");
1576
1577         return TEST_SUCCESS;
1578 }
1579
1580 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1581
1582 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
1583
1584 static uint8_t hmac_sha512_key[] = {
1585         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1586         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1587         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1588         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1589         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1590         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1591         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1592         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1593
1594 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1595         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1596         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1597         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1598         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1599         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1600         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1601         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1602         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1603
1604 static int
1605 test_AES_CBC_HMAC_SHA512_encrypt_digest(void)
1606 {
1607         struct crypto_testsuite_params *ts_params = &testsuite_params;
1608         struct crypto_unittest_params *ut_params = &unittest_params;
1609
1610         /* Generate test mbuf data and space for digest */
1611         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1612                         catch_22_quote, QUOTE_512_BYTES, 0);
1613
1614         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1615                         DIGEST_BYTE_LENGTH_SHA512);
1616         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1617
1618         /* Setup Cipher Parameters */
1619         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1620         ut_params->cipher_xform.next = &ut_params->auth_xform;
1621
1622         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1623         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1624         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1625         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1626
1627         /* Setup HMAC Parameters */
1628         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1629         ut_params->auth_xform.next = NULL;
1630
1631         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1632         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1633         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1634         ut_params->auth_xform.auth.key.data = hmac_sha512_key;
1635         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1636
1637         /* Create Crypto session*/
1638         ut_params->sess =
1639                 rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
1640                                                 &ut_params->cipher_xform);
1641
1642         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1643
1644         /* Generate Crypto op data structure */
1645         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1646                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1647         TEST_ASSERT_NOT_NULL(ut_params->op,
1648                         "Failed to allocate symmetric crypto operation struct");
1649
1650         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1651
1652         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1653
1654         /* set crypto operation source mbuf */
1655         sym_op->m_src = ut_params->ibuf;
1656
1657         sym_op->auth.digest.data = ut_params->digest;
1658         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1659                         ut_params->ibuf, QUOTE_512_BYTES);
1660         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
1661
1662         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1663         sym_op->auth.data.length = QUOTE_512_BYTES;
1664
1665         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1666                         CIPHER_IV_LENGTH_AES_CBC);
1667         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1668         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1669
1670         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1671                         CIPHER_IV_LENGTH_AES_CBC);
1672
1673         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1674         sym_op->cipher.data.length = QUOTE_512_BYTES;
1675
1676         /* Process crypto operation */
1677         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1678                         ut_params->op), "failed to process sym crypto op");
1679
1680         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1681                         "crypto op processing failed");
1682
1683         ut_params->obuf = ut_params->op->sym->m_src;
1684
1685         /* Validate obuf */
1686         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1687                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1688                         CIPHER_IV_LENGTH_AES_CBC,
1689                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1690                         QUOTE_512_BYTES,
1691                         "Ciphertext data not as expected");
1692
1693         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1694                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1695                         CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES,
1696                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
1697                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1698                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA512 :
1699                                         DIGEST_BYTE_LENGTH_SHA512,
1700                         "Generated digest data not as expected");
1701
1702         return TEST_SUCCESS;
1703 }
1704
1705
1706 static int
1707 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1708                 struct crypto_unittest_params *ut_params);
1709
1710 static int
1711 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1712                 struct crypto_unittest_params *ut_params,
1713                 struct crypto_testsuite_params *ts_params);
1714
1715 static int
1716 test_AES_CBC_HMAC_SHA512_decrypt_digest_verify(void)
1717 {
1718         struct crypto_unittest_params *ut_params = &unittest_params;
1719         struct crypto_testsuite_params *ts_params = &testsuite_params;
1720
1721         TEST_ASSERT(test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1722                         ut_params) == TEST_SUCCESS,
1723                         "Failed to create session params");
1724
1725         /* Create Crypto session*/
1726         ut_params->sess =
1727                 rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
1728                                                 &ut_params->auth_xform);
1729         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1730
1731         return test_AES_CBC_HMAC_SHA512_decrypt_perform(ut_params->sess,
1732                         ut_params, ts_params);
1733 }
1734
1735 static int
1736 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1737                 struct crypto_unittest_params *ut_params)
1738 {
1739
1740         /* Setup Cipher Parameters */
1741         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1742         ut_params->cipher_xform.next = NULL;
1743
1744         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1745         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1746         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1747         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1748
1749         /* Setup HMAC Parameters */
1750         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1751         ut_params->auth_xform.next = &ut_params->cipher_xform;
1752
1753         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1754         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1755         ut_params->auth_xform.auth.key.data = hmac_sha512_key;
1756         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1757         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1758
1759         return TEST_SUCCESS;
1760 }
1761
1762
1763 static int
1764 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1765                 struct crypto_unittest_params *ut_params,
1766                 struct crypto_testsuite_params *ts_params)
1767 {
1768         /* Generate test mbuf data and digest */
1769         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1770                         (const char *)
1771                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1772                         QUOTE_512_BYTES, 0);
1773
1774         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1775                         DIGEST_BYTE_LENGTH_SHA512);
1776         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1777
1778         rte_memcpy(ut_params->digest,
1779                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
1780                         DIGEST_BYTE_LENGTH_SHA512);
1781
1782         /* Generate Crypto op data structure */
1783         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1784                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1785         TEST_ASSERT_NOT_NULL(ut_params->op,
1786                         "Failed to allocate symmetric crypto operation struct");
1787
1788         rte_crypto_op_attach_sym_session(ut_params->op, sess);
1789
1790         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1791
1792         /* set crypto operation source mbuf */
1793         sym_op->m_src = ut_params->ibuf;
1794
1795         sym_op->auth.digest.data = ut_params->digest;
1796         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1797                         ut_params->ibuf, QUOTE_512_BYTES);
1798         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
1799
1800         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1801         sym_op->auth.data.length = QUOTE_512_BYTES;
1802
1803         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1804                         ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1805         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
1806                         ut_params->ibuf, 0);
1807         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1808
1809         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1810                         CIPHER_IV_LENGTH_AES_CBC);
1811
1812         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1813         sym_op->cipher.data.length = QUOTE_512_BYTES;
1814
1815         /* Process crypto operation */
1816         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1817                         ut_params->op), "failed to process sym crypto op");
1818
1819         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1820                         "crypto op processing failed");
1821
1822         ut_params->obuf = ut_params->op->sym->m_src;
1823
1824         /* Validate obuf */
1825         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1826                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1827                         CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1828                         QUOTE_512_BYTES,
1829                         "Plaintext data not as expected");
1830
1831         /* Validate obuf */
1832         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1833                         "Digest verification failed");
1834
1835         return TEST_SUCCESS;
1836 }
1837
1838 /* ***** AES-CBC / HMAC-AES_XCBC Chain Tests ***** */
1839
1840 static uint8_t aes_cbc_hmac_aes_xcbc_key[] = {
1841         0x87, 0x61, 0x54, 0x53, 0xC4, 0x6D, 0xDD, 0x51,
1842         0xE1, 0x9F, 0x86, 0x64, 0x39, 0x0A, 0xE6, 0x59
1843         };
1844
1845 static const uint8_t  catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest[] = {
1846         0xE0, 0xAC, 0x9A, 0xC4, 0x22, 0x64, 0x35, 0x89,
1847         0x77, 0x1D, 0x8B, 0x75
1848         };
1849
1850 static int
1851 test_AES_CBC_HMAC_AES_XCBC_encrypt_digest(void)
1852 {
1853         struct crypto_testsuite_params *ts_params = &testsuite_params;
1854         struct crypto_unittest_params *ut_params = &unittest_params;
1855
1856         /* Generate test mbuf data and space for digest */
1857         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1858                         catch_22_quote, QUOTE_512_BYTES, 0);
1859
1860         /* Setup Cipher Parameters */
1861         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1862         ut_params->cipher_xform.next = &ut_params->auth_xform;
1863
1864         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1865         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1866         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1867         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1868
1869         /* Setup HMAC Parameters */
1870         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1871         ut_params->auth_xform.next = NULL;
1872
1873         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1874         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC;
1875         ut_params->auth_xform.auth.key.length = AES_XCBC_MAC_KEY_SZ;
1876         ut_params->auth_xform.auth.key.data = aes_cbc_hmac_aes_xcbc_key;
1877         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_AES_XCBC;
1878
1879         /* Create Crypto session*/
1880         ut_params->sess = rte_cryptodev_sym_session_create(
1881                         ts_params->valid_devs[0],
1882                         &ut_params->cipher_xform);
1883         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1884
1885         /* Generate Crypto op data structure */
1886         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1887                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1888         TEST_ASSERT_NOT_NULL(ut_params->op,
1889                         "Failed to allocate symmetric crypto operation struct");
1890
1891         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1892
1893         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1894
1895         /* set crypto operation source mbuf */
1896         sym_op->m_src = ut_params->ibuf;
1897
1898         /* Set operation cipher parameters */
1899         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1900                         sym_op->m_src, CIPHER_IV_LENGTH_AES_CBC);
1901         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(sym_op->m_src);
1902         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1903
1904         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1905                         CIPHER_IV_LENGTH_AES_CBC);
1906
1907         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1908         sym_op->cipher.data.length = QUOTE_512_BYTES;
1909
1910         /* Set operation authentication parameters */
1911         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1912                         sym_op->m_src, DIGEST_BYTE_LENGTH_AES_XCBC);
1913         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1914                         sym_op->m_src,
1915                         CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES);
1916         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_AES_XCBC;
1917
1918         memset(sym_op->auth.digest.data, 0, DIGEST_BYTE_LENGTH_AES_XCBC);
1919
1920         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1921         sym_op->auth.data.length = QUOTE_512_BYTES;
1922
1923
1924         /* Process crypto operation */
1925         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
1926                         ut_params->op);
1927         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to process sym crypto op");
1928
1929         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1930                         "crypto op processing failed");
1931
1932         /* Validate obuf */
1933         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1934                         rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
1935                                         uint8_t *, CIPHER_IV_LENGTH_AES_CBC),
1936                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1937                         QUOTE_512_BYTES,
1938                         "Ciphertext data not as expected");
1939
1940         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1941                         rte_pktmbuf_mtod_offset(
1942                                         ut_params->op->sym->m_src, uint8_t *,
1943                                         CIPHER_IV_LENGTH_AES_CBC +
1944                                         QUOTE_512_BYTES),
1945                         catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest,
1946                         DIGEST_BYTE_LENGTH_AES_XCBC,
1947                         "Generated digest data not as expected");
1948
1949         return TEST_SUCCESS;
1950 }
1951
1952 static int
1953 test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify(void)
1954 {
1955         struct crypto_testsuite_params *ts_params = &testsuite_params;
1956         struct crypto_unittest_params *ut_params = &unittest_params;
1957
1958         /* Generate test mbuf data and space for digest */
1959         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1960                 (const char *)catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1961                 QUOTE_512_BYTES, 0);
1962
1963         /* Setup Cipher Parameters */
1964         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1965         ut_params->cipher_xform.next = NULL;
1966
1967         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1968         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1969         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1970         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1971
1972         /* Setup HMAC Parameters */
1973         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1974         ut_params->auth_xform.next = &ut_params->cipher_xform;
1975
1976         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1977         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC;
1978         ut_params->auth_xform.auth.key.length = AES_XCBC_MAC_KEY_SZ;
1979         ut_params->auth_xform.auth.key.data = aes_cbc_hmac_aes_xcbc_key;
1980         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_AES_XCBC;
1981
1982         /* Create Crypto session*/
1983         ut_params->sess =
1984                 rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
1985                                                 &ut_params->auth_xform);
1986         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1987
1988         /* Generate Crypto op data structure */
1989         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1990                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1991         TEST_ASSERT_NOT_NULL(ut_params->op,
1992                         "Failed to allocate symmetric crypto operation struct");
1993
1994         /* Set crypto operation data parameters */
1995         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1996
1997         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1998
1999         /* set crypto operation source mbuf */
2000         sym_op->m_src = ut_params->ibuf;
2001
2002
2003         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2004                                 ut_params->ibuf, DIGEST_BYTE_LENGTH_AES_XCBC);
2005         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2006                         "no room to append digest");
2007
2008         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2009                         ut_params->ibuf, QUOTE_512_BYTES);
2010         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_AES_XCBC;
2011
2012         rte_memcpy(sym_op->auth.digest.data,
2013                         catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest,
2014                         DIGEST_BYTE_LENGTH_AES_XCBC);
2015
2016         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
2017         sym_op->auth.data.length = QUOTE_512_BYTES;
2018
2019         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2020                         ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
2021         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2022         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2023
2024         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
2025                         CIPHER_IV_LENGTH_AES_CBC);
2026
2027         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
2028         sym_op->cipher.data.length = QUOTE_512_BYTES;
2029
2030         /* Process crypto operation */
2031         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
2032                         ut_params->op), "failed to process sym crypto op");
2033
2034         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2035                         "crypto op processing failed");
2036
2037         ut_params->obuf = ut_params->op->sym->m_src;
2038
2039         /* Validate obuf */
2040         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2041                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
2042                         CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
2043                         QUOTE_512_BYTES,
2044                         "Ciphertext data not as expected");
2045
2046         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2047                         "Digest verification failed");
2048
2049         return TEST_SUCCESS;
2050 }
2051
2052 /* ***** Snow3G Tests ***** */
2053 static int
2054 create_snow3g_hash_session(uint8_t dev_id,
2055         const uint8_t *key, const uint8_t key_len,
2056         const uint8_t aad_len, const uint8_t auth_len,
2057         enum rte_crypto_auth_operation op)
2058 {
2059         uint8_t hash_key[key_len];
2060
2061         struct crypto_unittest_params *ut_params = &unittest_params;
2062
2063         memcpy(hash_key, key, key_len);
2064 #ifdef RTE_APP_TEST_DEBUG
2065         rte_hexdump(stdout, "key:", key, key_len);
2066 #endif
2067         /* Setup Authentication Parameters */
2068         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2069         ut_params->auth_xform.next = NULL;
2070
2071         ut_params->auth_xform.auth.op = op;
2072         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2073         ut_params->auth_xform.auth.key.length = key_len;
2074         ut_params->auth_xform.auth.key.data = hash_key;
2075         ut_params->auth_xform.auth.digest_length = auth_len;
2076         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
2077         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
2078                                 &ut_params->auth_xform);
2079         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2080         return 0;
2081 }
2082 static int
2083 create_snow3g_cipher_session(uint8_t dev_id,
2084                         enum rte_crypto_cipher_operation op,
2085                         const uint8_t *key, const uint8_t key_len)
2086 {
2087         uint8_t cipher_key[key_len];
2088
2089         struct crypto_unittest_params *ut_params = &unittest_params;
2090
2091         memcpy(cipher_key, key, key_len);
2092
2093         /* Setup Cipher Parameters */
2094         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2095         ut_params->cipher_xform.next = NULL;
2096
2097         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
2098         ut_params->cipher_xform.cipher.op = op;
2099         ut_params->cipher_xform.cipher.key.data = cipher_key;
2100         ut_params->cipher_xform.cipher.key.length = key_len;
2101
2102 #ifdef RTE_APP_TEST_DEBUG
2103         rte_hexdump(stdout, "key:", key, key_len);
2104 #endif
2105         /* Create Crypto session */
2106         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
2107                                                 &ut_params->
2108                                                 cipher_xform);
2109         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2110         return 0;
2111 }
2112
2113 static int
2114 create_snow3g_cipher_operation(const uint8_t *iv, const unsigned iv_len,
2115                         const unsigned cipher_len,
2116                         const unsigned cipher_offset)
2117 {
2118         struct crypto_testsuite_params *ts_params = &testsuite_params;
2119         struct crypto_unittest_params *ut_params = &unittest_params;
2120         unsigned iv_pad_len = 0;
2121
2122         /* Generate Crypto op data structure */
2123         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2124                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2125         TEST_ASSERT_NOT_NULL(ut_params->op,
2126                                 "Failed to allocate pktmbuf offload");
2127
2128         /* Set crypto operation data parameters */
2129         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2130
2131         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2132
2133         /* set crypto operation source mbuf */
2134         sym_op->m_src = ut_params->ibuf;
2135
2136         /* iv */
2137         iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2138         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf
2139                         , iv_pad_len);
2140
2141         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2142
2143         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2144         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2145         sym_op->cipher.iv.length = iv_pad_len;
2146
2147         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2148         sym_op->cipher.data.length = cipher_len;
2149         sym_op->cipher.data.offset = cipher_offset;
2150         return 0;
2151 }
2152
2153 static int
2154 create_snow3g_cipher_operation_oop(const uint8_t *iv, const unsigned iv_len,
2155                         const unsigned cipher_len,
2156                         const unsigned cipher_offset)
2157 {
2158         struct crypto_testsuite_params *ts_params = &testsuite_params;
2159         struct crypto_unittest_params *ut_params = &unittest_params;
2160         unsigned iv_pad_len = 0;
2161
2162         /* Generate Crypto op data structure */
2163         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2164                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2165         TEST_ASSERT_NOT_NULL(ut_params->op,
2166                                 "Failed to allocate pktmbuf offload");
2167
2168         /* Set crypto operation data parameters */
2169         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2170
2171         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2172
2173         /* set crypto operation source mbuf */
2174         sym_op->m_src = ut_params->ibuf;
2175         sym_op->m_dst = ut_params->obuf;
2176
2177         /* iv */
2178         iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2179         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf
2180                         , iv_pad_len);
2181
2182         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2183
2184         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2185         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2186         sym_op->cipher.iv.length = iv_pad_len;
2187
2188         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2189         sym_op->cipher.data.length = cipher_len;
2190         sym_op->cipher.data.offset = cipher_offset;
2191         return 0;
2192 }
2193
2194 static int
2195 create_snow3g_cipher_auth_session(uint8_t dev_id,
2196                 enum rte_crypto_cipher_operation cipher_op,
2197                 enum rte_crypto_auth_operation auth_op,
2198                 const uint8_t *key, const uint8_t key_len,
2199                 const uint8_t aad_len, const uint8_t auth_len)
2200 {
2201         uint8_t cipher_auth_key[key_len];
2202
2203         struct crypto_unittest_params *ut_params = &unittest_params;
2204
2205         memcpy(cipher_auth_key, key, key_len);
2206
2207         /* Setup Authentication Parameters */
2208         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2209         ut_params->auth_xform.next = NULL;
2210
2211         ut_params->auth_xform.auth.op = auth_op;
2212         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2213         ut_params->auth_xform.auth.key.length = key_len;
2214         /* Hash key = cipher key */
2215         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2216         ut_params->auth_xform.auth.digest_length = auth_len;
2217         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
2218
2219         /* Setup Cipher Parameters */
2220         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2221         ut_params->cipher_xform.next = &ut_params->auth_xform;
2222
2223         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
2224         ut_params->cipher_xform.cipher.op = cipher_op;
2225         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2226         ut_params->cipher_xform.cipher.key.length = key_len;
2227
2228 #ifdef RTE_APP_TEST_DEBUG
2229         rte_hexdump(stdout, "key:", key, key_len);
2230 #endif
2231         /* Create Crypto session*/
2232         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
2233                                 &ut_params->cipher_xform);
2234
2235         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2236         return 0;
2237 }
2238
2239 static int
2240 create_snow3g_auth_cipher_session(uint8_t dev_id,
2241                 enum rte_crypto_cipher_operation cipher_op,
2242                 enum rte_crypto_auth_operation auth_op,
2243                 const uint8_t *key, const uint8_t key_len,
2244                 const uint8_t aad_len, const uint8_t auth_len)
2245         {
2246         uint8_t auth_cipher_key[key_len];
2247
2248         struct crypto_unittest_params *ut_params = &unittest_params;
2249
2250         memcpy(auth_cipher_key, key, key_len);
2251
2252         /* Setup Authentication Parameters */
2253         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2254         ut_params->auth_xform.auth.op = auth_op;
2255         ut_params->auth_xform.next = &ut_params->cipher_xform;
2256         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2257         ut_params->auth_xform.auth.key.length = key_len;
2258         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2259         ut_params->auth_xform.auth.digest_length = auth_len;
2260         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
2261
2262         /* Setup Cipher Parameters */
2263         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2264         ut_params->cipher_xform.next = NULL;
2265         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
2266         ut_params->cipher_xform.cipher.op = cipher_op;
2267         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2268         ut_params->cipher_xform.cipher.key.length = key_len;
2269
2270 #ifdef RTE_APP_TEST_DEBUG
2271         rte_hexdump(stdout, "key:", key, key_len);
2272 #endif
2273         /* Create Crypto session*/
2274         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
2275                                 &ut_params->auth_xform);
2276
2277         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2278
2279         return 0;
2280 }
2281
2282 static int
2283 create_snow3g_hash_operation(const uint8_t *auth_tag,
2284                 const unsigned auth_tag_len,
2285                 const uint8_t *aad, const unsigned aad_len,
2286                 unsigned data_pad_len,
2287                 enum rte_crypto_auth_operation op,
2288                 const unsigned auth_len, const unsigned auth_offset)
2289 {
2290         struct crypto_testsuite_params *ts_params = &testsuite_params;
2291
2292         struct crypto_unittest_params *ut_params = &unittest_params;
2293
2294         unsigned aad_buffer_len;
2295
2296         /* Generate Crypto op data structure */
2297         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2298                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2299         TEST_ASSERT_NOT_NULL(ut_params->op,
2300                 "Failed to allocate pktmbuf offload");
2301
2302         /* Set crypto operation data parameters */
2303         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2304
2305         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2306
2307         /* set crypto operation source mbuf */
2308         sym_op->m_src = ut_params->ibuf;
2309
2310         /* aad */
2311         /*
2312         * Always allocate the aad up to the block size.
2313         * The cryptodev API calls out -
2314         *  - the array must be big enough to hold the AAD, plus any
2315         *   space to round this up to the nearest multiple of the
2316         *   block size (16 bytes).
2317         */
2318         aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2319         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
2320                         ut_params->ibuf, aad_buffer_len);
2321         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2322                                         "no room to prepend aad");
2323         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2324                         ut_params->ibuf);
2325         sym_op->auth.aad.length = aad_len;
2326
2327         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2328         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2329
2330 #ifdef RTE_APP_TEST_DEBUG
2331         rte_hexdump(stdout, "aad:",
2332                         sym_op->auth.aad.data, aad_len);
2333 #endif
2334
2335         /* digest */
2336         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2337                                         ut_params->ibuf, auth_tag_len);
2338
2339         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2340                                 "no room to append auth tag");
2341         ut_params->digest = sym_op->auth.digest.data;
2342         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2343                         ut_params->ibuf, data_pad_len + aad_len);
2344         sym_op->auth.digest.length = auth_tag_len;
2345         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2346                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2347         else
2348                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2349
2350 #ifdef RTE_APP_TEST_DEBUG
2351         rte_hexdump(stdout, "digest:",
2352                 sym_op->auth.digest.data,
2353                 sym_op->auth.digest.length);
2354 #endif
2355
2356         sym_op->auth.data.length = auth_len;
2357         sym_op->auth.data.offset = auth_offset;
2358
2359         return 0;
2360 }
2361
2362 static int
2363 create_snow3g_cipher_hash_operation(const uint8_t *auth_tag,
2364                 const unsigned auth_tag_len,
2365                 const uint8_t *aad, const uint8_t aad_len,
2366                 unsigned data_pad_len,
2367                 enum rte_crypto_auth_operation op,
2368                 const uint8_t *iv, const uint8_t iv_len,
2369                 const unsigned cipher_len, const unsigned cipher_offset,
2370                 const unsigned auth_len, const unsigned auth_offset)
2371 {
2372         struct crypto_testsuite_params *ts_params = &testsuite_params;
2373         struct crypto_unittest_params *ut_params = &unittest_params;
2374
2375         unsigned iv_pad_len = 0;
2376         unsigned aad_buffer_len;
2377
2378         /* Generate Crypto op data structure */
2379         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2380                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2381         TEST_ASSERT_NOT_NULL(ut_params->op,
2382                         "Failed to allocate pktmbuf offload");
2383         /* Set crypto operation data parameters */
2384         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2385
2386         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2387
2388         /* set crypto operation source mbuf */
2389         sym_op->m_src = ut_params->ibuf;
2390
2391
2392         /* iv */
2393         iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2394
2395         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2396                 ut_params->ibuf, iv_pad_len);
2397         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2398
2399         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2400         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2401         sym_op->cipher.iv.length = iv_pad_len;
2402
2403         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2404
2405         sym_op->cipher.data.length = cipher_len;
2406         sym_op->cipher.data.offset = cipher_offset;
2407
2408         /* aad */
2409         /*
2410         * Always allocate the aad up to the block size.
2411         * The cryptodev API calls out -
2412         *  - the array must be big enough to hold the AAD, plus any
2413         *   space to round this up to the nearest multiple of the
2414         *   block size (16 bytes).
2415         */
2416         aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2417
2418         sym_op->auth.aad.data =
2419                         (uint8_t *)rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *);
2420         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2421                         "no room to prepend aad");
2422         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2423                         ut_params->ibuf);
2424         sym_op->auth.aad.length = aad_len;
2425
2426         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2427         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2428
2429 #ifdef RTE_APP_TEST_DEBUG
2430         rte_hexdump(stdout, "aad:",
2431                         sym_op->auth.aad.data, aad_len);
2432 #endif
2433
2434         /* digest */
2435         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2436                         ut_params->ibuf, auth_tag_len);
2437
2438         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2439                         "no room to append auth tag");
2440         ut_params->digest = sym_op->auth.digest.data;
2441         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2442                         ut_params->ibuf, data_pad_len + aad_len);
2443         sym_op->auth.digest.length = auth_tag_len;
2444         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2445                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2446         else
2447                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2448
2449         #ifdef RTE_APP_TEST_DEBUG
2450         rte_hexdump(stdout, "digest:",
2451                 sym_op->auth.digest.data,
2452                 sym_op->auth.digest.length);
2453         #endif
2454
2455         sym_op->auth.data.length = auth_len;
2456         sym_op->auth.data.offset = auth_offset;
2457
2458         return 0;
2459 }
2460
2461 static int
2462 create_snow3g_auth_cipher_operation(const unsigned auth_tag_len,
2463                 const uint8_t *iv, const uint8_t iv_len,
2464                 const uint8_t *aad, const uint8_t aad_len,
2465                 unsigned data_pad_len,
2466                 const unsigned cipher_len, const unsigned cipher_offset,
2467                 const unsigned auth_len, const unsigned auth_offset)
2468 {
2469         struct crypto_testsuite_params *ts_params = &testsuite_params;
2470         struct crypto_unittest_params *ut_params = &unittest_params;
2471
2472         unsigned iv_pad_len = 0;
2473         unsigned aad_buffer_len = 0;
2474
2475         /* Generate Crypto op data structure */
2476         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2477                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2478         TEST_ASSERT_NOT_NULL(ut_params->op,
2479                         "Failed to allocate pktmbuf offload");
2480
2481         /* Set crypto operation data parameters */
2482         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2483
2484         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2485
2486         /* set crypto operation source mbuf */
2487         sym_op->m_src = ut_params->ibuf;
2488
2489         /* digest */
2490         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2491                         ut_params->ibuf, auth_tag_len);
2492
2493         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2494                         "no room to append auth tag");
2495
2496         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2497                         ut_params->ibuf, data_pad_len);
2498         sym_op->auth.digest.length = auth_tag_len;
2499
2500         memset(sym_op->auth.digest.data, 0, auth_tag_len);
2501
2502         #ifdef RTE_APP_TEST_DEBUG
2503                 rte_hexdump(stdout, "digest:",
2504                         sym_op->auth.digest.data,
2505                         sym_op->auth.digest.length);
2506         #endif
2507         /* iv */
2508         iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2509
2510         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2511                 ut_params->ibuf, iv_pad_len);
2512         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2513
2514         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2515         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2516         sym_op->cipher.iv.length = iv_pad_len;
2517
2518         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2519
2520         /* aad */
2521         /*
2522         * Always allocate the aad up to the block size.
2523         * The cryptodev API calls out -
2524         *  - the array must be big enough to hold the AAD, plus any
2525         *   space to round this up to the nearest multiple of the
2526         *   block size (16 bytes).
2527         */
2528         aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2529
2530         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
2531         ut_params->ibuf, aad_buffer_len);
2532         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2533                                 "no room to prepend aad");
2534         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2535                                 ut_params->ibuf);
2536         sym_op->auth.aad.length = aad_len;
2537
2538         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2539         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2540
2541 #ifdef RTE_APP_TEST_DEBUG
2542         rte_hexdump(stdout, "aad:",
2543                         sym_op->auth.aad.data, aad_len);
2544 #endif
2545
2546         sym_op->cipher.data.length = cipher_len;
2547         sym_op->cipher.data.offset = auth_offset + cipher_offset;
2548
2549         sym_op->auth.data.length = auth_len;
2550         sym_op->auth.data.offset = auth_offset + cipher_offset;
2551
2552         return 0;
2553 }
2554
2555 static int
2556 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2557 {
2558         struct crypto_testsuite_params *ts_params = &testsuite_params;
2559         struct crypto_unittest_params *ut_params = &unittest_params;
2560
2561         int retval;
2562         unsigned plaintext_pad_len;
2563         uint8_t *plaintext;
2564
2565         /* Create SNOW3G session */
2566         retval = create_snow3g_hash_session(ts_params->valid_devs[0],
2567                         tdata->key.data, tdata->key.len,
2568                         tdata->aad.len, tdata->digest.len,
2569                         RTE_CRYPTO_AUTH_OP_GENERATE);
2570         if (retval < 0)
2571                 return retval;
2572
2573         /* alloc mbuf and set payload */
2574         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2575
2576         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2577         rte_pktmbuf_tailroom(ut_params->ibuf));
2578
2579         /* Append data which is padded to a multiple of */
2580         /* the algorithms block size */
2581         plaintext_pad_len = tdata->plaintext.len >> 3;
2582         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2583                                 plaintext_pad_len);
2584         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3);
2585
2586         /* Create SNOW3G opertaion */
2587         retval = create_snow3g_hash_operation(NULL, tdata->digest.len,
2588                         tdata->aad.data, tdata->aad.len,
2589                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2590                         tdata->validAuthLenInBits.len,
2591                         tdata->validAuthOffsetLenInBits.len);
2592         if (retval < 0)
2593                 return retval;
2594
2595         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2596                                 ut_params->op);
2597         ut_params->obuf = ut_params->op->sym->m_src;
2598         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2599         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2600                         + plaintext_pad_len + tdata->aad.len;
2601
2602         /* Validate obuf */
2603         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2604         ut_params->digest,
2605         tdata->digest.data,
2606         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2607         "Snow3G Generated auth tag not as expected");
2608
2609         return 0;
2610 }
2611
2612 static int
2613 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2614 {
2615         struct crypto_testsuite_params *ts_params = &testsuite_params;
2616         struct crypto_unittest_params *ut_params = &unittest_params;
2617
2618         int retval;
2619         unsigned plaintext_pad_len;
2620         uint8_t *plaintext;
2621
2622         /* Create SNOW3G session */
2623         retval = create_snow3g_hash_session(ts_params->valid_devs[0],
2624                                 tdata->key.data, tdata->key.len,
2625                                 tdata->aad.len, tdata->digest.len,
2626                                 RTE_CRYPTO_AUTH_OP_VERIFY);
2627         if (retval < 0)
2628                 return retval;
2629         /* alloc mbuf and set payload */
2630         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2631
2632         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2633         rte_pktmbuf_tailroom(ut_params->ibuf));
2634
2635         /* Append data which is padded to a multiple */
2636         /* of the algorithms block size */
2637         plaintext_pad_len = tdata->plaintext.len >> 3;
2638         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2639                                         plaintext_pad_len);
2640         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3);
2641
2642         /* Create SNOW3G operation */
2643         retval = create_snow3g_hash_operation(tdata->digest.data,
2644                         tdata->digest.len,
2645                         tdata->aad.data, tdata->aad.len,
2646                         plaintext_pad_len,
2647                         RTE_CRYPTO_AUTH_OP_VERIFY,
2648                         tdata->validAuthLenInBits.len,
2649                         tdata->validAuthOffsetLenInBits.len);
2650         if (retval < 0)
2651                 return retval;
2652
2653         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2654                                 ut_params->op);
2655         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2656         ut_params->obuf = ut_params->op->sym->m_src;
2657         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2658                                 + plaintext_pad_len + tdata->aad.len;
2659
2660         /* Validate obuf */
2661         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2662                 return 0;
2663         else
2664                 return -1;
2665
2666         return 0;
2667 }
2668
2669
2670 static int
2671 test_snow3g_hash_generate_test_case_1(void)
2672 {
2673         return test_snow3g_authentication(&snow3g_hash_test_case_1);
2674 }
2675
2676 static int
2677 test_snow3g_hash_generate_test_case_2(void)
2678 {
2679         return test_snow3g_authentication(&snow3g_hash_test_case_2);
2680 }
2681
2682 static int
2683 test_snow3g_hash_generate_test_case_3(void)
2684 {
2685         return test_snow3g_authentication(&snow3g_hash_test_case_3);
2686 }
2687
2688 static int
2689 test_snow3g_hash_verify_test_case_1(void)
2690 {
2691         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
2692
2693 }
2694
2695 static int
2696 test_snow3g_hash_verify_test_case_2(void)
2697 {
2698         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
2699 }
2700
2701 static int
2702 test_snow3g_hash_verify_test_case_3(void)
2703 {
2704         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
2705 }
2706
2707 static int
2708 test_snow3g_encryption(const struct snow3g_test_data *tdata)
2709 {
2710         struct crypto_testsuite_params *ts_params = &testsuite_params;
2711         struct crypto_unittest_params *ut_params = &unittest_params;
2712
2713         int retval;
2714         uint8_t *plaintext, *ciphertext;
2715         uint8_t plaintext_pad_len;
2716         uint8_t lastByteValidBits = 8;
2717         uint8_t lastByteMask = 0xFF;
2718
2719         /* Create SNOW3G session */
2720         retval = create_snow3g_cipher_session(ts_params->valid_devs[0],
2721                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2722                                         tdata->key.data, tdata->key.len);
2723         if (retval < 0)
2724                 return retval;
2725
2726         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2727
2728         /* Clear mbuf payload */
2729         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2730                rte_pktmbuf_tailroom(ut_params->ibuf));
2731
2732         /*
2733          * Append data which is padded to a
2734          * multiple of the algorithms block size
2735          */
2736         /*tdata->plaintext.len = tdata->plaintext.len >> 3;*/
2737         plaintext_pad_len = RTE_ALIGN_CEIL((tdata->plaintext.len >> 3), 16);
2738
2739         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
2740                                                 plaintext_pad_len);
2741         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
2742
2743 #ifdef RTE_APP_TEST_DEBUG
2744         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2745 #endif
2746         /* Create SNOW3G operation */
2747         retval = create_snow3g_cipher_operation(tdata->iv.data, tdata->iv.len,
2748                                         tdata->validCipherLenInBits.len,
2749                                         tdata->validCipherOffsetLenInBits.len);
2750         if (retval < 0)
2751                 return retval;
2752
2753         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2754                                                 ut_params->op);
2755         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2756
2757         ut_params->obuf = ut_params->op->sym->m_dst;
2758         if (ut_params->obuf)
2759                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2760                                 + tdata->iv.len;
2761         else
2762                 ciphertext = plaintext;
2763
2764         lastByteValidBits = (tdata->validDataLenInBits.len % 8);
2765         if (lastByteValidBits == 0)
2766                 lastByteValidBits = 8;
2767         lastByteMask = lastByteMask << (8 - lastByteValidBits);
2768         (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask;
2769
2770 #ifdef RTE_APP_TEST_DEBUG
2771         rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
2772 #endif
2773         /* Validate obuf */
2774         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2775                 ciphertext,
2776                 tdata->ciphertext.data,
2777                 tdata->ciphertext.len >> 3,
2778                 "Snow3G Ciphertext data not as expected");
2779         return 0;
2780 }
2781
2782
2783 static int
2784 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
2785 {
2786         struct crypto_testsuite_params *ts_params = &testsuite_params;
2787         struct crypto_unittest_params *ut_params = &unittest_params;
2788         uint8_t *plaintext, *ciphertext;
2789
2790         int retval;
2791         uint8_t plaintext_pad_len;
2792         uint8_t lastByteValidBits = 8;
2793         uint8_t lastByteMask = 0xFF;
2794
2795         /* Create SNOW3G session */
2796         retval = create_snow3g_cipher_session(ts_params->valid_devs[0],
2797                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2798                                         tdata->key.data, tdata->key.len);
2799         if (retval < 0)
2800                 return retval;
2801
2802         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2803         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2804
2805         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2806                         "Failed to allocate input buffer in mempool");
2807         TEST_ASSERT_NOT_NULL(ut_params->obuf,
2808                         "Failed to allocate output buffer in mempool");
2809
2810         /* Clear mbuf payload */
2811         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2812                rte_pktmbuf_tailroom(ut_params->ibuf));
2813
2814         /*
2815          * Append data which is padded to a
2816          * multiple of the algorithms block size
2817          */
2818         /*tdata->plaintext.len = tdata->plaintext.len >> 3;*/
2819         plaintext_pad_len = RTE_ALIGN_CEIL((tdata->plaintext.len >> 3), 16);
2820
2821         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
2822                                                 plaintext_pad_len);
2823
2824         rte_pktmbuf_append(ut_params->obuf,
2825                                                 plaintext_pad_len);
2826
2827         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
2828
2829 #ifdef RTE_APP_TEST_DEBUG
2830         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2831 #endif
2832         /* Create SNOW3G operation */
2833         retval = create_snow3g_cipher_operation_oop(tdata->iv.data,
2834                                         tdata->iv.len,
2835                                         tdata->validCipherLenInBits.len,
2836                                         tdata->validCipherOffsetLenInBits.len);
2837         if (retval < 0)
2838                 return retval;
2839
2840         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2841                                                 ut_params->op);
2842         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2843
2844         ut_params->obuf = ut_params->op->sym->m_dst;
2845         if (ut_params->obuf)
2846                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2847                                 + tdata->iv.len;
2848         else
2849                 ciphertext = plaintext;
2850
2851         lastByteValidBits = (tdata->validDataLenInBits.len % 8);
2852         if (lastByteValidBits == 0)
2853                 lastByteValidBits = 8;
2854         lastByteMask = lastByteMask << (8 - lastByteValidBits);
2855         (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask;
2856
2857 #ifdef RTE_APP_TEST_DEBUG
2858         rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
2859 #endif
2860         /* Validate obuf */
2861         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2862                 ciphertext,
2863                 tdata->ciphertext.data,
2864                 tdata->ciphertext.len >> 3,
2865                 "Snow3G Ciphertext data not as expected");
2866         return 0;
2867 }
2868
2869
2870 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
2871 {
2872         struct crypto_testsuite_params *ts_params = &testsuite_params;
2873         struct crypto_unittest_params *ut_params = &unittest_params;
2874
2875         int retval;
2876
2877         uint8_t *plaintext, *ciphertext;
2878         uint8_t ciphertext_pad_len;
2879         uint8_t lastByteValidBits = 8;
2880         uint8_t lastByteMask = 0xFF;
2881
2882         /* Create SNOW3G session */
2883         retval = create_snow3g_cipher_session(ts_params->valid_devs[0],
2884                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
2885                                         tdata->key.data, tdata->key.len);
2886         if (retval < 0)
2887                 return retval;
2888
2889         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2890
2891         /* Clear mbuf payload */
2892         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2893                rte_pktmbuf_tailroom(ut_params->ibuf));
2894
2895         /*
2896          * Append data which is padded to a
2897          * multiple of the algorithms block size
2898          */
2899         ciphertext_pad_len = RTE_ALIGN_CEIL((tdata->ciphertext.len >> 3), 16);
2900
2901         ciphertext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
2902                                                 ciphertext_pad_len);
2903         memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len >> 3);
2904
2905 #ifdef RTE_APP_TEST_DEBUG
2906         rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
2907 #endif
2908         /* Create SNOW3G operation */
2909         retval = create_snow3g_cipher_operation(tdata->iv.data, tdata->iv.len,
2910                                         tdata->validCipherLenInBits.len,
2911                                         tdata->validCipherOffsetLenInBits.len);
2912         if (retval < 0)
2913                 return retval;
2914
2915         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2916                                                 ut_params->op);
2917         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2918         ut_params->obuf = ut_params->op->sym->m_src;
2919         if (ut_params->obuf)
2920                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2921                                 + tdata->iv.len;
2922         else
2923                 plaintext = ciphertext;
2924         lastByteValidBits = (tdata->validDataLenInBits.len  % 8);
2925         if (lastByteValidBits == 0)
2926                 lastByteValidBits = 8;
2927         lastByteMask = lastByteMask << (8 - lastByteValidBits);
2928         (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask;
2929
2930 #ifdef RTE_APP_TEST_DEBUG
2931         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2932 #endif
2933         /* Validate obuf */
2934         TEST_ASSERT_BUFFERS_ARE_EQUAL(plaintext,
2935                                 tdata->plaintext.data,
2936                                 tdata->plaintext.len >> 3,
2937                                 "Snow3G Plaintext data not as expected");
2938         return 0;
2939 }
2940
2941 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
2942 {
2943         struct crypto_testsuite_params *ts_params = &testsuite_params;
2944         struct crypto_unittest_params *ut_params = &unittest_params;
2945
2946         int retval;
2947
2948         uint8_t *plaintext, *ciphertext;
2949         uint8_t ciphertext_pad_len;
2950         uint8_t lastByteValidBits = 8;
2951         uint8_t lastByteMask = 0xFF;
2952
2953         /* Create SNOW3G session */
2954         retval = create_snow3g_cipher_session(ts_params->valid_devs[0],
2955                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
2956                                         tdata->key.data, tdata->key.len);
2957         if (retval < 0)
2958                 return retval;
2959
2960         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2961         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2962
2963         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2964                         "Failed to allocate input buffer");
2965         TEST_ASSERT_NOT_NULL(ut_params->obuf,
2966                         "Failed to allocate output buffer");
2967
2968         /* Clear mbuf payload */
2969         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2970                rte_pktmbuf_tailroom(ut_params->ibuf));
2971
2972         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
2973                        rte_pktmbuf_tailroom(ut_params->obuf));
2974
2975         /*
2976          * Append data which is padded to a
2977          * multiple of the algorithms block size
2978          */
2979         ciphertext_pad_len = RTE_ALIGN_CEIL((tdata->ciphertext.len >> 3), 16);
2980
2981         ciphertext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
2982                                                 ciphertext_pad_len);
2983
2984         rte_pktmbuf_append(ut_params->obuf,
2985                                                 ciphertext_pad_len);
2986
2987         memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len >> 3);
2988
2989 #ifdef RTE_APP_TEST_DEBUG
2990         rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
2991 #endif
2992         /* Create SNOW3G operation */
2993         retval = create_snow3g_cipher_operation_oop(tdata->iv.data,
2994                                         tdata->iv.len,
2995                                         tdata->validCipherLenInBits.len,
2996                                         tdata->validCipherOffsetLenInBits.len);
2997         if (retval < 0)
2998                 return retval;
2999
3000         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3001                                                 ut_params->op);
3002         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3003         ut_params->obuf = ut_params->op->sym->m_dst;
3004         if (ut_params->obuf)
3005                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3006                                 + tdata->iv.len;
3007         else
3008                 plaintext = ciphertext;
3009         lastByteValidBits = (tdata->validDataLenInBits.len  % 8);
3010         if (lastByteValidBits == 0)
3011                 lastByteValidBits = 8;
3012         lastByteMask = lastByteMask << (8 - lastByteValidBits);
3013         (*(plaintext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask;
3014
3015 #ifdef RTE_APP_TEST_DEBUG
3016         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3017 #endif
3018         /* Validate obuf */
3019         TEST_ASSERT_BUFFERS_ARE_EQUAL(plaintext,
3020                                 tdata->plaintext.data,
3021                                 tdata->plaintext.len >> 3,
3022                                 "Snow3G Plaintext data not as expected");
3023         return 0;
3024 }
3025
3026 static int
3027 test_snow3g_authenticated_encryption(const struct snow3g_test_data *tdata)
3028 {
3029         struct crypto_testsuite_params *ts_params = &testsuite_params;
3030         struct crypto_unittest_params *ut_params = &unittest_params;
3031
3032         int retval;
3033
3034         uint8_t *plaintext, *ciphertext;
3035         uint8_t plaintext_pad_len;
3036         uint8_t lastByteValidBits = 8;
3037         uint8_t lastByteMask = 0xFF;
3038
3039         /* Create SNOW3G session */
3040         retval = create_snow3g_cipher_auth_session(ts_params->valid_devs[0],
3041                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3042                         RTE_CRYPTO_AUTH_OP_GENERATE,
3043                         tdata->key.data, tdata->key.len,
3044                         tdata->aad.len, tdata->digest.len);
3045         if (retval < 0)
3046                 return retval;
3047         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3048
3049         /* clear mbuf payload */
3050         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3051                         rte_pktmbuf_tailroom(ut_params->ibuf));
3052
3053         /* Append data which is padded to a multiple */
3054         /*  of the algorithms block size */
3055         plaintext_pad_len = tdata->plaintext.len >> 3;
3056
3057         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3058                         plaintext_pad_len);
3059         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3);
3060
3061 #ifdef RTE_APP_TEST_DEBUG
3062         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3063 #endif
3064
3065         /* Create SNOW3G operation */
3066         retval = create_snow3g_cipher_hash_operation(tdata->digest.data,
3067                         tdata->digest.len, tdata->aad.data,
3068                         tdata->aad.len, /*tdata->plaintext.len,*/
3069                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3070                         tdata->iv.data, tdata->iv.len,
3071                         tdata->validCipherLenInBits.len,
3072                         tdata->validCipherOffsetLenInBits.len,
3073                         tdata->validAuthLenInBits.len,
3074                         tdata->validAuthOffsetLenInBits.len);
3075         if (retval < 0)
3076                 return retval;
3077
3078         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3079                         ut_params->op);
3080         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3081         ut_params->obuf = ut_params->op->sym->m_src;
3082         if (ut_params->obuf)
3083                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3084                                 + tdata->iv.len;
3085         else
3086                 ciphertext = plaintext;
3087         lastByteValidBits = (tdata->validDataLenInBits.len % 8);
3088         if (lastByteValidBits == 0)
3089                 lastByteValidBits = 8;
3090         lastByteMask = lastByteMask << (8-lastByteValidBits);
3091         (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask;
3092
3093 #ifdef RTE_APP_TEST_DEBUG
3094         rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
3095 #endif
3096         /* Validate obuf */
3097         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3098                         ciphertext,
3099                         tdata->ciphertext.data,
3100                         tdata->ciphertext.len >> 3,
3101                         "Snow3G Ciphertext data not as expected");
3102
3103         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3104             + plaintext_pad_len + tdata->aad.len;
3105
3106         /* Validate obuf */
3107         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3108                         ut_params->digest,
3109                         tdata->digest.data,
3110                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3111                         "Snow3G Generated auth tag not as expected");
3112         return 0;
3113 }
3114 static int
3115 test_snow3g_encrypted_authentication(const struct snow3g_test_data *tdata)
3116 {
3117         struct crypto_testsuite_params *ts_params = &testsuite_params;
3118         struct crypto_unittest_params *ut_params = &unittest_params;
3119
3120         int retval;
3121
3122         uint8_t *plaintext, *ciphertext;
3123         uint8_t plaintext_pad_len;
3124         uint8_t lastByteValidBits = 8;
3125         uint8_t lastByteMask = 0xFF;
3126
3127         /* Create SNOW3G session */
3128         retval = create_snow3g_auth_cipher_session(ts_params->valid_devs[0],
3129                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3130                         RTE_CRYPTO_AUTH_OP_GENERATE,
3131                         tdata->key.data, tdata->key.len,
3132                         tdata->aad.len, tdata->digest.len);
3133         if (retval < 0)
3134                 return retval;
3135
3136         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3137
3138         /* clear mbuf payload */
3139         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3140                         rte_pktmbuf_tailroom(ut_params->ibuf));
3141
3142         /* Append data which is padded to a multiple */
3143         /* of the algorithms block size */
3144         plaintext_pad_len = RTE_ALIGN_CEIL((tdata->plaintext.len >> 3), 8);
3145
3146         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3147                         plaintext_pad_len);
3148         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3);
3149
3150 #ifdef RTE_APP_TEST_DEBUG
3151         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3152 #endif
3153
3154         /* Create SNOW3G operation */
3155         retval = create_snow3g_auth_cipher_operation(
3156                 tdata->digest.len,
3157                 tdata->iv.data, tdata->iv.len,
3158                 tdata->aad.data, tdata->aad.len,
3159                 plaintext_pad_len,
3160                 tdata->validCipherLenInBits.len,
3161                 tdata->validCipherOffsetLenInBits.len,
3162                 tdata->validAuthLenInBits.len,
3163                 tdata->validAuthOffsetLenInBits.len
3164         );
3165
3166         if (retval < 0)
3167                 return retval;
3168
3169         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3170                         ut_params->op);
3171         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3172         ut_params->obuf = ut_params->op->sym->m_src;
3173         if (ut_params->obuf)
3174                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3175                                 + tdata->aad.len + tdata->iv.len;
3176         else
3177                 ciphertext = plaintext;
3178
3179         lastByteValidBits = (tdata->validDataLenInBits.len % 8);
3180         if (lastByteValidBits == 0)
3181                 lastByteValidBits = 8;
3182         lastByteMask = lastByteMask << (8-lastByteValidBits);
3183         (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask;
3184         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3185                         + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3186         #ifdef RTE_APP_TEST_DEBUG
3187         rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
3188 #endif
3189         /* Validate obuf */
3190         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3191                 ciphertext,
3192                 tdata->ciphertext.data,
3193                 tdata->ciphertext.len >> 3,
3194                 "Snow3G Ciphertext data not as expected");
3195
3196         /* Validate obuf */
3197         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3198                 ut_params->digest,
3199                 tdata->digest.data,
3200                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3201                 "Snow3G Generated auth tag not as expected");
3202         return 0;
3203 }
3204
3205 static int
3206 test_snow3g_encryption_test_case_1(void)
3207 {
3208         return test_snow3g_encryption(&snow3g_test_case_1);
3209 }
3210
3211 static int
3212 test_snow3g_encryption_test_case_1_oop(void)
3213 {
3214         return test_snow3g_encryption_oop(&snow3g_test_case_1);
3215 }
3216
3217 static int
3218 test_snow3g_encryption_test_case_2(void)
3219 {
3220         return test_snow3g_encryption(&snow3g_test_case_2);
3221 }
3222
3223 static int
3224 test_snow3g_encryption_test_case_3(void)
3225 {
3226         return test_snow3g_encryption(&snow3g_test_case_3);
3227 }
3228
3229 static int
3230 test_snow3g_encryption_test_case_4(void)
3231 {
3232         return test_snow3g_encryption(&snow3g_test_case_4);
3233 }
3234
3235 static int
3236 test_snow3g_encryption_test_case_5(void)
3237 {
3238         return test_snow3g_encryption(&snow3g_test_case_5);
3239 }
3240
3241 static int
3242 test_snow3g_decryption_test_case_1(void)
3243 {
3244         return test_snow3g_decryption(&snow3g_test_case_1);
3245 }
3246
3247 static int
3248 test_snow3g_decryption_test_case_1_oop(void)
3249 {
3250         return test_snow3g_decryption_oop(&snow3g_test_case_1);
3251 }
3252
3253 static int
3254 test_snow3g_decryption_test_case_2(void)
3255 {
3256         return test_snow3g_decryption(&snow3g_test_case_2);
3257 }
3258
3259 static int
3260 test_snow3g_decryption_test_case_3(void)
3261 {
3262         return test_snow3g_decryption(&snow3g_test_case_3);
3263 }
3264
3265 static int
3266 test_snow3g_decryption_test_case_4(void)
3267 {
3268         return test_snow3g_decryption(&snow3g_test_case_4);
3269 }
3270
3271 static int
3272 test_snow3g_decryption_test_case_5(void)
3273 {
3274         return test_snow3g_decryption(&snow3g_test_case_5);
3275 }
3276 static int
3277 test_snow3g_authenticated_encryption_test_case_1(void)
3278 {
3279         return test_snow3g_authenticated_encryption(&snow3g_test_case_3);
3280 }
3281
3282 static int
3283 test_snow3g_encrypted_authentication_test_case_1(void)
3284 {
3285         return test_snow3g_encrypted_authentication(&snow3g_test_case_6);
3286 }
3287
3288 /* ***** AES-GCM Tests ***** */
3289
3290 static int
3291 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
3292                 const uint8_t *key, const uint8_t key_len,
3293                 const uint8_t aad_len, const uint8_t auth_len)
3294 {
3295         uint8_t cipher_key[key_len];
3296
3297         struct crypto_unittest_params *ut_params = &unittest_params;
3298
3299
3300         memcpy(cipher_key, key, key_len);
3301
3302         /* Setup Cipher Parameters */
3303         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3304         ut_params->cipher_xform.next = NULL;
3305
3306         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
3307         ut_params->cipher_xform.cipher.op = op;
3308         ut_params->cipher_xform.cipher.key.data = cipher_key;
3309         ut_params->cipher_xform.cipher.key.length = key_len;
3310
3311 #ifdef RTE_APP_TEST_DEBUG
3312         rte_hexdump(stdout, "key:", key, key_len);
3313 #endif
3314         /* Setup Authentication Parameters */
3315         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3316         ut_params->auth_xform.next = NULL;
3317
3318         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
3319
3320         ut_params->auth_xform.auth.digest_length = auth_len;
3321         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
3322         ut_params->auth_xform.auth.key.length = 0;
3323         ut_params->auth_xform.auth.key.data = NULL;
3324
3325         if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
3326                 ut_params->cipher_xform.next = &ut_params->auth_xform;
3327
3328                 /* Create Crypto session*/
3329                 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3330                                 &ut_params->cipher_xform);
3331         } else {/* Create Crypto session*/
3332                 ut_params->auth_xform.next = &ut_params->cipher_xform;
3333                 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3334                                 &ut_params->auth_xform);
3335         }
3336
3337         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3338
3339         return 0;
3340 }
3341
3342 static int
3343 create_gcm_operation(enum rte_crypto_cipher_operation op,
3344                 const uint8_t *auth_tag, const unsigned auth_tag_len,
3345                 const uint8_t *iv, const unsigned iv_len,
3346                 const uint8_t *aad, const unsigned aad_len,
3347                 const unsigned data_len, unsigned data_pad_len)
3348 {
3349         struct crypto_testsuite_params *ts_params = &testsuite_params;
3350         struct crypto_unittest_params *ut_params = &unittest_params;
3351
3352         unsigned iv_pad_len = 0, aad_buffer_len;
3353
3354         /* Generate Crypto op data structure */
3355         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3356                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3357         TEST_ASSERT_NOT_NULL(ut_params->op,
3358                         "Failed to allocate symmetric crypto operation struct");
3359
3360         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3361
3362
3363
3364         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
3365                         ut_params->ibuf, auth_tag_len);
3366         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
3367                         "no room to append digest");
3368         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
3369                         ut_params->ibuf, data_pad_len);
3370         sym_op->auth.digest.length = auth_tag_len;
3371
3372         if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
3373                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3374 #ifdef RTE_APP_TEST_DEBUG
3375                 rte_hexdump(stdout, "digest:",
3376                                 ut_params->op->digest.data,
3377                                 ut_params->op->digest.length);
3378 #endif
3379         }
3380
3381         /* iv */
3382         iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
3383
3384         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
3385                         ut_params->ibuf, iv_pad_len);
3386         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
3387
3388         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
3389         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
3390         sym_op->cipher.iv.length = iv_pad_len;
3391
3392         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
3393
3394         /* CalcY0 */
3395         if (iv_len != 16)
3396                 sym_op->cipher.iv.data[15] = 1;
3397
3398         /*
3399          * Always allocate the aad up to the block size.
3400          * The cryptodev API calls out -
3401          *  - the array must be big enough to hold the AAD, plus any
3402          *   space to round this up to the nearest multiple of the
3403          *   block size (16 bytes).
3404          */
3405         aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
3406
3407         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
3408                         ut_params->ibuf, aad_buffer_len);
3409         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
3410                         "no room to prepend aad");
3411         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
3412                         ut_params->ibuf);
3413         sym_op->auth.aad.length = aad_len;
3414
3415         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
3416         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
3417
3418 #ifdef RTE_APP_TEST_DEBUG
3419         rte_hexdump(stdout, "iv:", ut_params->op->iv.data, iv_pad_len);
3420         rte_hexdump(stdout, "aad:",
3421                         ut_params->op->additional_auth.data, aad_len);
3422 #endif
3423         sym_op->cipher.data.length = data_len;
3424         sym_op->cipher.data.offset = aad_buffer_len + iv_pad_len;
3425
3426         sym_op->auth.data.offset = aad_buffer_len + iv_pad_len;
3427         sym_op->auth.data.length = data_len;
3428
3429         return 0;
3430 }
3431
3432 static int
3433 test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
3434 {
3435         struct crypto_testsuite_params *ts_params = &testsuite_params;
3436         struct crypto_unittest_params *ut_params = &unittest_params;
3437
3438         int retval;
3439
3440         uint8_t *plaintext, *ciphertext, *auth_tag;
3441         uint16_t plaintext_pad_len;
3442
3443         /* Create GCM session */
3444         retval = create_gcm_session(ts_params->valid_devs[0],
3445                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3446                         tdata->key.data, tdata->key.len,
3447                         tdata->aad.len, tdata->auth_tag.len);
3448         if (retval < 0)
3449                 return retval;
3450
3451
3452         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3453
3454         /* clear mbuf payload */
3455         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3456                         rte_pktmbuf_tailroom(ut_params->ibuf));
3457
3458         /*
3459          * Append data which is padded to a multiple
3460          * of the algorithms block size
3461          */
3462         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
3463
3464         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3465                         plaintext_pad_len);
3466         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
3467
3468 #ifdef RTE_APP_TEST_DEBUG
3469         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3470 #endif
3471         /* Create GCM opertaion */
3472         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3473                         tdata->auth_tag.data, tdata->auth_tag.len,
3474                         tdata->iv.data, tdata->iv.len,
3475                         tdata->aad.data, tdata->aad.len,
3476                         tdata->plaintext.len, plaintext_pad_len);
3477         if (retval < 0)
3478                 return retval;
3479
3480         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3481
3482         ut_params->op->sym->m_src = ut_params->ibuf;
3483
3484         /* Process crypto operation */
3485         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
3486                         ut_params->op), "failed to process sym crypto op");
3487
3488         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3489                         "crypto op processing failed");
3490
3491         if (ut_params->op->sym->m_dst) {
3492                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
3493                                 uint8_t *);
3494                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
3495                                 uint8_t *, plaintext_pad_len);
3496         } else {
3497                 ciphertext = plaintext;
3498                 auth_tag = plaintext + plaintext_pad_len;
3499         }
3500
3501 #ifdef RTE_APP_TEST_DEBUG
3502         rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
3503         rte_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
3504 #endif
3505         /* Validate obuf */
3506         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3507                         ciphertext,
3508                         tdata->ciphertext.data,
3509                         tdata->ciphertext.len,
3510                         "GCM Ciphertext data not as expected");
3511
3512         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3513                         auth_tag,
3514                         tdata->auth_tag.data,
3515                         tdata->auth_tag.len,
3516                         "GCM Generated auth tag not as expected");
3517
3518         return 0;
3519
3520 }
3521
3522 static int
3523 test_mb_AES_GCM_authenticated_encryption_test_case_1(void)
3524 {
3525         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1);
3526 }
3527
3528 static int
3529 test_mb_AES_GCM_authenticated_encryption_test_case_2(void)
3530 {
3531         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2);
3532 }
3533
3534 static int
3535 test_mb_AES_GCM_authenticated_encryption_test_case_3(void)
3536 {
3537         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3);
3538 }
3539
3540 static int
3541 test_mb_AES_GCM_authenticated_encryption_test_case_4(void)
3542 {
3543         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4);
3544 }
3545
3546 static int
3547 test_mb_AES_GCM_authenticated_encryption_test_case_5(void)
3548 {
3549         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5);
3550 }
3551
3552 static int
3553 test_mb_AES_GCM_authenticated_encryption_test_case_6(void)
3554 {
3555         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6);
3556 }
3557
3558 static int
3559 test_mb_AES_GCM_authenticated_encryption_test_case_7(void)
3560 {
3561         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7);
3562 }
3563
3564 static int
3565 test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
3566 {
3567         struct crypto_testsuite_params *ts_params = &testsuite_params;
3568         struct crypto_unittest_params *ut_params = &unittest_params;
3569
3570         int retval;
3571
3572         uint8_t *plaintext, *ciphertext;
3573         uint16_t ciphertext_pad_len;
3574
3575         /* Create GCM session */
3576         retval = create_gcm_session(ts_params->valid_devs[0],
3577                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3578                         tdata->key.data, tdata->key.len,
3579                         tdata->aad.len, tdata->auth_tag.len);
3580         if (retval < 0)
3581                 return retval;
3582
3583
3584         /* alloc mbuf and set payload */
3585         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3586
3587         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3588                         rte_pktmbuf_tailroom(ut_params->ibuf));
3589
3590         ciphertext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
3591
3592         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3593                         ciphertext_pad_len);
3594         memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len);
3595
3596 #ifdef RTE_APP_TEST_DEBUG
3597         rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
3598 #endif
3599         /* Create GCM opertaion */
3600         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT,
3601                         tdata->auth_tag.data, tdata->auth_tag.len,
3602                         tdata->iv.data, tdata->iv.len,
3603                         tdata->aad.data, tdata->aad.len,
3604                         tdata->ciphertext.len, ciphertext_pad_len);
3605         if (retval < 0)
3606                 return retval;
3607
3608
3609         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3610
3611         ut_params->op->sym->m_src = ut_params->ibuf;
3612
3613         /* Process crypto operation */
3614         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
3615                         ut_params->op), "failed to process sym crypto op");
3616
3617         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3618                         "crypto op processing failed");
3619
3620         if (ut_params->op->sym->m_dst)
3621                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
3622                                 uint8_t *);
3623         else
3624                 plaintext = ciphertext;
3625
3626 #ifdef RTE_APP_TEST_DEBUG
3627         rte_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
3628 #endif
3629         /* Validate obuf */
3630         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3631                         plaintext,
3632                         tdata->plaintext.data,
3633                         tdata->plaintext.len,
3634                         "GCM plaintext data not as expected");
3635
3636         TEST_ASSERT_EQUAL(ut_params->op->status,
3637                         RTE_CRYPTO_OP_STATUS_SUCCESS,
3638                         "GCM authentication failed");
3639         return 0;
3640 }
3641
3642 static int
3643 test_mb_AES_GCM_authenticated_decryption_test_case_1(void)
3644 {
3645         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1);
3646 }
3647
3648 static int
3649 test_mb_AES_GCM_authenticated_decryption_test_case_2(void)
3650 {
3651         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2);
3652 }
3653
3654 static int
3655 test_mb_AES_GCM_authenticated_decryption_test_case_3(void)
3656 {
3657         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3);
3658 }
3659
3660 static int
3661 test_mb_AES_GCM_authenticated_decryption_test_case_4(void)
3662 {
3663         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4);
3664 }
3665
3666 static int
3667 test_mb_AES_GCM_authenticated_decryption_test_case_5(void)
3668 {
3669         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5);
3670 }
3671
3672 static int
3673 test_mb_AES_GCM_authenticated_decryption_test_case_6(void)
3674 {
3675         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6);
3676 }
3677
3678 static int
3679 test_mb_AES_GCM_authenticated_decryption_test_case_7(void)
3680 {
3681         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7);
3682 }
3683
3684 static int
3685 test_stats(void)
3686 {
3687         struct crypto_testsuite_params *ts_params = &testsuite_params;
3688         struct rte_cryptodev_stats stats;
3689         struct rte_cryptodev *dev;
3690         cryptodev_stats_get_t temp_pfn;
3691
3692         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
3693         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
3694                         &stats) == -ENODEV),
3695                 "rte_cryptodev_stats_get invalid dev failed");
3696         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
3697                 "rte_cryptodev_stats_get invalid Param failed");
3698         dev = &rte_cryptodevs[ts_params->valid_devs[0]];
3699         temp_pfn = dev->dev_ops->stats_get;
3700         dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
3701         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
3702                         == -ENOTSUP),
3703                 "rte_cryptodev_stats_get invalid Param failed");
3704         dev->dev_ops->stats_get = temp_pfn;
3705
3706         /* Test expected values */
3707         ut_setup();
3708         test_AES_CBC_HMAC_SHA1_encrypt_digest();
3709         ut_teardown();
3710         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
3711                         &stats),
3712                 "rte_cryptodev_stats_get failed");
3713         TEST_ASSERT((stats.enqueued_count == 1),
3714                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3715         TEST_ASSERT((stats.dequeued_count == 1),
3716                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3717         TEST_ASSERT((stats.enqueue_err_count == 0),
3718                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3719         TEST_ASSERT((stats.dequeue_err_count == 0),
3720                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3721
3722         /* invalid device but should ignore and not reset device stats*/
3723         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
3724         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
3725                         &stats),
3726                 "rte_cryptodev_stats_get failed");
3727         TEST_ASSERT((stats.enqueued_count == 1),
3728                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3729
3730         /* check that a valid reset clears stats */
3731         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
3732         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
3733                         &stats),
3734                                           "rte_cryptodev_stats_get failed");
3735         TEST_ASSERT((stats.enqueued_count == 0),
3736                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3737         TEST_ASSERT((stats.dequeued_count == 0),
3738                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3739
3740         return TEST_SUCCESS;
3741 }
3742
3743
3744 static int
3745 test_multi_session(void)
3746 {
3747         struct crypto_testsuite_params *ts_params = &testsuite_params;
3748         struct crypto_unittest_params *ut_params = &unittest_params;
3749
3750         struct rte_cryptodev_info dev_info;
3751         struct rte_cryptodev_sym_session **sessions;
3752
3753         uint16_t i;
3754
3755         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params);
3756
3757
3758         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3759
3760         sessions = rte_malloc(NULL,
3761                         (sizeof(struct rte_cryptodev_sym_session *) *
3762                         dev_info.sym.max_nb_sessions) + 1, 0);
3763
3764         /* Create multiple crypto sessions*/
3765         for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
3766                 sessions[i] = rte_cryptodev_sym_session_create(
3767                                 ts_params->valid_devs[0],
3768                         &ut_params->auth_xform);
3769                 TEST_ASSERT_NOT_NULL(sessions[i],
3770                                 "Session creation failed at session number %u",
3771                                 i);
3772
3773                 /* Attempt to send a request on each session */
3774                 TEST_ASSERT_SUCCESS(test_AES_CBC_HMAC_SHA512_decrypt_perform(
3775                                 sessions[i], ut_params, ts_params),
3776                                 "Failed to perform decrypt on request "
3777                                 "number %u.", i);
3778                 /* free crypto operation structure */
3779                 if (ut_params->op)
3780                         rte_crypto_op_free(ut_params->op);
3781
3782                 /*
3783                  * free mbuf - both obuf and ibuf are usually the same,
3784                  * but rte copes even if we call free twice
3785                  */
3786                 if (ut_params->obuf) {
3787                         rte_pktmbuf_free(ut_params->obuf);
3788                         ut_params->obuf = 0;
3789                 }
3790         }
3791
3792         /* Next session create should fail */
3793         sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
3794                         &ut_params->auth_xform);
3795         TEST_ASSERT_NULL(sessions[i],
3796                         "Session creation succeeded unexpectedly!");
3797
3798         for (i = 0; i < dev_info.sym.max_nb_sessions; i++)
3799                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
3800                                 sessions[i]);
3801
3802         rte_free(sessions);
3803
3804         return TEST_SUCCESS;
3805 }
3806
3807 static int
3808 test_not_in_place_crypto(void)
3809 {
3810         struct crypto_testsuite_params *ts_params = &testsuite_params;
3811         struct crypto_unittest_params *ut_params = &unittest_params;
3812         struct rte_mbuf *dst_m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3813
3814         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params);
3815
3816         /* Create multiple crypto sessions*/
3817
3818         ut_params->sess = rte_cryptodev_sym_session_create(
3819                         ts_params->valid_devs[0], &ut_params->auth_xform);
3820
3821         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3822
3823
3824         /* Generate test mbuf data and digest */
3825         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
3826                         (const char *)
3827                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
3828                         QUOTE_512_BYTES, 0);
3829
3830         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3831                         DIGEST_BYTE_LENGTH_SHA512);
3832         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
3833
3834         rte_memcpy(ut_params->digest,
3835                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
3836                         DIGEST_BYTE_LENGTH_SHA512);
3837
3838         /* Generate Crypto op data structure */
3839         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3840                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3841         TEST_ASSERT_NOT_NULL(ut_params->op,
3842                         "Failed to allocate symmetric crypto operation struct");
3843
3844
3845         /* Set crypto operation data parameters */
3846         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3847
3848         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3849
3850         /* set crypto operation source mbuf */
3851         sym_op->m_src = ut_params->ibuf;
3852         sym_op->m_dst = dst_m;
3853
3854         sym_op->auth.digest.data = ut_params->digest;
3855         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
3856                         ut_params->ibuf, QUOTE_512_BYTES);
3857         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
3858
3859         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
3860         sym_op->auth.data.length = QUOTE_512_BYTES;
3861
3862
3863         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
3864                         ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
3865         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
3866                         ut_params->ibuf, 0);
3867         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
3868
3869         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
3870                         CIPHER_IV_LENGTH_AES_CBC);
3871
3872         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
3873         sym_op->cipher.data.length = QUOTE_512_BYTES;
3874
3875         /* Process crypto operation */
3876         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3877                         ut_params->op);
3878         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
3879
3880         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3881                         "crypto operation processing failed");
3882
3883         /* Validate obuf */
3884         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3885                         rte_pktmbuf_mtod(ut_params->op->sym->m_dst, char *),
3886                         catch_22_quote,
3887                         QUOTE_512_BYTES,
3888                         "Plaintext data not as expected");
3889
3890         return TEST_SUCCESS;
3891 }
3892
3893 static int
3894 test_null_cipher_only_operation(void)
3895 {
3896         struct crypto_testsuite_params *ts_params = &testsuite_params;
3897         struct crypto_unittest_params *ut_params = &unittest_params;
3898
3899         /* Generate test mbuf data and space for digest */
3900         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
3901                         catch_22_quote, QUOTE_512_BYTES, 0);
3902
3903         /* Setup Cipher Parameters */
3904         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3905         ut_params->cipher_xform.next = NULL;
3906
3907         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
3908         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
3909
3910         /* Create Crypto session*/
3911         ut_params->sess = rte_cryptodev_sym_session_create(
3912                         ts_params->valid_devs[0], &ut_params->cipher_xform);
3913         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3914
3915         /* Generate Crypto op data structure */
3916         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3917                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3918         TEST_ASSERT_NOT_NULL(ut_params->op,
3919                         "Failed to allocate symmetric crypto operation struct");
3920
3921         /* Set crypto operation data parameters */
3922         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3923
3924         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3925
3926         /* set crypto operation source mbuf */
3927         sym_op->m_src = ut_params->ibuf;
3928
3929         sym_op->cipher.data.offset = 0;
3930         sym_op->cipher.data.length = QUOTE_512_BYTES;
3931
3932         /* Process crypto operation */
3933         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3934                         ut_params->op);
3935         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
3936
3937         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3938                         "crypto operation processing failed");
3939
3940         /* Validate obuf */
3941         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3942                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
3943                         catch_22_quote,
3944                         QUOTE_512_BYTES,
3945                         "Ciphertext data not as expected");
3946
3947         return TEST_SUCCESS;
3948 }
3949
3950 static int
3951 test_null_auth_only_operation(void)
3952 {
3953         struct crypto_testsuite_params *ts_params = &testsuite_params;
3954         struct crypto_unittest_params *ut_params = &unittest_params;
3955
3956         /* Generate test mbuf data and space for digest */
3957         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
3958                         catch_22_quote, QUOTE_512_BYTES, 0);
3959
3960         /* Setup HMAC Parameters */
3961         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3962         ut_params->auth_xform.next = NULL;
3963
3964         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
3965         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
3966
3967         /* Create Crypto session*/
3968         ut_params->sess = rte_cryptodev_sym_session_create(
3969                         ts_params->valid_devs[0], &ut_params->auth_xform);
3970         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3971
3972         /* Generate Crypto op data structure */
3973         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3974                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3975         TEST_ASSERT_NOT_NULL(ut_params->op,
3976                         "Failed to allocate symmetric crypto operation struct");
3977
3978         /* Set crypto operation data parameters */
3979         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3980
3981         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3982
3983         sym_op->m_src = ut_params->ibuf;
3984
3985         sym_op->auth.data.offset = 0;
3986         sym_op->auth.data.length = QUOTE_512_BYTES;
3987
3988         /* Process crypto operation */
3989         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3990                         ut_params->op);
3991         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
3992
3993         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3994                         "crypto operation processing failed");
3995
3996         return TEST_SUCCESS;
3997 }
3998
3999 static int
4000 test_null_cipher_auth_operation(void)
4001 {
4002         struct crypto_testsuite_params *ts_params = &testsuite_params;
4003         struct crypto_unittest_params *ut_params = &unittest_params;
4004
4005         /* Generate test mbuf data and space for digest */
4006         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4007                         catch_22_quote, QUOTE_512_BYTES, 0);
4008
4009         /* Setup Cipher Parameters */
4010         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4011         ut_params->cipher_xform.next = &ut_params->auth_xform;
4012
4013         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4014         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4015
4016         /* Setup HMAC Parameters */
4017         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4018         ut_params->auth_xform.next = NULL;
4019
4020         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4021         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4022
4023         /* Create Crypto session*/
4024         ut_params->sess = rte_cryptodev_sym_session_create(
4025                         ts_params->valid_devs[0], &ut_params->cipher_xform);
4026         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4027
4028         /* Generate Crypto op data structure */
4029         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4030                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4031         TEST_ASSERT_NOT_NULL(ut_params->op,
4032                         "Failed to allocate symmetric crypto operation struct");
4033
4034         /* Set crypto operation data parameters */
4035         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4036
4037         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4038
4039         sym_op->m_src = ut_params->ibuf;
4040
4041         sym_op->cipher.data.offset = 0;
4042         sym_op->cipher.data.length = QUOTE_512_BYTES;
4043
4044         sym_op->auth.data.offset = 0;
4045         sym_op->auth.data.length = QUOTE_512_BYTES;
4046
4047         /* Process crypto operation */
4048         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4049                         ut_params->op);
4050         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4051
4052         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4053                         "crypto operation processing failed");
4054
4055         /* Validate obuf */
4056         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4057                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4058                         catch_22_quote,
4059                         QUOTE_512_BYTES,
4060                         "Ciphertext data not as expected");
4061
4062         return TEST_SUCCESS;
4063 }
4064
4065 static int
4066 test_null_auth_cipher_operation(void)
4067 {
4068         struct crypto_testsuite_params *ts_params = &testsuite_params;
4069         struct crypto_unittest_params *ut_params = &unittest_params;
4070
4071         /* Generate test mbuf data and space for digest */
4072         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4073                         catch_22_quote, QUOTE_512_BYTES, 0);
4074
4075         /* Setup Cipher Parameters */
4076         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4077         ut_params->cipher_xform.next = NULL;
4078
4079         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4080         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4081
4082         /* Setup HMAC Parameters */
4083         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4084         ut_params->auth_xform.next = &ut_params->cipher_xform;
4085
4086         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4087         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4088
4089         /* Create Crypto session*/
4090         ut_params->sess = rte_cryptodev_sym_session_create(
4091                         ts_params->valid_devs[0], &ut_params->cipher_xform);
4092         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4093
4094         /* Generate Crypto op data structure */
4095         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4096                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4097         TEST_ASSERT_NOT_NULL(ut_params->op,
4098                         "Failed to allocate symmetric crypto operation struct");
4099
4100         /* Set crypto operation data parameters */
4101         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4102
4103         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4104
4105         sym_op->m_src = ut_params->ibuf;
4106
4107         sym_op->cipher.data.offset = 0;
4108         sym_op->cipher.data.length = QUOTE_512_BYTES;
4109
4110         sym_op->auth.data.offset = 0;
4111         sym_op->auth.data.length = QUOTE_512_BYTES;
4112
4113         /* Process crypto operation */
4114         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4115                         ut_params->op);
4116         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4117
4118         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4119                         "crypto operation processing failed");
4120
4121         /* Validate obuf */
4122         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4123                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4124                         catch_22_quote,
4125                         QUOTE_512_BYTES,
4126                         "Ciphertext data not as expected");
4127
4128         return TEST_SUCCESS;
4129 }
4130
4131
4132 static int
4133 test_null_invalid_operation(void)
4134 {
4135         struct crypto_testsuite_params *ts_params = &testsuite_params;
4136         struct crypto_unittest_params *ut_params = &unittest_params;
4137
4138         /* Setup Cipher Parameters */
4139         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4140         ut_params->cipher_xform.next = NULL;
4141
4142         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
4143         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4144
4145         /* Create Crypto session*/
4146         ut_params->sess = rte_cryptodev_sym_session_create(
4147                         ts_params->valid_devs[0], &ut_params->cipher_xform);
4148         TEST_ASSERT_NULL(ut_params->sess,
4149                         "Session creation succeeded unexpectedly");
4150
4151
4152         /* Setup HMAC Parameters */
4153         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4154         ut_params->auth_xform.next = NULL;
4155
4156         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
4157         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4158
4159         /* Create Crypto session*/
4160         ut_params->sess = rte_cryptodev_sym_session_create(
4161                         ts_params->valid_devs[0], &ut_params->auth_xform);
4162         TEST_ASSERT_NULL(ut_params->sess,
4163                         "Session creation succeeded unexpectedly");
4164
4165         return TEST_SUCCESS;
4166 }
4167
4168
4169 #define NULL_BURST_LENGTH (32)
4170
4171 static int
4172 test_null_burst_operation(void)
4173 {
4174         struct crypto_testsuite_params *ts_params = &testsuite_params;
4175         struct crypto_unittest_params *ut_params = &unittest_params;
4176
4177         unsigned i, burst_len = NULL_BURST_LENGTH;
4178
4179         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
4180         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
4181
4182         /* Setup Cipher Parameters */
4183         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4184         ut_params->cipher_xform.next = &ut_params->auth_xform;
4185
4186         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4187         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4188
4189         /* Setup HMAC Parameters */
4190         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4191         ut_params->auth_xform.next = NULL;
4192
4193         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4194         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4195
4196         /* Create Crypto session*/
4197         ut_params->sess = rte_cryptodev_sym_session_create(
4198                         ts_params->valid_devs[0], &ut_params->cipher_xform);
4199         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4200
4201         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
4202                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
4203                         burst_len, "failed to generate burst of crypto ops");
4204
4205         /* Generate an operation for each mbuf in burst */
4206         for (i = 0; i < burst_len; i++) {
4207                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4208
4209                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
4210
4211                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
4212                                 sizeof(unsigned));
4213                 *data = i;
4214
4215                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
4216
4217                 burst[i]->sym->m_src = m;
4218         }
4219
4220         /* Process crypto operation */
4221         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
4222                         0, burst, burst_len),
4223                         burst_len,
4224                         "Error enqueuing burst");
4225
4226         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
4227                         0, burst_dequeued, burst_len),
4228                         burst_len,
4229                         "Error dequeuing burst");
4230
4231
4232         for (i = 0; i < burst_len; i++) {
4233                 TEST_ASSERT_EQUAL(
4234                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
4235                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
4236                                         uint32_t *),
4237                         "data not as expected");
4238
4239                 rte_pktmbuf_free(burst[i]->sym->m_src);
4240                 rte_crypto_op_free(burst[i]);
4241         }
4242
4243         return TEST_SUCCESS;
4244 }
4245
4246
4247
4248
4249 static struct unit_test_suite cryptodev_qat_testsuite  = {
4250         .suite_name = "Crypto QAT Unit Test Suite",
4251         .setup = testsuite_setup,
4252         .teardown = testsuite_teardown,
4253         .unit_test_cases = {
4254                 TEST_CASE_ST(ut_setup, ut_teardown,
4255                                 test_device_configure_invalid_dev_id),
4256                 TEST_CASE_ST(ut_setup, ut_teardown,
4257                                 test_device_configure_invalid_queue_pair_ids),
4258                 TEST_CASE_ST(ut_setup, ut_teardown,
4259                                 test_queue_pair_descriptor_setup),
4260                 TEST_CASE_ST(ut_setup, ut_teardown,
4261                                 test_multi_session),
4262
4263                 TEST_CASE_ST(ut_setup, ut_teardown,
4264                                 test_AES_CBC_HMAC_SHA1_encrypt_digest_oop),
4265                 TEST_CASE_ST(ut_setup, ut_teardown,
4266                                 test_AES_CBC_HMAC_SHA1_decrypt_digest_oop_ver),
4267
4268                 TEST_CASE_ST(ut_setup, ut_teardown,
4269                                 test_AES_CBC_HMAC_SHA1_encrypt_digest),
4270                 TEST_CASE_ST(ut_setup, ut_teardown,
4271                                 test_AES_CBC_HMAC_SHA1_decrypt_digest_verify),
4272
4273                 TEST_CASE_ST(ut_setup, ut_teardown,
4274                                 test_AES_CBC_HMAC_SHA256_encrypt_digest),
4275                 TEST_CASE_ST(ut_setup, ut_teardown,
4276                                 test_AES_CBC_HMAC_SHA256_decrypt_digest_verify),
4277
4278                 TEST_CASE_ST(ut_setup, ut_teardown,
4279                                 test_AES_CBC_HMAC_SHA512_encrypt_digest),
4280                 TEST_CASE_ST(ut_setup, ut_teardown,
4281                                 test_AES_CBC_HMAC_SHA512_decrypt_digest_verify),
4282
4283                 TEST_CASE_ST(ut_setup, ut_teardown,
4284                                 test_AES_CBC_HMAC_AES_XCBC_encrypt_digest),
4285                 TEST_CASE_ST(ut_setup, ut_teardown,
4286                                 test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify),
4287                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
4288
4289                 /** AES GCM Authenticated Encryption */
4290                 TEST_CASE_ST(ut_setup, ut_teardown,
4291                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
4292                 TEST_CASE_ST(ut_setup, ut_teardown,
4293                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
4294                 TEST_CASE_ST(ut_setup, ut_teardown,
4295                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
4296                 TEST_CASE_ST(ut_setup, ut_teardown,
4297                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
4298                 TEST_CASE_ST(ut_setup, ut_teardown,
4299                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
4300                 TEST_CASE_ST(ut_setup, ut_teardown,
4301                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
4302                 TEST_CASE_ST(ut_setup, ut_teardown,
4303                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
4304
4305                 /** AES GCM Authenticated Decryption */
4306                 TEST_CASE_ST(ut_setup, ut_teardown,
4307                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
4308                 TEST_CASE_ST(ut_setup, ut_teardown,
4309                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
4310                 TEST_CASE_ST(ut_setup, ut_teardown,
4311                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
4312                 TEST_CASE_ST(ut_setup, ut_teardown,
4313                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
4314                 TEST_CASE_ST(ut_setup, ut_teardown,
4315                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
4316                 TEST_CASE_ST(ut_setup, ut_teardown,
4317                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
4318                 TEST_CASE_ST(ut_setup, ut_teardown,
4319                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
4320
4321                 /** Snow3G encrypt only (UEA2) */
4322                 TEST_CASE_ST(ut_setup, ut_teardown,
4323                         test_snow3g_encryption_test_case_1),
4324                 TEST_CASE_ST(ut_setup, ut_teardown,
4325                         test_snow3g_encryption_test_case_2),
4326                 TEST_CASE_ST(ut_setup, ut_teardown,
4327                         test_snow3g_encryption_test_case_3),
4328                 TEST_CASE_ST(ut_setup, ut_teardown,
4329                         test_snow3g_encryption_test_case_4),
4330                 TEST_CASE_ST(ut_setup, ut_teardown,
4331                         test_snow3g_encryption_test_case_5),
4332
4333                 TEST_CASE_ST(ut_setup, ut_teardown,
4334                         test_snow3g_encryption_test_case_1_oop),
4335                 TEST_CASE_ST(ut_setup, ut_teardown,
4336                         test_snow3g_decryption_test_case_1_oop),
4337
4338                 /** Snow3G decrypt only (UEA2) */
4339                 TEST_CASE_ST(ut_setup, ut_teardown,
4340                         test_snow3g_decryption_test_case_1),
4341                 TEST_CASE_ST(ut_setup, ut_teardown,
4342                         test_snow3g_decryption_test_case_2),
4343                 TEST_CASE_ST(ut_setup, ut_teardown,
4344                         test_snow3g_decryption_test_case_3),
4345                 TEST_CASE_ST(ut_setup, ut_teardown,
4346                         test_snow3g_decryption_test_case_4),
4347                 TEST_CASE_ST(ut_setup, ut_teardown,
4348                         test_snow3g_decryption_test_case_5),
4349                 TEST_CASE_ST(ut_setup, ut_teardown,
4350                         test_snow3g_hash_generate_test_case_1),
4351                 TEST_CASE_ST(ut_setup, ut_teardown,
4352                         test_snow3g_hash_generate_test_case_2),
4353                 TEST_CASE_ST(ut_setup, ut_teardown,
4354                         test_snow3g_hash_generate_test_case_3),
4355                 TEST_CASE_ST(ut_setup, ut_teardown,
4356                         test_snow3g_hash_verify_test_case_1),
4357                 TEST_CASE_ST(ut_setup, ut_teardown,
4358                         test_snow3g_hash_verify_test_case_2),
4359                 TEST_CASE_ST(ut_setup, ut_teardown,
4360                         test_snow3g_hash_verify_test_case_3),
4361                 TEST_CASE_ST(ut_setup, ut_teardown,
4362                         test_snow3g_authenticated_encryption_test_case_1),
4363                 TEST_CASE_ST(ut_setup, ut_teardown,
4364                         test_snow3g_encrypted_authentication_test_case_1),
4365                 TEST_CASES_END() /**< NULL terminate unit test array */
4366         }
4367 };
4368
4369 static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
4370         .suite_name = "Crypto Device AESNI MB Unit Test Suite",
4371         .setup = testsuite_setup,
4372         .teardown = testsuite_teardown,
4373         .unit_test_cases = {
4374                 TEST_CASE_ST(ut_setup, ut_teardown,
4375                         test_AES_CBC_HMAC_SHA1_encrypt_digest),
4376                 TEST_CASE_ST(ut_setup, ut_teardown,
4377                         test_AES_CBC_HMAC_SHA1_decrypt_digest_verify),
4378
4379                 TEST_CASE_ST(ut_setup, ut_teardown,
4380                         test_AES_CBC_HMAC_SHA256_encrypt_digest),
4381                 TEST_CASE_ST(ut_setup, ut_teardown,
4382                         test_AES_CBC_HMAC_SHA256_decrypt_digest_verify),
4383
4384                 TEST_CASE_ST(ut_setup, ut_teardown,
4385                         test_AES_CBC_HMAC_SHA512_encrypt_digest),
4386                 TEST_CASE_ST(ut_setup, ut_teardown,
4387                         test_AES_CBC_HMAC_SHA512_decrypt_digest_verify),
4388
4389                 TEST_CASE_ST(ut_setup, ut_teardown,
4390                         test_AES_CBC_HMAC_AES_XCBC_encrypt_digest),
4391                 TEST_CASE_ST(ut_setup, ut_teardown,
4392                         test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify),
4393
4394                 TEST_CASE_ST(ut_setup, ut_teardown,
4395                         test_AES_CBC_HMAC_SHA1_encrypt_digest_sessionless),
4396
4397                 TEST_CASE_ST(ut_setup, ut_teardown,
4398                         test_not_in_place_crypto),
4399
4400                 TEST_CASES_END() /**< NULL terminate unit test array */
4401         }
4402 };
4403
4404 static struct unit_test_suite cryptodev_aesni_gcm_testsuite  = {
4405         .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
4406         .setup = testsuite_setup,
4407         .teardown = testsuite_teardown,
4408         .unit_test_cases = {
4409                 /** AES GCM Authenticated Encryption */
4410                 TEST_CASE_ST(ut_setup, ut_teardown,
4411                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
4412                 TEST_CASE_ST(ut_setup, ut_teardown,
4413                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
4414                 TEST_CASE_ST(ut_setup, ut_teardown,
4415                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
4416                 TEST_CASE_ST(ut_setup, ut_teardown,
4417                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
4418                 TEST_CASE_ST(ut_setup, ut_teardown,
4419                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
4420                 TEST_CASE_ST(ut_setup, ut_teardown,
4421                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
4422                 TEST_CASE_ST(ut_setup, ut_teardown,
4423                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
4424
4425                 /** AES GCM Authenticated Decryption */
4426                 TEST_CASE_ST(ut_setup, ut_teardown,
4427                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
4428                 TEST_CASE_ST(ut_setup, ut_teardown,
4429                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
4430                 TEST_CASE_ST(ut_setup, ut_teardown,
4431                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
4432                 TEST_CASE_ST(ut_setup, ut_teardown,
4433                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
4434                 TEST_CASE_ST(ut_setup, ut_teardown,
4435                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
4436                 TEST_CASE_ST(ut_setup, ut_teardown,
4437                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
4438                 TEST_CASE_ST(ut_setup, ut_teardown,
4439                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
4440
4441                 TEST_CASES_END() /**< NULL terminate unit test array */
4442         }
4443 };
4444
4445 static struct unit_test_suite cryptodev_sw_snow3g_testsuite  = {
4446         .suite_name = "Crypto Device SW Snow3G Unit Test Suite",
4447         .setup = testsuite_setup,
4448         .teardown = testsuite_teardown,
4449         .unit_test_cases = {
4450                 /** Snow3G encrypt only (UEA2) */
4451                 TEST_CASE_ST(ut_setup, ut_teardown,
4452                         test_snow3g_encryption_test_case_1),
4453                 TEST_CASE_ST(ut_setup, ut_teardown,
4454                         test_snow3g_encryption_test_case_2),
4455                 TEST_CASE_ST(ut_setup, ut_teardown,
4456                         test_snow3g_encryption_test_case_3),
4457                 TEST_CASE_ST(ut_setup, ut_teardown,
4458                         test_snow3g_encryption_test_case_4),
4459                 TEST_CASE_ST(ut_setup, ut_teardown,
4460                         test_snow3g_encryption_test_case_5),
4461
4462
4463                 /** Snow3G decrypt only (UEA2) */
4464                 TEST_CASE_ST(ut_setup, ut_teardown,
4465                         test_snow3g_decryption_test_case_1),
4466                 TEST_CASE_ST(ut_setup, ut_teardown,
4467                         test_snow3g_decryption_test_case_2),
4468                 TEST_CASE_ST(ut_setup, ut_teardown,
4469                         test_snow3g_decryption_test_case_3),
4470                 TEST_CASE_ST(ut_setup, ut_teardown,
4471                         test_snow3g_decryption_test_case_4),
4472                 TEST_CASE_ST(ut_setup, ut_teardown,
4473                         test_snow3g_decryption_test_case_5),
4474                 TEST_CASE_ST(ut_setup, ut_teardown,
4475                         test_snow3g_hash_generate_test_case_1),
4476                 TEST_CASE_ST(ut_setup, ut_teardown,
4477                         test_snow3g_hash_generate_test_case_2),
4478                 TEST_CASE_ST(ut_setup, ut_teardown,
4479                         test_snow3g_hash_generate_test_case_3),
4480                 TEST_CASE_ST(ut_setup, ut_teardown,
4481                         test_snow3g_hash_verify_test_case_1),
4482                 TEST_CASE_ST(ut_setup, ut_teardown,
4483                         test_snow3g_hash_verify_test_case_2),
4484                 TEST_CASE_ST(ut_setup, ut_teardown,
4485                         test_snow3g_hash_verify_test_case_3),
4486                 TEST_CASE_ST(ut_setup, ut_teardown,
4487                         test_snow3g_authenticated_encryption_test_case_1),
4488                 TEST_CASE_ST(ut_setup, ut_teardown,
4489                         test_snow3g_encrypted_authentication_test_case_1),
4490
4491                 TEST_CASES_END() /**< NULL terminate unit test array */
4492         }
4493 };
4494
4495 static struct unit_test_suite cryptodev_null_testsuite  = {
4496         .suite_name = "Crypto Device NULL Unit Test Suite",
4497         .setup = testsuite_setup,
4498         .teardown = testsuite_teardown,
4499         .unit_test_cases = {
4500                 TEST_CASE_ST(ut_setup, ut_teardown,
4501                         test_null_auth_only_operation),
4502                 TEST_CASE_ST(ut_setup, ut_teardown,
4503                         test_null_cipher_only_operation),
4504                 TEST_CASE_ST(ut_setup, ut_teardown,
4505                         test_null_cipher_auth_operation),
4506                 TEST_CASE_ST(ut_setup, ut_teardown,
4507                         test_null_auth_cipher_operation),
4508                 TEST_CASE_ST(ut_setup, ut_teardown,
4509                         test_null_invalid_operation),
4510                 TEST_CASE_ST(ut_setup, ut_teardown,
4511                         test_null_burst_operation),
4512
4513                 TEST_CASES_END() /**< NULL terminate unit test array */
4514         }
4515 };
4516
4517 static int
4518 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
4519 {
4520         gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
4521         return unit_test_suite_runner(&cryptodev_qat_testsuite);
4522 }
4523 static struct test_command cryptodev_qat_cmd = {
4524         .command = "cryptodev_qat_autotest",
4525         .callback = test_cryptodev_qat,
4526 };
4527
4528 static int
4529 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
4530 {
4531         gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
4532
4533         return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
4534 }
4535
4536 static struct test_command cryptodev_aesni_mb_cmd = {
4537         .command = "cryptodev_aesni_mb_autotest",
4538         .callback = test_cryptodev_aesni_mb,
4539 };
4540
4541 static int
4542 test_cryptodev_aesni_gcm(void)
4543 {
4544         gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD;
4545
4546         return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
4547 }
4548
4549 static struct test_command cryptodev_aesni_gcm_cmd = {
4550         .command = "cryptodev_aesni_gcm_autotest",
4551         .callback = test_cryptodev_aesni_gcm,
4552 };
4553
4554 static int
4555 test_cryptodev_null(void)
4556 {
4557         gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD;
4558
4559         return unit_test_suite_runner(&cryptodev_null_testsuite);
4560 }
4561
4562 static struct test_command cryptodev_null_cmd = {
4563         .command = "cryptodev_null_autotest",
4564         .callback = test_cryptodev_null,
4565 };
4566
4567 static int
4568 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
4569 {
4570         gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD;
4571
4572         return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
4573 }
4574
4575 static struct test_command cryptodev_sw_snow3g_cmd = {
4576         .command = "cryptodev_sw_snow3g_autotest",
4577         .callback = test_cryptodev_sw_snow3g,
4578 };
4579
4580 REGISTER_TEST_COMMAND(cryptodev_qat_cmd);
4581 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_cmd);
4582 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_cmd);
4583 REGISTER_TEST_COMMAND(cryptodev_null_cmd);
4584 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_cmd);