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