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_kasumi_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         enum rte_crypto_auth_algorithm algo)
1099 {
1100         uint8_t hash_key[key_len];
1101
1102         struct crypto_unittest_params *ut_params = &unittest_params;
1103
1104         memcpy(hash_key, key, key_len);
1105
1106         TEST_HEXDUMP(stdout, "key:", key, key_len);
1107
1108         /* Setup Authentication Parameters */
1109         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1110         ut_params->auth_xform.next = NULL;
1111
1112         ut_params->auth_xform.auth.op = op;
1113         ut_params->auth_xform.auth.algo = algo;
1114         ut_params->auth_xform.auth.key.length = key_len;
1115         ut_params->auth_xform.auth.key.data = hash_key;
1116         ut_params->auth_xform.auth.digest_length = auth_len;
1117         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1118         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1119                                 &ut_params->auth_xform);
1120         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1121         return 0;
1122 }
1123
1124 static int
1125 create_snow3g_kasumi_cipher_session(uint8_t dev_id,
1126                         enum rte_crypto_cipher_operation op,
1127                         enum rte_crypto_cipher_algorithm algo,
1128                         const uint8_t *key, const uint8_t key_len)
1129 {
1130         uint8_t cipher_key[key_len];
1131
1132         struct crypto_unittest_params *ut_params = &unittest_params;
1133
1134         memcpy(cipher_key, key, key_len);
1135
1136         /* Setup Cipher Parameters */
1137         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1138         ut_params->cipher_xform.next = NULL;
1139
1140         ut_params->cipher_xform.cipher.algo = algo;
1141         ut_params->cipher_xform.cipher.op = op;
1142         ut_params->cipher_xform.cipher.key.data = cipher_key;
1143         ut_params->cipher_xform.cipher.key.length = key_len;
1144
1145         TEST_HEXDUMP(stdout, "key:", key, key_len);
1146
1147         /* Create Crypto session */
1148         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1149                                                 &ut_params->
1150                                                 cipher_xform);
1151         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1152         return 0;
1153 }
1154
1155 static int
1156 create_snow3g_kasumi_cipher_operation(const uint8_t *iv, const unsigned iv_len,
1157                         const unsigned cipher_len,
1158                         const unsigned cipher_offset,
1159                         enum rte_crypto_cipher_algorithm algo)
1160 {
1161         struct crypto_testsuite_params *ts_params = &testsuite_params;
1162         struct crypto_unittest_params *ut_params = &unittest_params;
1163         unsigned iv_pad_len = 0;
1164
1165         /* Generate Crypto op data structure */
1166         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1167                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1168         TEST_ASSERT_NOT_NULL(ut_params->op,
1169                                 "Failed to allocate pktmbuf offload");
1170
1171         /* Set crypto operation data parameters */
1172         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1173
1174         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1175
1176         /* set crypto operation source mbuf */
1177         sym_op->m_src = ut_params->ibuf;
1178
1179         /* iv */
1180         if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1181                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1182         else
1183                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1184
1185         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf
1186                         , iv_pad_len);
1187
1188         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1189
1190         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1191         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1192         sym_op->cipher.iv.length = iv_pad_len;
1193
1194         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1195         sym_op->cipher.data.length = cipher_len;
1196         sym_op->cipher.data.offset = cipher_offset;
1197         return 0;
1198 }
1199
1200 static int
1201 create_snow3g_kasumi_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
1202                         const unsigned cipher_len,
1203                         const unsigned cipher_offset,
1204                         enum rte_crypto_cipher_algorithm algo)
1205 {
1206         struct crypto_testsuite_params *ts_params = &testsuite_params;
1207         struct crypto_unittest_params *ut_params = &unittest_params;
1208         unsigned iv_pad_len = 0;
1209
1210         /* Generate Crypto op data structure */
1211         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1212                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1213         TEST_ASSERT_NOT_NULL(ut_params->op,
1214                                 "Failed to allocate pktmbuf offload");
1215
1216         /* Set crypto operation data parameters */
1217         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1218
1219         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1220
1221         /* set crypto operation source mbuf */
1222         sym_op->m_src = ut_params->ibuf;
1223         sym_op->m_dst = ut_params->obuf;
1224
1225         /* iv */
1226         if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1227                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1228         else
1229                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1230         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1231                                         iv_pad_len);
1232
1233         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1234
1235         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1236         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1237         sym_op->cipher.iv.length = iv_pad_len;
1238
1239         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1240         sym_op->cipher.data.length = cipher_len;
1241         sym_op->cipher.data.offset = cipher_offset;
1242         return 0;
1243 }
1244
1245 static int
1246 create_snow3g_kasumi_cipher_auth_session(uint8_t dev_id,
1247                 enum rte_crypto_cipher_operation cipher_op,
1248                 enum rte_crypto_auth_operation auth_op,
1249                 enum rte_crypto_auth_algorithm auth_algo,
1250                 enum rte_crypto_cipher_algorithm cipher_algo,
1251                 const uint8_t *key, const uint8_t key_len,
1252                 const uint8_t aad_len, const uint8_t auth_len)
1253
1254 {
1255         uint8_t cipher_auth_key[key_len];
1256
1257         struct crypto_unittest_params *ut_params = &unittest_params;
1258
1259         memcpy(cipher_auth_key, key, key_len);
1260
1261         /* Setup Authentication Parameters */
1262         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1263         ut_params->auth_xform.next = NULL;
1264
1265         ut_params->auth_xform.auth.op = auth_op;
1266         ut_params->auth_xform.auth.algo = auth_algo;
1267         ut_params->auth_xform.auth.key.length = key_len;
1268         /* Hash key = cipher key */
1269         ut_params->auth_xform.auth.key.data = cipher_auth_key;
1270         ut_params->auth_xform.auth.digest_length = auth_len;
1271         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1272
1273         /* Setup Cipher Parameters */
1274         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1275         ut_params->cipher_xform.next = &ut_params->auth_xform;
1276
1277         ut_params->cipher_xform.cipher.algo = cipher_algo;
1278         ut_params->cipher_xform.cipher.op = cipher_op;
1279         ut_params->cipher_xform.cipher.key.data = cipher_auth_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->cipher_xform);
1287
1288         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1289         return 0;
1290 }
1291
1292 static int
1293 create_snow3g_kasumi_auth_cipher_session(uint8_t dev_id,
1294                 enum rte_crypto_cipher_operation cipher_op,
1295                 enum rte_crypto_auth_operation auth_op,
1296                 enum rte_crypto_auth_algorithm auth_algo,
1297                 enum rte_crypto_cipher_algorithm cipher_algo,
1298                 const uint8_t *key, const uint8_t key_len,
1299                 const uint8_t aad_len, const uint8_t auth_len)
1300 {
1301         uint8_t auth_cipher_key[key_len];
1302
1303         struct crypto_unittest_params *ut_params = &unittest_params;
1304
1305         memcpy(auth_cipher_key, key, key_len);
1306
1307         /* Setup Authentication Parameters */
1308         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1309         ut_params->auth_xform.auth.op = auth_op;
1310         ut_params->auth_xform.next = &ut_params->cipher_xform;
1311         ut_params->auth_xform.auth.algo = auth_algo;
1312         ut_params->auth_xform.auth.key.length = key_len;
1313         ut_params->auth_xform.auth.key.data = auth_cipher_key;
1314         ut_params->auth_xform.auth.digest_length = auth_len;
1315         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1316
1317         /* Setup Cipher Parameters */
1318         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1319         ut_params->cipher_xform.next = NULL;
1320         ut_params->cipher_xform.cipher.algo = cipher_algo;
1321         ut_params->cipher_xform.cipher.op = cipher_op;
1322         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
1323         ut_params->cipher_xform.cipher.key.length = key_len;
1324
1325         TEST_HEXDUMP(stdout, "key:", key, key_len);
1326
1327         /* Create Crypto session*/
1328         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1329                                 &ut_params->auth_xform);
1330
1331         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1332
1333         return 0;
1334 }
1335
1336 static int
1337 create_snow3g_kasumi_hash_operation(const uint8_t *auth_tag,
1338                 const unsigned auth_tag_len,
1339                 const uint8_t *aad, const unsigned aad_len,
1340                 unsigned data_pad_len,
1341                 enum rte_crypto_auth_operation op,
1342                 enum rte_crypto_auth_algorithm algo,
1343                 const unsigned auth_len, const unsigned auth_offset)
1344 {
1345         struct crypto_testsuite_params *ts_params = &testsuite_params;
1346
1347         struct crypto_unittest_params *ut_params = &unittest_params;
1348
1349         unsigned aad_buffer_len;
1350
1351         /* Generate Crypto op data structure */
1352         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1353                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1354         TEST_ASSERT_NOT_NULL(ut_params->op,
1355                 "Failed to allocate pktmbuf offload");
1356
1357         /* Set crypto operation data parameters */
1358         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1359
1360         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1361
1362         /* set crypto operation source mbuf */
1363         sym_op->m_src = ut_params->ibuf;
1364
1365         /* aad */
1366         /*
1367         * Always allocate the aad up to the block size.
1368         * The cryptodev API calls out -
1369         *  - the array must be big enough to hold the AAD, plus any
1370         *   space to round this up to the nearest multiple of the
1371         *   block size (8 bytes for KASUMI and 16 bytes for SNOW3G).
1372         */
1373         if (algo == RTE_CRYPTO_AUTH_KASUMI_F9)
1374                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
1375         else
1376                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
1377         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
1378                         ut_params->ibuf, aad_buffer_len);
1379         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
1380                                         "no room to prepend aad");
1381         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
1382                         ut_params->ibuf);
1383         sym_op->auth.aad.length = aad_len;
1384
1385         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
1386         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
1387
1388         TEST_HEXDUMP(stdout, "aad:",
1389                         sym_op->auth.aad.data, aad_len);
1390
1391         /* digest */
1392         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1393                                         ut_params->ibuf, auth_tag_len);
1394
1395         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
1396                                 "no room to append auth tag");
1397         ut_params->digest = sym_op->auth.digest.data;
1398         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1399                         ut_params->ibuf, data_pad_len + aad_len);
1400         sym_op->auth.digest.length = auth_tag_len;
1401         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
1402                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
1403         else
1404                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
1405
1406         TEST_HEXDUMP(stdout, "digest:",
1407                 sym_op->auth.digest.data,
1408                 sym_op->auth.digest.length);
1409
1410         sym_op->auth.data.length = auth_len;
1411         sym_op->auth.data.offset = auth_offset;
1412
1413         return 0;
1414 }
1415
1416 static int
1417 create_snow3g_kasumi_cipher_hash_operation(const uint8_t *auth_tag,
1418                 const unsigned auth_tag_len,
1419                 const uint8_t *aad, const uint8_t aad_len,
1420                 unsigned data_pad_len,
1421                 enum rte_crypto_auth_operation op,
1422                 enum rte_crypto_auth_algorithm auth_algo,
1423                 enum rte_crypto_cipher_algorithm cipher_algo,
1424                 const uint8_t *iv, const uint8_t iv_len,
1425                 const unsigned cipher_len, const unsigned cipher_offset,
1426                 const unsigned auth_len, const unsigned auth_offset)
1427 {
1428         struct crypto_testsuite_params *ts_params = &testsuite_params;
1429         struct crypto_unittest_params *ut_params = &unittest_params;
1430
1431         unsigned iv_pad_len = 0;
1432         unsigned aad_buffer_len;
1433
1434         /* Generate Crypto op data structure */
1435         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1436                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1437         TEST_ASSERT_NOT_NULL(ut_params->op,
1438                         "Failed to allocate pktmbuf offload");
1439         /* Set crypto operation data parameters */
1440         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1441
1442         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1443
1444         /* set crypto operation source mbuf */
1445         sym_op->m_src = ut_params->ibuf;
1446
1447
1448         /* iv */
1449         if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1450                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1451         else
1452                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1453
1454         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1455                 ut_params->ibuf, iv_pad_len);
1456         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1457
1458         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1459         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1460         sym_op->cipher.iv.length = iv_pad_len;
1461
1462         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1463
1464         sym_op->cipher.data.length = cipher_len;
1465         sym_op->cipher.data.offset = cipher_offset;
1466
1467         /* aad */
1468         /*
1469         * Always allocate the aad up to the block size.
1470         * The cryptodev API calls out -
1471         *  - the array must be big enough to hold the AAD, plus any
1472         *   space to round this up to the nearest multiple of the
1473         *   block size (8 bytes for KASUMI and 16 bytes for SNOW3G).
1474         */
1475         if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
1476                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
1477         else
1478                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
1479
1480         sym_op->auth.aad.data =
1481                         (uint8_t *)rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *);
1482         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
1483                         "no room to prepend aad");
1484         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
1485                         ut_params->ibuf);
1486         sym_op->auth.aad.length = aad_len;
1487
1488         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
1489         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
1490
1491         TEST_HEXDUMP(stdout, "aad:",
1492                         sym_op->auth.aad.data, aad_len);
1493
1494         /* digest */
1495         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1496                         ut_params->ibuf, auth_tag_len);
1497
1498         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
1499                         "no room to append auth tag");
1500         ut_params->digest = sym_op->auth.digest.data;
1501         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1502                         ut_params->ibuf, data_pad_len + aad_len);
1503         sym_op->auth.digest.length = auth_tag_len;
1504         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
1505                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
1506         else
1507                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
1508
1509         TEST_HEXDUMP(stdout, "digest:",
1510                 sym_op->auth.digest.data,
1511                 sym_op->auth.digest.length);
1512
1513         sym_op->auth.data.length = auth_len;
1514         sym_op->auth.data.offset = auth_offset;
1515
1516         return 0;
1517 }
1518
1519 static int
1520 create_snow3g_kasumi_auth_cipher_operation(const unsigned auth_tag_len,
1521                 const uint8_t *iv, const uint8_t iv_len,
1522                 const uint8_t *aad, const uint8_t aad_len,
1523                 unsigned data_pad_len,
1524                 const unsigned cipher_len, const unsigned cipher_offset,
1525                 const unsigned auth_len, const unsigned auth_offset,
1526                 enum rte_crypto_auth_algorithm auth_algo,
1527                 enum rte_crypto_cipher_algorithm cipher_algo)
1528 {
1529         struct crypto_testsuite_params *ts_params = &testsuite_params;
1530         struct crypto_unittest_params *ut_params = &unittest_params;
1531
1532         unsigned iv_pad_len = 0;
1533         unsigned aad_buffer_len = 0;
1534
1535         /* Generate Crypto op data structure */
1536         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1537                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1538         TEST_ASSERT_NOT_NULL(ut_params->op,
1539                         "Failed to allocate pktmbuf offload");
1540
1541         /* Set crypto operation data parameters */
1542         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1543
1544         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1545
1546         /* set crypto operation source mbuf */
1547         sym_op->m_src = ut_params->ibuf;
1548
1549         /* digest */
1550         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1551                         ut_params->ibuf, auth_tag_len);
1552
1553         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
1554                         "no room to append auth tag");
1555
1556         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1557                         ut_params->ibuf, data_pad_len);
1558         sym_op->auth.digest.length = auth_tag_len;
1559
1560         memset(sym_op->auth.digest.data, 0, auth_tag_len);
1561
1562         TEST_HEXDUMP(stdout, "digest:",
1563                         sym_op->auth.digest.data,
1564                         sym_op->auth.digest.length);
1565
1566         /* iv */
1567         if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1568                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1569         else
1570                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1571
1572         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1573                 ut_params->ibuf, iv_pad_len);
1574         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1575
1576         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1577         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1578         sym_op->cipher.iv.length = iv_pad_len;
1579
1580         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1581
1582         /* aad */
1583         /*
1584         * Always allocate the aad up to the block size.
1585         * The cryptodev API calls out -
1586         *  - the array must be big enough to hold the AAD, plus any
1587         *   space to round this up to the nearest multiple of the
1588         *   block size (8 bytes for KASUMI 16 bytes).
1589         */
1590         if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
1591                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
1592         else
1593                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
1594
1595         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
1596         ut_params->ibuf, aad_buffer_len);
1597         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
1598                                 "no room to prepend aad");
1599         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
1600                                 ut_params->ibuf);
1601         sym_op->auth.aad.length = aad_len;
1602
1603         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
1604         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
1605
1606         TEST_HEXDUMP(stdout, "aad:",
1607                         sym_op->auth.aad.data, aad_len);
1608
1609         sym_op->cipher.data.length = cipher_len;
1610         sym_op->cipher.data.offset = auth_offset + cipher_offset;
1611
1612         sym_op->auth.data.length = auth_len;
1613         sym_op->auth.data.offset = auth_offset + cipher_offset;
1614
1615         return 0;
1616 }
1617
1618 static int
1619 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
1620 {
1621         struct crypto_testsuite_params *ts_params = &testsuite_params;
1622         struct crypto_unittest_params *ut_params = &unittest_params;
1623
1624         int retval;
1625         unsigned plaintext_pad_len;
1626         unsigned plaintext_len;
1627         uint8_t *plaintext;
1628
1629         /* Create SNOW3G session */
1630         retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
1631                         tdata->key.data, tdata->key.len,
1632                         tdata->aad.len, tdata->digest.len,
1633                         RTE_CRYPTO_AUTH_OP_GENERATE,
1634                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
1635         if (retval < 0)
1636                 return retval;
1637
1638         /* alloc mbuf and set payload */
1639         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
1640
1641         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
1642         rte_pktmbuf_tailroom(ut_params->ibuf));
1643
1644         plaintext_len = ceil_byte_length(tdata->plaintext.len);
1645         /* Append data which is padded to a multiple of */
1646         /* the algorithms block size */
1647         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
1648         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1649                                 plaintext_pad_len);
1650         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
1651
1652         /* Create SNOW3G operation */
1653         retval = create_snow3g_kasumi_hash_operation(NULL, tdata->digest.len,
1654                         tdata->aad.data, tdata->aad.len,
1655                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
1656                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1657                         tdata->validAuthLenInBits.len,
1658                         tdata->validAuthOffsetLenInBits.len);
1659         if (retval < 0)
1660                 return retval;
1661
1662         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
1663                                 ut_params->op);
1664         ut_params->obuf = ut_params->op->sym->m_src;
1665         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
1666         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
1667                         + plaintext_pad_len + tdata->aad.len;
1668
1669         /* Validate obuf */
1670         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1671         ut_params->digest,
1672         tdata->digest.data,
1673         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
1674         "Snow3G Generated auth tag not as expected");
1675
1676         return 0;
1677 }
1678
1679 static int
1680 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
1681 {
1682         struct crypto_testsuite_params *ts_params = &testsuite_params;
1683         struct crypto_unittest_params *ut_params = &unittest_params;
1684
1685         int retval;
1686         unsigned plaintext_pad_len;
1687         unsigned plaintext_len;
1688         uint8_t *plaintext;
1689
1690         /* Create SNOW3G session */
1691         retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
1692                                 tdata->key.data, tdata->key.len,
1693                                 tdata->aad.len, tdata->digest.len,
1694                                 RTE_CRYPTO_AUTH_OP_VERIFY,
1695                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
1696         if (retval < 0)
1697                 return retval;
1698         /* alloc mbuf and set payload */
1699         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
1700
1701         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
1702         rte_pktmbuf_tailroom(ut_params->ibuf));
1703
1704         plaintext_len = ceil_byte_length(tdata->plaintext.len);
1705         /* Append data which is padded to a multiple of */
1706         /* the algorithms block size */
1707         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
1708         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1709                                 plaintext_pad_len);
1710         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
1711
1712         /* Create SNOW3G operation */
1713         retval = create_snow3g_kasumi_hash_operation(tdata->digest.data,
1714                         tdata->digest.len,
1715                         tdata->aad.data, tdata->aad.len,
1716                         plaintext_pad_len,
1717                         RTE_CRYPTO_AUTH_OP_VERIFY,
1718                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1719                         tdata->validAuthLenInBits.len,
1720                         tdata->validAuthOffsetLenInBits.len);
1721         if (retval < 0)
1722                 return retval;
1723
1724         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
1725                                 ut_params->op);
1726         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
1727         ut_params->obuf = ut_params->op->sym->m_src;
1728         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
1729                                 + plaintext_pad_len + tdata->aad.len;
1730
1731         /* Validate obuf */
1732         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
1733                 return 0;
1734         else
1735                 return -1;
1736
1737         return 0;
1738 }
1739
1740 static int
1741 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
1742 {
1743         struct crypto_testsuite_params *ts_params = &testsuite_params;
1744         struct crypto_unittest_params *ut_params = &unittest_params;
1745
1746         int retval;
1747         unsigned plaintext_pad_len;
1748         unsigned plaintext_len;
1749         uint8_t *plaintext;
1750
1751         /* Create KASUMI session */
1752         retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
1753                         tdata->key.data, tdata->key.len,
1754                         tdata->aad.len, tdata->digest.len,
1755                         RTE_CRYPTO_AUTH_OP_GENERATE,
1756                         RTE_CRYPTO_AUTH_KASUMI_F9);
1757         if (retval < 0)
1758                 return retval;
1759
1760         /* alloc mbuf and set payload */
1761         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
1762
1763         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
1764         rte_pktmbuf_tailroom(ut_params->ibuf));
1765
1766         plaintext_len = ceil_byte_length(tdata->plaintext.len);
1767         /* Append data which is padded to a multiple of */
1768         /* the algorithms block size */
1769         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
1770         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1771                                 plaintext_pad_len);
1772         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
1773
1774         /* Create KASUMI operation */
1775         retval = create_snow3g_kasumi_hash_operation(NULL, tdata->digest.len,
1776                         tdata->aad.data, tdata->aad.len,
1777                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
1778                         RTE_CRYPTO_AUTH_KASUMI_F9,
1779                         tdata->validAuthLenInBits.len,
1780                         tdata->validAuthOffsetLenInBits.len);
1781         if (retval < 0)
1782                 return retval;
1783
1784         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
1785                                 ut_params->op);
1786         ut_params->obuf = ut_params->op->sym->m_src;
1787         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
1788         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
1789                         + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
1790
1791         /* Validate obuf */
1792         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1793         ut_params->digest,
1794         tdata->digest.data,
1795         DIGEST_BYTE_LENGTH_KASUMI_F9,
1796         "KASUMI Generated auth tag not as expected");
1797
1798         return 0;
1799 }
1800
1801 static int
1802 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
1803 {
1804         struct crypto_testsuite_params *ts_params = &testsuite_params;
1805         struct crypto_unittest_params *ut_params = &unittest_params;
1806
1807         int retval;
1808         unsigned plaintext_pad_len;
1809         unsigned plaintext_len;
1810         uint8_t *plaintext;
1811
1812         /* Create KASUMI session */
1813         retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0],
1814                                 tdata->key.data, tdata->key.len,
1815                                 tdata->aad.len, tdata->digest.len,
1816                                 RTE_CRYPTO_AUTH_OP_VERIFY,
1817                                 RTE_CRYPTO_AUTH_KASUMI_F9);
1818         if (retval < 0)
1819                 return retval;
1820         /* alloc mbuf and set payload */
1821         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
1822
1823         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
1824         rte_pktmbuf_tailroom(ut_params->ibuf));
1825
1826         plaintext_len = ceil_byte_length(tdata->plaintext.len);
1827         /* Append data which is padded to a multiple */
1828         /* of the algorithms block size */
1829         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
1830         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1831                                 plaintext_pad_len);
1832         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
1833
1834         /* Create KASUMI operation */
1835         retval = create_snow3g_kasumi_hash_operation(tdata->digest.data,
1836                         tdata->digest.len,
1837                         tdata->aad.data, tdata->aad.len,
1838                         plaintext_pad_len,
1839                         RTE_CRYPTO_AUTH_OP_VERIFY,
1840                         RTE_CRYPTO_AUTH_KASUMI_F9,
1841                         tdata->validAuthLenInBits.len,
1842                         tdata->validAuthOffsetLenInBits.len);
1843         if (retval < 0)
1844                 return retval;
1845
1846         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
1847                                 ut_params->op);
1848         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
1849         ut_params->obuf = ut_params->op->sym->m_src;
1850         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
1851                                 + plaintext_pad_len + tdata->aad.len;
1852
1853         /* Validate obuf */
1854         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
1855                 return 0;
1856         else
1857                 return -1;
1858
1859         return 0;
1860 }
1861
1862 static int
1863 test_snow3g_hash_generate_test_case_1(void)
1864 {
1865         return test_snow3g_authentication(&snow3g_hash_test_case_1);
1866 }
1867
1868 static int
1869 test_snow3g_hash_generate_test_case_2(void)
1870 {
1871         return test_snow3g_authentication(&snow3g_hash_test_case_2);
1872 }
1873
1874 static int
1875 test_snow3g_hash_generate_test_case_3(void)
1876 {
1877         return test_snow3g_authentication(&snow3g_hash_test_case_3);
1878 }
1879
1880 static int
1881 test_snow3g_hash_generate_test_case_4(void)
1882 {
1883         return test_snow3g_authentication(&snow3g_hash_test_case_4);
1884 }
1885
1886 static int
1887 test_snow3g_hash_generate_test_case_5(void)
1888 {
1889         return test_snow3g_authentication(&snow3g_hash_test_case_5);
1890 }
1891
1892 static int
1893 test_snow3g_hash_generate_test_case_6(void)
1894 {
1895         return test_snow3g_authentication(&snow3g_hash_test_case_6);
1896 }
1897
1898 static int
1899 test_snow3g_hash_verify_test_case_1(void)
1900 {
1901         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
1902
1903 }
1904
1905 static int
1906 test_snow3g_hash_verify_test_case_2(void)
1907 {
1908         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
1909 }
1910
1911 static int
1912 test_snow3g_hash_verify_test_case_3(void)
1913 {
1914         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
1915 }
1916
1917 static int
1918 test_snow3g_hash_verify_test_case_4(void)
1919 {
1920         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
1921 }
1922
1923 static int
1924 test_snow3g_hash_verify_test_case_5(void)
1925 {
1926         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
1927 }
1928
1929 static int
1930 test_snow3g_hash_verify_test_case_6(void)
1931 {
1932         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
1933 }
1934
1935 static int
1936 test_kasumi_hash_generate_test_case_1(void)
1937 {
1938         return test_kasumi_authentication(&kasumi_hash_test_case_1);
1939 }
1940
1941 static int
1942 test_kasumi_hash_generate_test_case_2(void)
1943 {
1944         return test_kasumi_authentication(&kasumi_hash_test_case_2);
1945 }
1946
1947 static int
1948 test_kasumi_hash_generate_test_case_3(void)
1949 {
1950         return test_kasumi_authentication(&kasumi_hash_test_case_3);
1951 }
1952
1953 static int
1954 test_kasumi_hash_generate_test_case_4(void)
1955 {
1956         return test_kasumi_authentication(&kasumi_hash_test_case_4);
1957 }
1958
1959 static int
1960 test_kasumi_hash_generate_test_case_5(void)
1961 {
1962         return test_kasumi_authentication(&kasumi_hash_test_case_5);
1963 }
1964
1965 static int
1966 test_kasumi_hash_verify_test_case_1(void)
1967 {
1968         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
1969 }
1970
1971 static int
1972 test_kasumi_hash_verify_test_case_2(void)
1973 {
1974         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
1975 }
1976
1977 static int
1978 test_kasumi_hash_verify_test_case_3(void)
1979 {
1980         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
1981 }
1982
1983 static int
1984 test_kasumi_hash_verify_test_case_4(void)
1985 {
1986         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
1987 }
1988
1989 static int
1990 test_kasumi_hash_verify_test_case_5(void)
1991 {
1992         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
1993 }
1994
1995 static int
1996 test_kasumi_encryption(const struct kasumi_test_data *tdata)
1997 {
1998         struct crypto_testsuite_params *ts_params = &testsuite_params;
1999         struct crypto_unittest_params *ut_params = &unittest_params;
2000
2001         int retval;
2002         uint8_t *plaintext, *ciphertext;
2003         unsigned plaintext_pad_len;
2004         unsigned plaintext_len;
2005
2006         /* Create KASUMI session */
2007         retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2008                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2009                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2010                                         tdata->key.data, tdata->key.len);
2011         if (retval < 0)
2012                 return retval;
2013
2014         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2015
2016         /* Clear mbuf payload */
2017         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2018                rte_pktmbuf_tailroom(ut_params->ibuf));
2019
2020         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2021         /* Append data which is padded to a multiple */
2022         /* of the algorithms block size */
2023         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2024         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2025                                 plaintext_pad_len);
2026         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2027
2028         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2029
2030         /* Create KASUMI operation */
2031         retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len,
2032                                         tdata->plaintext.len,
2033                                         tdata->validCipherOffsetLenInBits.len,
2034                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2035         if (retval < 0)
2036                 return retval;
2037
2038         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2039                                                 ut_params->op);
2040         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2041
2042         ut_params->obuf = ut_params->op->sym->m_dst;
2043         if (ut_params->obuf)
2044                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2045                                 + tdata->iv.len;
2046         else
2047                 ciphertext = plaintext;
2048
2049         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2050
2051         /* Validate obuf */
2052         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2053                 ciphertext,
2054                 tdata->ciphertext.data,
2055                 tdata->validCipherLenInBits.len,
2056                 "KASUMI Ciphertext data not as expected");
2057         return 0;
2058 }
2059
2060 static int
2061 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
2062 {
2063         struct crypto_testsuite_params *ts_params = &testsuite_params;
2064         struct crypto_unittest_params *ut_params = &unittest_params;
2065
2066         int retval;
2067         uint8_t *plaintext, *ciphertext;
2068         unsigned plaintext_pad_len;
2069         unsigned plaintext_len;
2070
2071         /* Create KASUMI session */
2072         retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2073                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2074                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2075                                         tdata->key.data, tdata->key.len);
2076         if (retval < 0)
2077                 return retval;
2078
2079         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2080         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2081
2082         /* Clear mbuf payload */
2083         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2084                rte_pktmbuf_tailroom(ut_params->ibuf));
2085
2086         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2087         /* Append data which is padded to a multiple */
2088         /* of the algorithms block size */
2089         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2090         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2091                                 plaintext_pad_len);
2092         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2093         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2094
2095         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2096
2097         /* Create KASUMI operation */
2098         retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
2099                                         tdata->iv.len,
2100                                         tdata->plaintext.len,
2101                                         tdata->validCipherOffsetLenInBits.len,
2102                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2103         if (retval < 0)
2104                 return retval;
2105
2106         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2107                                                 ut_params->op);
2108         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2109
2110         ut_params->obuf = ut_params->op->sym->m_dst;
2111         if (ut_params->obuf)
2112                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2113                                 + tdata->iv.len;
2114         else
2115                 ciphertext = plaintext;
2116
2117         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2118
2119         /* Validate obuf */
2120         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2121                 ciphertext,
2122                 tdata->ciphertext.data,
2123                 tdata->validCipherLenInBits.len,
2124                 "KASUMI Ciphertext data not as expected");
2125         return 0;
2126 }
2127
2128 static int
2129 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
2130 {
2131         struct crypto_testsuite_params *ts_params = &testsuite_params;
2132         struct crypto_unittest_params *ut_params = &unittest_params;
2133
2134         int retval;
2135         uint8_t *ciphertext, *plaintext;
2136         unsigned ciphertext_pad_len;
2137         unsigned ciphertext_len;
2138
2139         /* Create KASUMI session */
2140         retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2141                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
2142                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2143                                         tdata->key.data, tdata->key.len);
2144         if (retval < 0)
2145                 return retval;
2146
2147         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2148         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2149
2150         /* Clear mbuf payload */
2151         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2152                rte_pktmbuf_tailroom(ut_params->ibuf));
2153
2154         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2155         /* Append data which is padded to a multiple */
2156         /* of the algorithms block size */
2157         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
2158         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2159                                 ciphertext_pad_len);
2160         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
2161         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2162
2163         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
2164
2165         /* Create KASUMI operation */
2166         retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
2167                                         tdata->iv.len,
2168                                         tdata->ciphertext.len,
2169                                         tdata->validCipherOffsetLenInBits.len,
2170                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2171         if (retval < 0)
2172                 return retval;
2173
2174         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2175                                                 ut_params->op);
2176         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2177
2178         ut_params->obuf = ut_params->op->sym->m_dst;
2179         if (ut_params->obuf)
2180                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2181                                 + tdata->iv.len;
2182         else
2183                 plaintext = ciphertext;
2184
2185         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
2186
2187         /* Validate obuf */
2188         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2189                 plaintext,
2190                 tdata->plaintext.data,
2191                 tdata->validCipherLenInBits.len,
2192                 "KASUMI Plaintext data not as expected");
2193         return 0;
2194 }
2195
2196 static int
2197 test_kasumi_decryption(const struct kasumi_test_data *tdata)
2198 {
2199         struct crypto_testsuite_params *ts_params = &testsuite_params;
2200         struct crypto_unittest_params *ut_params = &unittest_params;
2201
2202         int retval;
2203         uint8_t *ciphertext, *plaintext;
2204         unsigned ciphertext_pad_len;
2205         unsigned ciphertext_len;
2206
2207         /* Create KASUMI session */
2208         retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2209                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
2210                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2211                                         tdata->key.data, tdata->key.len);
2212         if (retval < 0)
2213                 return retval;
2214
2215         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2216
2217         /* Clear mbuf payload */
2218         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2219                rte_pktmbuf_tailroom(ut_params->ibuf));
2220
2221         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2222         /* Append data which is padded to a multiple */
2223         /* of the algorithms block size */
2224         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
2225         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2226                                 ciphertext_pad_len);
2227         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2228
2229         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
2230
2231         /* Create KASUMI operation */
2232         retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data,
2233                                         tdata->iv.len,
2234                                         tdata->ciphertext.len,
2235                                         tdata->validCipherOffsetLenInBits.len,
2236                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2237         if (retval < 0)
2238                 return retval;
2239
2240         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2241                                                 ut_params->op);
2242         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2243
2244         ut_params->obuf = ut_params->op->sym->m_dst;
2245         if (ut_params->obuf)
2246                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2247                                 + tdata->iv.len;
2248         else
2249                 plaintext = ciphertext;
2250
2251         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
2252
2253         /* Validate obuf */
2254         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2255                 plaintext,
2256                 tdata->plaintext.data,
2257                 tdata->validCipherLenInBits.len,
2258                 "KASUMI Plaintext data not as expected");
2259         return 0;
2260 }
2261
2262 static int
2263 test_snow3g_encryption(const struct snow3g_test_data *tdata)
2264 {
2265         struct crypto_testsuite_params *ts_params = &testsuite_params;
2266         struct crypto_unittest_params *ut_params = &unittest_params;
2267
2268         int retval;
2269         uint8_t *plaintext, *ciphertext;
2270         unsigned plaintext_pad_len;
2271         unsigned plaintext_len;
2272
2273         /* Create SNOW3G session */
2274         retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2275                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2276                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2277                                         tdata->key.data, tdata->key.len);
2278         if (retval < 0)
2279                 return retval;
2280
2281         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2282
2283         /* Clear mbuf payload */
2284         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2285                rte_pktmbuf_tailroom(ut_params->ibuf));
2286
2287         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2288         /* Append data which is padded to a multiple of */
2289         /* the algorithms block size */
2290         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2291         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2292                                 plaintext_pad_len);
2293         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2294
2295         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2296
2297         /* Create SNOW3G operation */
2298         retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len,
2299                                         tdata->validCipherLenInBits.len,
2300                                         tdata->validCipherOffsetLenInBits.len,
2301                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2302         if (retval < 0)
2303                 return retval;
2304
2305         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2306                                                 ut_params->op);
2307         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2308
2309         ut_params->obuf = ut_params->op->sym->m_dst;
2310         if (ut_params->obuf)
2311                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2312                                 + tdata->iv.len;
2313         else
2314                 ciphertext = plaintext;
2315
2316         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
2317
2318         /* Validate obuf */
2319         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2320                 ciphertext,
2321                 tdata->ciphertext.data,
2322                 tdata->validDataLenInBits.len,
2323                 "Snow3G Ciphertext data not as expected");
2324         return 0;
2325 }
2326
2327
2328 static int
2329 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
2330 {
2331         struct crypto_testsuite_params *ts_params = &testsuite_params;
2332         struct crypto_unittest_params *ut_params = &unittest_params;
2333         uint8_t *plaintext, *ciphertext;
2334
2335         int retval;
2336         unsigned plaintext_pad_len;
2337         unsigned plaintext_len;
2338
2339         /* Create SNOW3G session */
2340         retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2341                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2342                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2343                                         tdata->key.data, tdata->key.len);
2344         if (retval < 0)
2345                 return retval;
2346
2347         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2348         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2349
2350         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2351                         "Failed to allocate input buffer in mempool");
2352         TEST_ASSERT_NOT_NULL(ut_params->obuf,
2353                         "Failed to allocate output buffer in mempool");
2354
2355         /* Clear mbuf payload */
2356         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2357                rte_pktmbuf_tailroom(ut_params->ibuf));
2358
2359         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2360         /* Append data which is padded to a multiple of */
2361         /* the algorithms block size */
2362         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2363         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2364                                 plaintext_pad_len);
2365         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2366         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2367
2368         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2369
2370         /* Create SNOW3G operation */
2371         retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
2372                                         tdata->iv.len,
2373                                         tdata->validCipherLenInBits.len,
2374                                         tdata->validCipherOffsetLenInBits.len,
2375                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2376         if (retval < 0)
2377                 return retval;
2378
2379         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2380                                                 ut_params->op);
2381         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2382
2383         ut_params->obuf = ut_params->op->sym->m_dst;
2384         if (ut_params->obuf)
2385                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2386                                 + tdata->iv.len;
2387         else
2388                 ciphertext = plaintext;
2389
2390         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
2391
2392         /* Validate obuf */
2393         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2394                 ciphertext,
2395                 tdata->ciphertext.data,
2396                 tdata->validDataLenInBits.len,
2397                 "Snow3G Ciphertext data not as expected");
2398         return 0;
2399 }
2400
2401 /* Shift right a buffer by "offset" bits, "offset" < 8 */
2402 static void
2403 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
2404 {
2405         uint8_t curr_byte, prev_byte;
2406         uint32_t length_in_bytes = ceil_byte_length(length + offset);
2407         uint8_t lower_byte_mask = (1 << offset) - 1;
2408         unsigned i;
2409
2410         prev_byte = buffer[0];
2411         buffer[0] >>= offset;
2412
2413         for (i = 1; i < length_in_bytes; i++) {
2414                 curr_byte = buffer[i];
2415                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
2416                                 (curr_byte >> offset);
2417                 prev_byte = curr_byte;
2418         }
2419 }
2420
2421 static int
2422 test_snow3g_encryption_offset_oop(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         uint8_t *plaintext, *ciphertext;
2427         int retval;
2428         uint32_t plaintext_len;
2429         uint32_t plaintext_pad_len;
2430         uint8_t extra_offset = 4;
2431         uint8_t *expected_ciphertext_shifted;
2432
2433         /* Create SNOW3G session */
2434         retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2435                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2436                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2437                                         tdata->key.data, tdata->key.len);
2438         if (retval < 0)
2439                 return retval;
2440
2441         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2442         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2443
2444         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2445                         "Failed to allocate input buffer in mempool");
2446         TEST_ASSERT_NOT_NULL(ut_params->obuf,
2447                         "Failed to allocate output buffer in mempool");
2448
2449         /* Clear mbuf payload */
2450         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2451                rte_pktmbuf_tailroom(ut_params->ibuf));
2452
2453         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
2454         /*
2455          * Append data which is padded to a
2456          * multiple of the algorithms block size
2457          */
2458         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2459
2460         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
2461                                                 plaintext_pad_len);
2462
2463         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2464
2465         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
2466         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
2467
2468 #ifdef RTE_APP_TEST_DEBUG
2469         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2470 #endif
2471         /* Create SNOW3G operation */
2472         retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
2473                                         tdata->iv.len,
2474                                         tdata->validCipherLenInBits.len,
2475                                         tdata->validCipherOffsetLenInBits.len +
2476                                         extra_offset,
2477                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2478         if (retval < 0)
2479                 return retval;
2480
2481         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2482                                                 ut_params->op);
2483         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2484
2485         ut_params->obuf = ut_params->op->sym->m_dst;
2486         if (ut_params->obuf)
2487                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2488                                 + tdata->iv.len;
2489         else
2490                 ciphertext = plaintext;
2491
2492 #ifdef RTE_APP_TEST_DEBUG
2493         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
2494 #endif
2495
2496         expected_ciphertext_shifted = rte_malloc(NULL,
2497                         ceil_byte_length(plaintext_len + extra_offset), 0);
2498
2499         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
2500                         "failed to reserve memory for ciphertext shifted\n");
2501
2502         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
2503                         ceil_byte_length(tdata->ciphertext.len));
2504         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
2505                         extra_offset);
2506         /* Validate obuf */
2507         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
2508                 ciphertext,
2509                 expected_ciphertext_shifted,
2510                 tdata->validDataLenInBits.len,
2511                 extra_offset,
2512                 "Snow3G Ciphertext data not as expected");
2513         return 0;
2514 }
2515
2516 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
2517 {
2518         struct crypto_testsuite_params *ts_params = &testsuite_params;
2519         struct crypto_unittest_params *ut_params = &unittest_params;
2520
2521         int retval;
2522
2523         uint8_t *plaintext, *ciphertext;
2524         unsigned ciphertext_pad_len;
2525         unsigned ciphertext_len;
2526
2527         /* Create SNOW3G session */
2528         retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2529                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
2530                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2531                                         tdata->key.data, tdata->key.len);
2532         if (retval < 0)
2533                 return retval;
2534
2535         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2536
2537         /* Clear mbuf payload */
2538         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2539                rte_pktmbuf_tailroom(ut_params->ibuf));
2540
2541         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2542         /* Append data which is padded to a multiple of */
2543         /* the algorithms block size */
2544         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
2545         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2546                                 ciphertext_pad_len);
2547         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2548
2549         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
2550
2551         /* Create SNOW3G operation */
2552         retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len,
2553                                         tdata->validCipherLenInBits.len,
2554                                         tdata->validCipherOffsetLenInBits.len,
2555                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2556         if (retval < 0)
2557                 return retval;
2558
2559         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2560                                                 ut_params->op);
2561         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2562         ut_params->obuf = ut_params->op->sym->m_dst;
2563         if (ut_params->obuf)
2564                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2565                                 + tdata->iv.len;
2566         else
2567                 plaintext = ciphertext;
2568
2569         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2570
2571         /* Validate obuf */
2572         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
2573                                 tdata->plaintext.data,
2574                                 tdata->validDataLenInBits.len,
2575                                 "Snow3G Plaintext data not as expected");
2576         return 0;
2577 }
2578
2579 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
2580 {
2581         struct crypto_testsuite_params *ts_params = &testsuite_params;
2582         struct crypto_unittest_params *ut_params = &unittest_params;
2583
2584         int retval;
2585
2586         uint8_t *plaintext, *ciphertext;
2587         unsigned ciphertext_pad_len;
2588         unsigned ciphertext_len;
2589
2590         /* Create SNOW3G session */
2591         retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0],
2592                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
2593                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2594                                         tdata->key.data, tdata->key.len);
2595         if (retval < 0)
2596                 return retval;
2597
2598         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2599         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2600
2601         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2602                         "Failed to allocate input buffer");
2603         TEST_ASSERT_NOT_NULL(ut_params->obuf,
2604                         "Failed to allocate output buffer");
2605
2606         /* Clear mbuf payload */
2607         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2608                rte_pktmbuf_tailroom(ut_params->ibuf));
2609
2610         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
2611                        rte_pktmbuf_tailroom(ut_params->obuf));
2612
2613         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2614         /* Append data which is padded to a multiple of */
2615         /* the algorithms block size */
2616         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
2617         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2618                                 ciphertext_pad_len);
2619         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
2620         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2621
2622         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
2623
2624         /* Create SNOW3G operation */
2625         retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data,
2626                                         tdata->iv.len,
2627                                         tdata->validCipherLenInBits.len,
2628                                         tdata->validCipherOffsetLenInBits.len,
2629                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2630         if (retval < 0)
2631                 return retval;
2632
2633         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2634                                                 ut_params->op);
2635         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2636         ut_params->obuf = ut_params->op->sym->m_dst;
2637         if (ut_params->obuf)
2638                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2639                                 + tdata->iv.len;
2640         else
2641                 plaintext = ciphertext;
2642
2643         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2644
2645         /* Validate obuf */
2646         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
2647                                 tdata->plaintext.data,
2648                                 tdata->validDataLenInBits.len,
2649                                 "Snow3G Plaintext data not as expected");
2650         return 0;
2651 }
2652
2653 static int
2654 test_snow3g_authenticated_encryption(const struct snow3g_test_data *tdata)
2655 {
2656         struct crypto_testsuite_params *ts_params = &testsuite_params;
2657         struct crypto_unittest_params *ut_params = &unittest_params;
2658
2659         int retval;
2660
2661         uint8_t *plaintext, *ciphertext;
2662         unsigned plaintext_pad_len;
2663         unsigned plaintext_len;
2664
2665         /* Create SNOW3G session */
2666         retval = create_snow3g_kasumi_cipher_auth_session(ts_params->valid_devs[0],
2667                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2668                         RTE_CRYPTO_AUTH_OP_GENERATE,
2669                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2670                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2671                         tdata->key.data, tdata->key.len,
2672                         tdata->aad.len, tdata->digest.len);
2673         if (retval < 0)
2674                 return retval;
2675         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2676
2677         /* clear mbuf payload */
2678         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2679                         rte_pktmbuf_tailroom(ut_params->ibuf));
2680
2681         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2682         /* Append data which is padded to a multiple of */
2683         /* the algorithms block size */
2684         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2685         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2686                                 plaintext_pad_len);
2687         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2688
2689         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2690
2691         /* Create SNOW3G operation */
2692         retval = create_snow3g_kasumi_cipher_hash_operation(tdata->digest.data,
2693                         tdata->digest.len, tdata->aad.data,
2694                         tdata->aad.len, /*tdata->plaintext.len,*/
2695                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2696                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2697                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2698                         tdata->iv.data, tdata->iv.len,
2699                         tdata->validCipherLenInBits.len,
2700                         tdata->validCipherOffsetLenInBits.len,
2701                         tdata->validAuthLenInBits.len,
2702                         tdata->validAuthOffsetLenInBits.len
2703                         );
2704         if (retval < 0)
2705                 return retval;
2706
2707         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2708                         ut_params->op);
2709         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2710         ut_params->obuf = ut_params->op->sym->m_src;
2711         if (ut_params->obuf)
2712                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2713                                 + tdata->iv.len;
2714         else
2715                 ciphertext = plaintext;
2716
2717         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
2718
2719         /* Validate obuf */
2720         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2721                         ciphertext,
2722                         tdata->ciphertext.data,
2723                         tdata->validDataLenInBits.len,
2724                         "Snow3G Ciphertext data not as expected");
2725
2726         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2727             + plaintext_pad_len + tdata->aad.len;
2728
2729         /* Validate obuf */
2730         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2731                         ut_params->digest,
2732                         tdata->digest.data,
2733                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2734                         "Snow3G Generated auth tag not as expected");
2735         return 0;
2736 }
2737 static int
2738 test_snow3g_encrypted_authentication(const struct snow3g_test_data *tdata)
2739 {
2740         struct crypto_testsuite_params *ts_params = &testsuite_params;
2741         struct crypto_unittest_params *ut_params = &unittest_params;
2742
2743         int retval;
2744
2745         uint8_t *plaintext, *ciphertext;
2746         unsigned plaintext_pad_len;
2747         unsigned plaintext_len;
2748
2749         /* Create SNOW3G session */
2750         retval = create_snow3g_kasumi_auth_cipher_session(ts_params->valid_devs[0],
2751                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2752                         RTE_CRYPTO_AUTH_OP_GENERATE,
2753                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2754                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2755                         tdata->key.data, tdata->key.len,
2756                         tdata->aad.len, tdata->digest.len);
2757         if (retval < 0)
2758                 return retval;
2759
2760         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2761
2762         /* clear mbuf payload */
2763         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2764                         rte_pktmbuf_tailroom(ut_params->ibuf));
2765
2766         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2767         /* Append data which is padded to a multiple of */
2768         /* the algorithms block size */
2769         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2770         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2771                                 plaintext_pad_len);
2772         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2773
2774         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2775
2776         /* Create SNOW3G operation */
2777         retval = create_snow3g_kasumi_auth_cipher_operation(
2778                 tdata->digest.len,
2779                 tdata->iv.data, tdata->iv.len,
2780                 tdata->aad.data, tdata->aad.len,
2781                 plaintext_pad_len,
2782                 tdata->validCipherLenInBits.len,
2783                 tdata->validCipherOffsetLenInBits.len,
2784                 tdata->validAuthLenInBits.len,
2785                 tdata->validAuthOffsetLenInBits.len,
2786                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2787                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
2788         );
2789
2790         if (retval < 0)
2791                 return retval;
2792
2793         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2794                         ut_params->op);
2795         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2796         ut_params->obuf = ut_params->op->sym->m_src;
2797         if (ut_params->obuf)
2798                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2799                                 + tdata->aad.len + tdata->iv.len;
2800         else
2801                 ciphertext = plaintext;
2802
2803         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2804                         + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
2805         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
2806
2807         /* Validate obuf */
2808         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2809                 ciphertext,
2810                 tdata->ciphertext.data,
2811                 tdata->validDataLenInBits.len,
2812                 "Snow3G Ciphertext data not as expected");
2813
2814         /* Validate obuf */
2815         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2816                 ut_params->digest,
2817                 tdata->digest.data,
2818                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2819                 "Snow3G Generated auth tag not as expected");
2820         return 0;
2821 }
2822
2823 static int
2824 test_kasumi_encryption_test_case_1(void)
2825 {
2826         return test_kasumi_encryption(&kasumi_test_case_1);
2827 }
2828
2829 static int
2830 test_kasumi_encryption_test_case_1_oop(void)
2831 {
2832         return test_kasumi_encryption_oop(&kasumi_test_case_1);
2833 }
2834
2835 static int
2836 test_kasumi_encryption_test_case_2(void)
2837 {
2838         return test_kasumi_encryption(&kasumi_test_case_2);
2839 }
2840
2841 static int
2842 test_kasumi_encryption_test_case_3(void)
2843 {
2844         return test_kasumi_encryption(&kasumi_test_case_3);
2845 }
2846
2847 static int
2848 test_kasumi_encryption_test_case_4(void)
2849 {
2850         return test_kasumi_encryption(&kasumi_test_case_4);
2851 }
2852
2853 static int
2854 test_kasumi_encryption_test_case_5(void)
2855 {
2856         return test_kasumi_encryption(&kasumi_test_case_5);
2857 }
2858
2859 static int
2860 test_kasumi_decryption_test_case_1(void)
2861 {
2862         return test_kasumi_decryption(&kasumi_test_case_1);
2863 }
2864
2865 static int
2866 test_kasumi_decryption_test_case_1_oop(void)
2867 {
2868         return test_kasumi_decryption_oop(&kasumi_test_case_1);
2869 }
2870
2871 static int
2872 test_kasumi_decryption_test_case_2(void)
2873 {
2874         return test_kasumi_decryption(&kasumi_test_case_2);
2875 }
2876
2877 static int
2878 test_kasumi_decryption_test_case_3(void)
2879 {
2880         return test_kasumi_decryption(&kasumi_test_case_3);
2881 }
2882
2883 static int
2884 test_kasumi_decryption_test_case_4(void)
2885 {
2886         return test_kasumi_decryption(&kasumi_test_case_4);
2887 }
2888
2889 static int
2890 test_kasumi_decryption_test_case_5(void)
2891 {
2892         return test_kasumi_decryption(&kasumi_test_case_5);
2893 }
2894 static int
2895 test_snow3g_encryption_test_case_1(void)
2896 {
2897         return test_snow3g_encryption(&snow3g_test_case_1);
2898 }
2899
2900 static int
2901 test_snow3g_encryption_test_case_1_oop(void)
2902 {
2903         return test_snow3g_encryption_oop(&snow3g_test_case_1);
2904 }
2905
2906 static int
2907 test_snow3g_encryption_test_case_1_offset_oop(void)
2908 {
2909         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
2910 }
2911
2912 static int
2913 test_snow3g_encryption_test_case_2(void)
2914 {
2915         return test_snow3g_encryption(&snow3g_test_case_2);
2916 }
2917
2918 static int
2919 test_snow3g_encryption_test_case_3(void)
2920 {
2921         return test_snow3g_encryption(&snow3g_test_case_3);
2922 }
2923
2924 static int
2925 test_snow3g_encryption_test_case_4(void)
2926 {
2927         return test_snow3g_encryption(&snow3g_test_case_4);
2928 }
2929
2930 static int
2931 test_snow3g_encryption_test_case_5(void)
2932 {
2933         return test_snow3g_encryption(&snow3g_test_case_5);
2934 }
2935
2936 static int
2937 test_snow3g_decryption_test_case_1(void)
2938 {
2939         return test_snow3g_decryption(&snow3g_test_case_1);
2940 }
2941
2942 static int
2943 test_snow3g_decryption_test_case_1_oop(void)
2944 {
2945         return test_snow3g_decryption_oop(&snow3g_test_case_1);
2946 }
2947
2948 static int
2949 test_snow3g_decryption_test_case_2(void)
2950 {
2951         return test_snow3g_decryption(&snow3g_test_case_2);
2952 }
2953
2954 static int
2955 test_snow3g_decryption_test_case_3(void)
2956 {
2957         return test_snow3g_decryption(&snow3g_test_case_3);
2958 }
2959
2960 static int
2961 test_snow3g_decryption_test_case_4(void)
2962 {
2963         return test_snow3g_decryption(&snow3g_test_case_4);
2964 }
2965
2966 static int
2967 test_snow3g_decryption_test_case_5(void)
2968 {
2969         return test_snow3g_decryption(&snow3g_test_case_5);
2970 }
2971 static int
2972 test_snow3g_authenticated_encryption_test_case_1(void)
2973 {
2974         return test_snow3g_authenticated_encryption(&snow3g_test_case_3);
2975 }
2976
2977 static int
2978 test_snow3g_encrypted_authentication_test_case_1(void)
2979 {
2980         return test_snow3g_encrypted_authentication(&snow3g_test_case_6);
2981 }
2982
2983 /* ***** AES-GCM Tests ***** */
2984
2985 static int
2986 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
2987                 const uint8_t *key, const uint8_t key_len,
2988                 const uint8_t aad_len, const uint8_t auth_len)
2989 {
2990         uint8_t cipher_key[key_len];
2991
2992         struct crypto_unittest_params *ut_params = &unittest_params;
2993
2994
2995         memcpy(cipher_key, key, key_len);
2996
2997         /* Setup Cipher Parameters */
2998         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2999         ut_params->cipher_xform.next = NULL;
3000
3001         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
3002         ut_params->cipher_xform.cipher.op = op;
3003         ut_params->cipher_xform.cipher.key.data = cipher_key;
3004         ut_params->cipher_xform.cipher.key.length = key_len;
3005
3006         TEST_HEXDUMP(stdout, "key:", key, key_len);
3007
3008         /* Setup Authentication Parameters */
3009         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3010         ut_params->auth_xform.next = NULL;
3011
3012         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
3013
3014         ut_params->auth_xform.auth.digest_length = auth_len;
3015         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
3016         ut_params->auth_xform.auth.key.length = 0;
3017         ut_params->auth_xform.auth.key.data = NULL;
3018
3019         if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
3020                 ut_params->cipher_xform.next = &ut_params->auth_xform;
3021
3022                 /* Create Crypto session*/
3023                 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3024                                 &ut_params->cipher_xform);
3025         } else {/* Create Crypto session*/
3026                 ut_params->auth_xform.next = &ut_params->cipher_xform;
3027                 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3028                                 &ut_params->auth_xform);
3029         }
3030
3031         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3032
3033         return 0;
3034 }
3035
3036 static int
3037 create_gcm_operation(enum rte_crypto_cipher_operation op,
3038                 const uint8_t *auth_tag, const unsigned auth_tag_len,
3039                 const uint8_t *iv, const unsigned iv_len,
3040                 const uint8_t *aad, const unsigned aad_len,
3041                 const unsigned data_len, unsigned data_pad_len)
3042 {
3043         struct crypto_testsuite_params *ts_params = &testsuite_params;
3044         struct crypto_unittest_params *ut_params = &unittest_params;
3045
3046         unsigned iv_pad_len = 0, aad_buffer_len;
3047
3048         /* Generate Crypto op data structure */
3049         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3050                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3051         TEST_ASSERT_NOT_NULL(ut_params->op,
3052                         "Failed to allocate symmetric crypto operation struct");
3053
3054         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3055
3056
3057
3058         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
3059                         ut_params->ibuf, auth_tag_len);
3060         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
3061                         "no room to append digest");
3062         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
3063                         ut_params->ibuf, data_pad_len);
3064         sym_op->auth.digest.length = auth_tag_len;
3065
3066         if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
3067                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3068                 TEST_HEXDUMP(stdout, "digest:",
3069                                 sym_op->auth.digest.data,
3070                                 sym_op->auth.digest.length);
3071         }
3072
3073         /* iv */
3074         iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
3075
3076         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
3077                         ut_params->ibuf, iv_pad_len);
3078         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
3079
3080         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
3081         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
3082         sym_op->cipher.iv.length = iv_pad_len;
3083
3084         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
3085
3086         /* CalcY0 */
3087         if (iv_len != 16)
3088                 sym_op->cipher.iv.data[15] = 1;
3089
3090         /*
3091          * Always allocate the aad up to the block size.
3092          * The cryptodev API calls out -
3093          *  - the array must be big enough to hold the AAD, plus any
3094          *   space to round this up to the nearest multiple of the
3095          *   block size (16 bytes).
3096          */
3097         aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
3098
3099         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
3100                         ut_params->ibuf, aad_buffer_len);
3101         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
3102                         "no room to prepend aad");
3103         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
3104                         ut_params->ibuf);
3105         sym_op->auth.aad.length = aad_len;
3106
3107         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
3108         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
3109
3110         TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
3111         TEST_HEXDUMP(stdout, "aad:",
3112                         sym_op->auth.aad.data, aad_len);
3113
3114         sym_op->cipher.data.length = data_len;
3115         sym_op->cipher.data.offset = aad_buffer_len + iv_pad_len;
3116
3117         sym_op->auth.data.offset = aad_buffer_len + iv_pad_len;
3118         sym_op->auth.data.length = data_len;
3119
3120         return 0;
3121 }
3122
3123 static int
3124 test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
3125 {
3126         struct crypto_testsuite_params *ts_params = &testsuite_params;
3127         struct crypto_unittest_params *ut_params = &unittest_params;
3128
3129         int retval;
3130
3131         uint8_t *plaintext, *ciphertext, *auth_tag;
3132         uint16_t plaintext_pad_len;
3133
3134         /* Create GCM session */
3135         retval = create_gcm_session(ts_params->valid_devs[0],
3136                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3137                         tdata->key.data, tdata->key.len,
3138                         tdata->aad.len, tdata->auth_tag.len);
3139         if (retval < 0)
3140                 return retval;
3141
3142
3143         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3144
3145         /* clear mbuf payload */
3146         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3147                         rte_pktmbuf_tailroom(ut_params->ibuf));
3148
3149         /*
3150          * Append data which is padded to a multiple
3151          * of the algorithms block size
3152          */
3153         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
3154
3155         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3156                         plaintext_pad_len);
3157         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
3158
3159         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3160
3161         /* Create GCM opertaion */
3162         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3163                         tdata->auth_tag.data, tdata->auth_tag.len,
3164                         tdata->iv.data, tdata->iv.len,
3165                         tdata->aad.data, tdata->aad.len,
3166                         tdata->plaintext.len, plaintext_pad_len);
3167         if (retval < 0)
3168                 return retval;
3169
3170         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3171
3172         ut_params->op->sym->m_src = ut_params->ibuf;
3173
3174         /* Process crypto operation */
3175         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
3176                         ut_params->op), "failed to process sym crypto op");
3177
3178         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3179                         "crypto op processing failed");
3180
3181         if (ut_params->op->sym->m_dst) {
3182                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
3183                                 uint8_t *);
3184                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
3185                                 uint8_t *, plaintext_pad_len);
3186         } else {
3187                 ciphertext = plaintext;
3188                 auth_tag = plaintext + plaintext_pad_len;
3189         }
3190
3191         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
3192         TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
3193
3194         /* Validate obuf */
3195         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3196                         ciphertext,
3197                         tdata->ciphertext.data,
3198                         tdata->ciphertext.len,
3199                         "GCM Ciphertext data not as expected");
3200
3201         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3202                         auth_tag,
3203                         tdata->auth_tag.data,
3204                         tdata->auth_tag.len,
3205                         "GCM Generated auth tag not as expected");
3206
3207         return 0;
3208
3209 }
3210
3211 static int
3212 test_mb_AES_GCM_authenticated_encryption_test_case_1(void)
3213 {
3214         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1);
3215 }
3216
3217 static int
3218 test_mb_AES_GCM_authenticated_encryption_test_case_2(void)
3219 {
3220         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2);
3221 }
3222
3223 static int
3224 test_mb_AES_GCM_authenticated_encryption_test_case_3(void)
3225 {
3226         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3);
3227 }
3228
3229 static int
3230 test_mb_AES_GCM_authenticated_encryption_test_case_4(void)
3231 {
3232         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4);
3233 }
3234
3235 static int
3236 test_mb_AES_GCM_authenticated_encryption_test_case_5(void)
3237 {
3238         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5);
3239 }
3240
3241 static int
3242 test_mb_AES_GCM_authenticated_encryption_test_case_6(void)
3243 {
3244         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6);
3245 }
3246
3247 static int
3248 test_mb_AES_GCM_authenticated_encryption_test_case_7(void)
3249 {
3250         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7);
3251 }
3252
3253 static int
3254 test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
3255 {
3256         struct crypto_testsuite_params *ts_params = &testsuite_params;
3257         struct crypto_unittest_params *ut_params = &unittest_params;
3258
3259         int retval;
3260
3261         uint8_t *plaintext, *ciphertext;
3262         uint16_t ciphertext_pad_len;
3263
3264         /* Create GCM session */
3265         retval = create_gcm_session(ts_params->valid_devs[0],
3266                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3267                         tdata->key.data, tdata->key.len,
3268                         tdata->aad.len, tdata->auth_tag.len);
3269         if (retval < 0)
3270                 return retval;
3271
3272
3273         /* alloc mbuf and set payload */
3274         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3275
3276         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3277                         rte_pktmbuf_tailroom(ut_params->ibuf));
3278
3279         ciphertext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
3280
3281         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3282                         ciphertext_pad_len);
3283         memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len);
3284
3285         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
3286
3287         /* Create GCM opertaion */
3288         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT,
3289                         tdata->auth_tag.data, tdata->auth_tag.len,
3290                         tdata->iv.data, tdata->iv.len,
3291                         tdata->aad.data, tdata->aad.len,
3292                         tdata->ciphertext.len, ciphertext_pad_len);
3293         if (retval < 0)
3294                 return retval;
3295
3296
3297         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3298
3299         ut_params->op->sym->m_src = ut_params->ibuf;
3300
3301         /* Process crypto operation */
3302         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
3303                         ut_params->op), "failed to process sym crypto op");
3304
3305         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3306                         "crypto op processing failed");
3307
3308         if (ut_params->op->sym->m_dst)
3309                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
3310                                 uint8_t *);
3311         else
3312                 plaintext = ciphertext;
3313
3314         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
3315
3316         /* Validate obuf */
3317         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3318                         plaintext,
3319                         tdata->plaintext.data,
3320                         tdata->plaintext.len,
3321                         "GCM plaintext data not as expected");
3322
3323         TEST_ASSERT_EQUAL(ut_params->op->status,
3324                         RTE_CRYPTO_OP_STATUS_SUCCESS,
3325                         "GCM authentication failed");
3326         return 0;
3327 }
3328
3329 static int
3330 test_mb_AES_GCM_authenticated_decryption_test_case_1(void)
3331 {
3332         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1);
3333 }
3334
3335 static int
3336 test_mb_AES_GCM_authenticated_decryption_test_case_2(void)
3337 {
3338         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2);
3339 }
3340
3341 static int
3342 test_mb_AES_GCM_authenticated_decryption_test_case_3(void)
3343 {
3344         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3);
3345 }
3346
3347 static int
3348 test_mb_AES_GCM_authenticated_decryption_test_case_4(void)
3349 {
3350         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4);
3351 }
3352
3353 static int
3354 test_mb_AES_GCM_authenticated_decryption_test_case_5(void)
3355 {
3356         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5);
3357 }
3358
3359 static int
3360 test_mb_AES_GCM_authenticated_decryption_test_case_6(void)
3361 {
3362         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6);
3363 }
3364
3365 static int
3366 test_mb_AES_GCM_authenticated_decryption_test_case_7(void)
3367 {
3368         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7);
3369 }
3370
3371 static int
3372 test_stats(void)
3373 {
3374         struct crypto_testsuite_params *ts_params = &testsuite_params;
3375         struct rte_cryptodev_stats stats;
3376         struct rte_cryptodev *dev;
3377         cryptodev_stats_get_t temp_pfn;
3378
3379         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
3380         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
3381                         &stats) == -ENODEV),
3382                 "rte_cryptodev_stats_get invalid dev failed");
3383         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
3384                 "rte_cryptodev_stats_get invalid Param failed");
3385         dev = &rte_cryptodevs[ts_params->valid_devs[0]];
3386         temp_pfn = dev->dev_ops->stats_get;
3387         dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
3388         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
3389                         == -ENOTSUP),
3390                 "rte_cryptodev_stats_get invalid Param failed");
3391         dev->dev_ops->stats_get = temp_pfn;
3392
3393         /* Test expected values */
3394         ut_setup();
3395         test_AES_CBC_HMAC_SHA1_encrypt_digest();
3396         ut_teardown();
3397         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
3398                         &stats),
3399                 "rte_cryptodev_stats_get failed");
3400         TEST_ASSERT((stats.enqueued_count == 1),
3401                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3402         TEST_ASSERT((stats.dequeued_count == 1),
3403                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3404         TEST_ASSERT((stats.enqueue_err_count == 0),
3405                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3406         TEST_ASSERT((stats.dequeue_err_count == 0),
3407                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3408
3409         /* invalid device but should ignore and not reset device stats*/
3410         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
3411         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
3412                         &stats),
3413                 "rte_cryptodev_stats_get failed");
3414         TEST_ASSERT((stats.enqueued_count == 1),
3415                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3416
3417         /* check that a valid reset clears stats */
3418         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
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 == 0),
3423                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3424         TEST_ASSERT((stats.dequeued_count == 0),
3425                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
3426
3427         return TEST_SUCCESS;
3428 }
3429
3430
3431 static int
3432 test_multi_session(void)
3433 {
3434         struct crypto_testsuite_params *ts_params = &testsuite_params;
3435         struct crypto_unittest_params *ut_params = &unittest_params;
3436
3437         struct rte_cryptodev_info dev_info;
3438         struct rte_cryptodev_sym_session **sessions;
3439
3440         uint16_t i;
3441
3442         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params);
3443
3444
3445         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3446
3447         sessions = rte_malloc(NULL,
3448                         (sizeof(struct rte_cryptodev_sym_session *) *
3449                         dev_info.sym.max_nb_sessions) + 1, 0);
3450
3451         /* Create multiple crypto sessions*/
3452         for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
3453                 sessions[i] = rte_cryptodev_sym_session_create(
3454                                 ts_params->valid_devs[0],
3455                         &ut_params->auth_xform);
3456                 TEST_ASSERT_NOT_NULL(sessions[i],
3457                                 "Session creation failed at session number %u",
3458                                 i);
3459
3460                 /* Attempt to send a request on each session */
3461                 TEST_ASSERT_SUCCESS(test_AES_CBC_HMAC_SHA512_decrypt_perform(
3462                                 sessions[i], ut_params, ts_params),
3463                                 "Failed to perform decrypt on request "
3464                                 "number %u.", i);
3465                 /* free crypto operation structure */
3466                 if (ut_params->op)
3467                         rte_crypto_op_free(ut_params->op);
3468
3469                 /*
3470                  * free mbuf - both obuf and ibuf are usually the same,
3471                  * but rte copes even if we call free twice
3472                  */
3473                 if (ut_params->obuf) {
3474                         rte_pktmbuf_free(ut_params->obuf);
3475                         ut_params->obuf = 0;
3476                 }
3477         }
3478
3479         /* Next session create should fail */
3480         sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
3481                         &ut_params->auth_xform);
3482         TEST_ASSERT_NULL(sessions[i],
3483                         "Session creation succeeded unexpectedly!");
3484
3485         for (i = 0; i < dev_info.sym.max_nb_sessions; i++)
3486                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
3487                                 sessions[i]);
3488
3489         rte_free(sessions);
3490
3491         return TEST_SUCCESS;
3492 }
3493
3494 static int
3495 test_null_cipher_only_operation(void)
3496 {
3497         struct crypto_testsuite_params *ts_params = &testsuite_params;
3498         struct crypto_unittest_params *ut_params = &unittest_params;
3499
3500         /* Generate test mbuf data and space for digest */
3501         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
3502                         catch_22_quote, QUOTE_512_BYTES, 0);
3503
3504         /* Setup Cipher Parameters */
3505         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3506         ut_params->cipher_xform.next = NULL;
3507
3508         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
3509         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
3510
3511         /* Create Crypto session*/
3512         ut_params->sess = rte_cryptodev_sym_session_create(
3513                         ts_params->valid_devs[0], &ut_params->cipher_xform);
3514         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3515
3516         /* Generate Crypto op data structure */
3517         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3518                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3519         TEST_ASSERT_NOT_NULL(ut_params->op,
3520                         "Failed to allocate symmetric crypto operation struct");
3521
3522         /* Set crypto operation data parameters */
3523         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3524
3525         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3526
3527         /* set crypto operation source mbuf */
3528         sym_op->m_src = ut_params->ibuf;
3529
3530         sym_op->cipher.data.offset = 0;
3531         sym_op->cipher.data.length = QUOTE_512_BYTES;
3532
3533         /* Process crypto operation */
3534         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3535                         ut_params->op);
3536         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
3537
3538         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3539                         "crypto operation processing failed");
3540
3541         /* Validate obuf */
3542         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3543                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
3544                         catch_22_quote,
3545                         QUOTE_512_BYTES,
3546                         "Ciphertext data not as expected");
3547
3548         return TEST_SUCCESS;
3549 }
3550
3551 static int
3552 test_null_auth_only_operation(void)
3553 {
3554         struct crypto_testsuite_params *ts_params = &testsuite_params;
3555         struct crypto_unittest_params *ut_params = &unittest_params;
3556
3557         /* Generate test mbuf data and space for digest */
3558         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
3559                         catch_22_quote, QUOTE_512_BYTES, 0);
3560
3561         /* Setup HMAC Parameters */
3562         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3563         ut_params->auth_xform.next = NULL;
3564
3565         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
3566         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
3567
3568         /* Create Crypto session*/
3569         ut_params->sess = rte_cryptodev_sym_session_create(
3570                         ts_params->valid_devs[0], &ut_params->auth_xform);
3571         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3572
3573         /* Generate Crypto op data structure */
3574         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3575                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3576         TEST_ASSERT_NOT_NULL(ut_params->op,
3577                         "Failed to allocate symmetric crypto operation struct");
3578
3579         /* Set crypto operation data parameters */
3580         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3581
3582         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3583
3584         sym_op->m_src = ut_params->ibuf;
3585
3586         sym_op->auth.data.offset = 0;
3587         sym_op->auth.data.length = QUOTE_512_BYTES;
3588
3589         /* Process crypto operation */
3590         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3591                         ut_params->op);
3592         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
3593
3594         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3595                         "crypto operation processing failed");
3596
3597         return TEST_SUCCESS;
3598 }
3599
3600 static int
3601 test_null_cipher_auth_operation(void)
3602 {
3603         struct crypto_testsuite_params *ts_params = &testsuite_params;
3604         struct crypto_unittest_params *ut_params = &unittest_params;
3605
3606         /* Generate test mbuf data and space for digest */
3607         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
3608                         catch_22_quote, QUOTE_512_BYTES, 0);
3609
3610         /* Setup Cipher Parameters */
3611         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3612         ut_params->cipher_xform.next = &ut_params->auth_xform;
3613
3614         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
3615         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
3616
3617         /* Setup HMAC Parameters */
3618         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3619         ut_params->auth_xform.next = NULL;
3620
3621         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
3622         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
3623
3624         /* Create Crypto session*/
3625         ut_params->sess = rte_cryptodev_sym_session_create(
3626                         ts_params->valid_devs[0], &ut_params->cipher_xform);
3627         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3628
3629         /* Generate Crypto op data structure */
3630         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3631                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3632         TEST_ASSERT_NOT_NULL(ut_params->op,
3633                         "Failed to allocate symmetric crypto operation struct");
3634
3635         /* Set crypto operation data parameters */
3636         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3637
3638         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3639
3640         sym_op->m_src = ut_params->ibuf;
3641
3642         sym_op->cipher.data.offset = 0;
3643         sym_op->cipher.data.length = QUOTE_512_BYTES;
3644
3645         sym_op->auth.data.offset = 0;
3646         sym_op->auth.data.length = QUOTE_512_BYTES;
3647
3648         /* Process crypto operation */
3649         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3650                         ut_params->op);
3651         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
3652
3653         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3654                         "crypto operation processing failed");
3655
3656         /* Validate obuf */
3657         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3658                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
3659                         catch_22_quote,
3660                         QUOTE_512_BYTES,
3661                         "Ciphertext data not as expected");
3662
3663         return TEST_SUCCESS;
3664 }
3665
3666 static int
3667 test_null_auth_cipher_operation(void)
3668 {
3669         struct crypto_testsuite_params *ts_params = &testsuite_params;
3670         struct crypto_unittest_params *ut_params = &unittest_params;
3671
3672         /* Generate test mbuf data and space for digest */
3673         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
3674                         catch_22_quote, QUOTE_512_BYTES, 0);
3675
3676         /* Setup Cipher Parameters */
3677         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3678         ut_params->cipher_xform.next = NULL;
3679
3680         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
3681         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
3682
3683         /* Setup HMAC Parameters */
3684         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3685         ut_params->auth_xform.next = &ut_params->cipher_xform;
3686
3687         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
3688         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
3689
3690         /* Create Crypto session*/
3691         ut_params->sess = rte_cryptodev_sym_session_create(
3692                         ts_params->valid_devs[0], &ut_params->cipher_xform);
3693         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3694
3695         /* Generate Crypto op data structure */
3696         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3697                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3698         TEST_ASSERT_NOT_NULL(ut_params->op,
3699                         "Failed to allocate symmetric crypto operation struct");
3700
3701         /* Set crypto operation data parameters */
3702         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3703
3704         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3705
3706         sym_op->m_src = ut_params->ibuf;
3707
3708         sym_op->cipher.data.offset = 0;
3709         sym_op->cipher.data.length = QUOTE_512_BYTES;
3710
3711         sym_op->auth.data.offset = 0;
3712         sym_op->auth.data.length = QUOTE_512_BYTES;
3713
3714         /* Process crypto operation */
3715         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3716                         ut_params->op);
3717         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
3718
3719         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
3720                         "crypto operation processing failed");
3721
3722         /* Validate obuf */
3723         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3724                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
3725                         catch_22_quote,
3726                         QUOTE_512_BYTES,
3727                         "Ciphertext data not as expected");
3728
3729         return TEST_SUCCESS;
3730 }
3731
3732
3733 static int
3734 test_null_invalid_operation(void)
3735 {
3736         struct crypto_testsuite_params *ts_params = &testsuite_params;
3737         struct crypto_unittest_params *ut_params = &unittest_params;
3738
3739         /* Setup Cipher Parameters */
3740         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3741         ut_params->cipher_xform.next = NULL;
3742
3743         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
3744         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
3745
3746         /* Create Crypto session*/
3747         ut_params->sess = rte_cryptodev_sym_session_create(
3748                         ts_params->valid_devs[0], &ut_params->cipher_xform);
3749         TEST_ASSERT_NULL(ut_params->sess,
3750                         "Session creation succeeded unexpectedly");
3751
3752
3753         /* Setup HMAC Parameters */
3754         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3755         ut_params->auth_xform.next = NULL;
3756
3757         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
3758         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
3759
3760         /* Create Crypto session*/
3761         ut_params->sess = rte_cryptodev_sym_session_create(
3762                         ts_params->valid_devs[0], &ut_params->auth_xform);
3763         TEST_ASSERT_NULL(ut_params->sess,
3764                         "Session creation succeeded unexpectedly");
3765
3766         return TEST_SUCCESS;
3767 }
3768
3769
3770 #define NULL_BURST_LENGTH (32)
3771
3772 static int
3773 test_null_burst_operation(void)
3774 {
3775         struct crypto_testsuite_params *ts_params = &testsuite_params;
3776         struct crypto_unittest_params *ut_params = &unittest_params;
3777
3778         unsigned i, burst_len = NULL_BURST_LENGTH;
3779
3780         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
3781         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
3782
3783         /* Setup Cipher Parameters */
3784         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3785         ut_params->cipher_xform.next = &ut_params->auth_xform;
3786
3787         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
3788         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
3789
3790         /* Setup HMAC Parameters */
3791         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3792         ut_params->auth_xform.next = NULL;
3793
3794         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
3795         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
3796
3797         /* Create Crypto session*/
3798         ut_params->sess = rte_cryptodev_sym_session_create(
3799                         ts_params->valid_devs[0], &ut_params->cipher_xform);
3800         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3801
3802         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3803                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
3804                         burst_len, "failed to generate burst of crypto ops");
3805
3806         /* Generate an operation for each mbuf in burst */
3807         for (i = 0; i < burst_len; i++) {
3808                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3809
3810                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
3811
3812                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
3813                                 sizeof(unsigned));
3814                 *data = i;
3815
3816                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
3817
3818                 burst[i]->sym->m_src = m;
3819         }
3820
3821         /* Process crypto operation */
3822         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
3823                         0, burst, burst_len),
3824                         burst_len,
3825                         "Error enqueuing burst");
3826
3827         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
3828                         0, burst_dequeued, burst_len),
3829                         burst_len,
3830                         "Error dequeuing burst");
3831
3832
3833         for (i = 0; i < burst_len; i++) {
3834                 TEST_ASSERT_EQUAL(
3835                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
3836                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
3837                                         uint32_t *),
3838                         "data not as expected");
3839
3840                 rte_pktmbuf_free(burst[i]->sym->m_src);
3841                 rte_crypto_op_free(burst[i]);
3842         }
3843
3844         return TEST_SUCCESS;
3845 }
3846
3847
3848
3849
3850 static struct unit_test_suite cryptodev_qat_testsuite  = {
3851         .suite_name = "Crypto QAT Unit Test Suite",
3852         .setup = testsuite_setup,
3853         .teardown = testsuite_teardown,
3854         .unit_test_cases = {
3855                 TEST_CASE_ST(ut_setup, ut_teardown,
3856                                 test_device_configure_invalid_dev_id),
3857                 TEST_CASE_ST(ut_setup, ut_teardown,
3858                                 test_device_configure_invalid_queue_pair_ids),
3859                 TEST_CASE_ST(ut_setup, ut_teardown,
3860                                 test_queue_pair_descriptor_setup),
3861                 TEST_CASE_ST(ut_setup, ut_teardown,
3862                                 test_multi_session),
3863
3864                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_qat_all),
3865                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
3866
3867                 /** AES GCM Authenticated Encryption */
3868                 TEST_CASE_ST(ut_setup, ut_teardown,
3869                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
3870                 TEST_CASE_ST(ut_setup, ut_teardown,
3871                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
3872                 TEST_CASE_ST(ut_setup, ut_teardown,
3873                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
3874                 TEST_CASE_ST(ut_setup, ut_teardown,
3875                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
3876                 TEST_CASE_ST(ut_setup, ut_teardown,
3877                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
3878                 TEST_CASE_ST(ut_setup, ut_teardown,
3879                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
3880                 TEST_CASE_ST(ut_setup, ut_teardown,
3881                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
3882
3883                 /** AES GCM Authenticated Decryption */
3884                 TEST_CASE_ST(ut_setup, ut_teardown,
3885                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
3886                 TEST_CASE_ST(ut_setup, ut_teardown,
3887                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
3888                 TEST_CASE_ST(ut_setup, ut_teardown,
3889                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
3890                 TEST_CASE_ST(ut_setup, ut_teardown,
3891                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
3892                 TEST_CASE_ST(ut_setup, ut_teardown,
3893                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
3894                 TEST_CASE_ST(ut_setup, ut_teardown,
3895                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
3896                 TEST_CASE_ST(ut_setup, ut_teardown,
3897                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
3898
3899                 /** Snow3G encrypt only (UEA2) */
3900                 TEST_CASE_ST(ut_setup, ut_teardown,
3901                         test_snow3g_encryption_test_case_1),
3902                 TEST_CASE_ST(ut_setup, ut_teardown,
3903                         test_snow3g_encryption_test_case_2),
3904                 TEST_CASE_ST(ut_setup, ut_teardown,
3905                         test_snow3g_encryption_test_case_3),
3906                 TEST_CASE_ST(ut_setup, ut_teardown,
3907                         test_snow3g_encryption_test_case_4),
3908                 TEST_CASE_ST(ut_setup, ut_teardown,
3909                         test_snow3g_encryption_test_case_5),
3910
3911                 TEST_CASE_ST(ut_setup, ut_teardown,
3912                         test_snow3g_encryption_test_case_1_oop),
3913                 TEST_CASE_ST(ut_setup, ut_teardown,
3914                         test_snow3g_decryption_test_case_1_oop),
3915
3916                 /** Snow3G decrypt only (UEA2) */
3917                 TEST_CASE_ST(ut_setup, ut_teardown,
3918                         test_snow3g_decryption_test_case_1),
3919                 TEST_CASE_ST(ut_setup, ut_teardown,
3920                         test_snow3g_decryption_test_case_2),
3921                 TEST_CASE_ST(ut_setup, ut_teardown,
3922                         test_snow3g_decryption_test_case_3),
3923                 TEST_CASE_ST(ut_setup, ut_teardown,
3924                         test_snow3g_decryption_test_case_4),
3925                 TEST_CASE_ST(ut_setup, ut_teardown,
3926                         test_snow3g_decryption_test_case_5),
3927                 TEST_CASE_ST(ut_setup, ut_teardown,
3928                         test_snow3g_hash_generate_test_case_1),
3929                 TEST_CASE_ST(ut_setup, ut_teardown,
3930                         test_snow3g_hash_generate_test_case_2),
3931                 TEST_CASE_ST(ut_setup, ut_teardown,
3932                         test_snow3g_hash_generate_test_case_3),
3933                 TEST_CASE_ST(ut_setup, ut_teardown,
3934                         test_snow3g_hash_verify_test_case_1),
3935                 TEST_CASE_ST(ut_setup, ut_teardown,
3936                         test_snow3g_hash_verify_test_case_2),
3937                 TEST_CASE_ST(ut_setup, ut_teardown,
3938                         test_snow3g_hash_verify_test_case_3),
3939                 TEST_CASE_ST(ut_setup, ut_teardown,
3940                         test_snow3g_authenticated_encryption_test_case_1),
3941                 TEST_CASE_ST(ut_setup, ut_teardown,
3942                         test_snow3g_encrypted_authentication_test_case_1),
3943                 TEST_CASES_END() /**< NULL terminate unit test array */
3944         }
3945 };
3946
3947 static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
3948         .suite_name = "Crypto Device AESNI MB Unit Test Suite",
3949         .setup = testsuite_setup,
3950         .teardown = testsuite_teardown,
3951         .unit_test_cases = {
3952                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_mb_all),
3953
3954                 TEST_CASES_END() /**< NULL terminate unit test array */
3955         }
3956 };
3957
3958 static struct unit_test_suite cryptodev_aesni_gcm_testsuite  = {
3959         .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
3960         .setup = testsuite_setup,
3961         .teardown = testsuite_teardown,
3962         .unit_test_cases = {
3963                 /** AES GCM Authenticated Encryption */
3964                 TEST_CASE_ST(ut_setup, ut_teardown,
3965                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
3966                 TEST_CASE_ST(ut_setup, ut_teardown,
3967                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
3968                 TEST_CASE_ST(ut_setup, ut_teardown,
3969                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
3970                 TEST_CASE_ST(ut_setup, ut_teardown,
3971                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
3972                 TEST_CASE_ST(ut_setup, ut_teardown,
3973                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
3974                 TEST_CASE_ST(ut_setup, ut_teardown,
3975                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
3976                 TEST_CASE_ST(ut_setup, ut_teardown,
3977                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
3978
3979                 /** AES GCM Authenticated Decryption */
3980                 TEST_CASE_ST(ut_setup, ut_teardown,
3981                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
3982                 TEST_CASE_ST(ut_setup, ut_teardown,
3983                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
3984                 TEST_CASE_ST(ut_setup, ut_teardown,
3985                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
3986                 TEST_CASE_ST(ut_setup, ut_teardown,
3987                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
3988                 TEST_CASE_ST(ut_setup, ut_teardown,
3989                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
3990                 TEST_CASE_ST(ut_setup, ut_teardown,
3991                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
3992                 TEST_CASE_ST(ut_setup, ut_teardown,
3993                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
3994
3995                 TEST_CASES_END() /**< NULL terminate unit test array */
3996         }
3997 };
3998
3999 static struct unit_test_suite cryptodev_sw_kasumi_testsuite  = {
4000         .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
4001         .setup = testsuite_setup,
4002         .teardown = testsuite_teardown,
4003         .unit_test_cases = {
4004                 /** KASUMI encrypt only (UEA1) */
4005                 TEST_CASE_ST(ut_setup, ut_teardown,
4006                         test_kasumi_encryption_test_case_1),
4007                 TEST_CASE_ST(ut_setup, ut_teardown,
4008                         test_kasumi_encryption_test_case_2),
4009                 TEST_CASE_ST(ut_setup, ut_teardown,
4010                         test_kasumi_encryption_test_case_3),
4011                 TEST_CASE_ST(ut_setup, ut_teardown,
4012                         test_kasumi_encryption_test_case_4),
4013                 TEST_CASE_ST(ut_setup, ut_teardown,
4014                         test_kasumi_encryption_test_case_5),
4015                 /** KASUMI decrypt only (UEA1) */
4016                 TEST_CASE_ST(ut_setup, ut_teardown,
4017                         test_kasumi_decryption_test_case_1),
4018                 TEST_CASE_ST(ut_setup, ut_teardown,
4019                         test_kasumi_decryption_test_case_2),
4020                 TEST_CASE_ST(ut_setup, ut_teardown,
4021                         test_kasumi_decryption_test_case_3),
4022                 TEST_CASE_ST(ut_setup, ut_teardown,
4023                         test_kasumi_decryption_test_case_4),
4024                 TEST_CASE_ST(ut_setup, ut_teardown,
4025                         test_kasumi_decryption_test_case_5),
4026
4027                 TEST_CASE_ST(ut_setup, ut_teardown,
4028                         test_kasumi_encryption_test_case_1_oop),
4029                 TEST_CASE_ST(ut_setup, ut_teardown,
4030                         test_kasumi_decryption_test_case_1_oop),
4031
4032                 /** KASUMI hash only (UIA1) */
4033                 TEST_CASE_ST(ut_setup, ut_teardown,
4034                         test_kasumi_hash_generate_test_case_1),
4035                 TEST_CASE_ST(ut_setup, ut_teardown,
4036                         test_kasumi_hash_generate_test_case_2),
4037                 TEST_CASE_ST(ut_setup, ut_teardown,
4038                         test_kasumi_hash_generate_test_case_3),
4039                 TEST_CASE_ST(ut_setup, ut_teardown,
4040                         test_kasumi_hash_generate_test_case_4),
4041                 TEST_CASE_ST(ut_setup, ut_teardown,
4042                         test_kasumi_hash_generate_test_case_5),
4043                 TEST_CASE_ST(ut_setup, ut_teardown,
4044                         test_kasumi_hash_verify_test_case_1),
4045                 TEST_CASE_ST(ut_setup, ut_teardown,
4046                         test_kasumi_hash_verify_test_case_2),
4047                 TEST_CASE_ST(ut_setup, ut_teardown,
4048                         test_kasumi_hash_verify_test_case_3),
4049                 TEST_CASE_ST(ut_setup, ut_teardown,
4050                         test_kasumi_hash_verify_test_case_4),
4051                 TEST_CASE_ST(ut_setup, ut_teardown,
4052                         test_kasumi_hash_verify_test_case_5),
4053
4054                 TEST_CASES_END() /**< NULL terminate unit test array */
4055         }
4056 };
4057 static struct unit_test_suite cryptodev_sw_snow3g_testsuite  = {
4058         .suite_name = "Crypto Device SW Snow3G Unit Test Suite",
4059         .setup = testsuite_setup,
4060         .teardown = testsuite_teardown,
4061         .unit_test_cases = {
4062                 /** Snow3G encrypt only (UEA2) */
4063                 TEST_CASE_ST(ut_setup, ut_teardown,
4064                         test_snow3g_encryption_test_case_1),
4065                 TEST_CASE_ST(ut_setup, ut_teardown,
4066                         test_snow3g_encryption_test_case_2),
4067                 TEST_CASE_ST(ut_setup, ut_teardown,
4068                         test_snow3g_encryption_test_case_3),
4069                 TEST_CASE_ST(ut_setup, ut_teardown,
4070                         test_snow3g_encryption_test_case_4),
4071                 TEST_CASE_ST(ut_setup, ut_teardown,
4072                         test_snow3g_encryption_test_case_5),
4073
4074                 TEST_CASE_ST(ut_setup, ut_teardown,
4075                         test_snow3g_encryption_test_case_1_oop),
4076                 TEST_CASE_ST(ut_setup, ut_teardown,
4077                         test_snow3g_decryption_test_case_1_oop),
4078
4079                 TEST_CASE_ST(ut_setup, ut_teardown,
4080                         test_snow3g_encryption_test_case_1_offset_oop),
4081
4082                 /** Snow3G decrypt only (UEA2) */
4083                 TEST_CASE_ST(ut_setup, ut_teardown,
4084                         test_snow3g_decryption_test_case_1),
4085                 TEST_CASE_ST(ut_setup, ut_teardown,
4086                         test_snow3g_decryption_test_case_2),
4087                 TEST_CASE_ST(ut_setup, ut_teardown,
4088                         test_snow3g_decryption_test_case_3),
4089                 TEST_CASE_ST(ut_setup, ut_teardown,
4090                         test_snow3g_decryption_test_case_4),
4091                 TEST_CASE_ST(ut_setup, ut_teardown,
4092                         test_snow3g_decryption_test_case_5),
4093                 TEST_CASE_ST(ut_setup, ut_teardown,
4094                         test_snow3g_hash_generate_test_case_1),
4095                 TEST_CASE_ST(ut_setup, ut_teardown,
4096                         test_snow3g_hash_generate_test_case_2),
4097                 TEST_CASE_ST(ut_setup, ut_teardown,
4098                         test_snow3g_hash_generate_test_case_3),
4099                 /* Tests with buffers which length is not byte-aligned */
4100                 TEST_CASE_ST(ut_setup, ut_teardown,
4101                         test_snow3g_hash_generate_test_case_4),
4102                 TEST_CASE_ST(ut_setup, ut_teardown,
4103                         test_snow3g_hash_generate_test_case_5),
4104                 TEST_CASE_ST(ut_setup, ut_teardown,
4105                         test_snow3g_hash_generate_test_case_6),
4106                 TEST_CASE_ST(ut_setup, ut_teardown,
4107                         test_snow3g_hash_verify_test_case_1),
4108                 TEST_CASE_ST(ut_setup, ut_teardown,
4109                         test_snow3g_hash_verify_test_case_2),
4110                 TEST_CASE_ST(ut_setup, ut_teardown,
4111                         test_snow3g_hash_verify_test_case_3),
4112                 /* Tests with buffers which length is not byte-aligned */
4113                 TEST_CASE_ST(ut_setup, ut_teardown,
4114                         test_snow3g_hash_verify_test_case_4),
4115                 TEST_CASE_ST(ut_setup, ut_teardown,
4116                         test_snow3g_hash_verify_test_case_5),
4117                 TEST_CASE_ST(ut_setup, ut_teardown,
4118                         test_snow3g_hash_verify_test_case_6),
4119                 TEST_CASE_ST(ut_setup, ut_teardown,
4120                         test_snow3g_authenticated_encryption_test_case_1),
4121                 TEST_CASE_ST(ut_setup, ut_teardown,
4122                         test_snow3g_encrypted_authentication_test_case_1),
4123
4124                 TEST_CASES_END() /**< NULL terminate unit test array */
4125         }
4126 };
4127
4128 static struct unit_test_suite cryptodev_null_testsuite  = {
4129         .suite_name = "Crypto Device NULL Unit Test Suite",
4130         .setup = testsuite_setup,
4131         .teardown = testsuite_teardown,
4132         .unit_test_cases = {
4133                 TEST_CASE_ST(ut_setup, ut_teardown,
4134                         test_null_auth_only_operation),
4135                 TEST_CASE_ST(ut_setup, ut_teardown,
4136                         test_null_cipher_only_operation),
4137                 TEST_CASE_ST(ut_setup, ut_teardown,
4138                         test_null_cipher_auth_operation),
4139                 TEST_CASE_ST(ut_setup, ut_teardown,
4140                         test_null_auth_cipher_operation),
4141                 TEST_CASE_ST(ut_setup, ut_teardown,
4142                         test_null_invalid_operation),
4143                 TEST_CASE_ST(ut_setup, ut_teardown,
4144                         test_null_burst_operation),
4145
4146                 TEST_CASES_END() /**< NULL terminate unit test array */
4147         }
4148 };
4149
4150 static int
4151 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
4152 {
4153         gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
4154         return unit_test_suite_runner(&cryptodev_qat_testsuite);
4155 }
4156 static struct test_command cryptodev_qat_cmd = {
4157         .command = "cryptodev_qat_autotest",
4158         .callback = test_cryptodev_qat,
4159 };
4160
4161 static int
4162 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
4163 {
4164         gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
4165
4166         return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
4167 }
4168
4169 static struct test_command cryptodev_aesni_mb_cmd = {
4170         .command = "cryptodev_aesni_mb_autotest",
4171         .callback = test_cryptodev_aesni_mb,
4172 };
4173
4174 static int
4175 test_cryptodev_aesni_gcm(void)
4176 {
4177         gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD;
4178
4179         return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
4180 }
4181
4182 static struct test_command cryptodev_aesni_gcm_cmd = {
4183         .command = "cryptodev_aesni_gcm_autotest",
4184         .callback = test_cryptodev_aesni_gcm,
4185 };
4186
4187 static int
4188 test_cryptodev_null(void)
4189 {
4190         gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD;
4191
4192         return unit_test_suite_runner(&cryptodev_null_testsuite);
4193 }
4194
4195 static struct test_command cryptodev_null_cmd = {
4196         .command = "cryptodev_null_autotest",
4197         .callback = test_cryptodev_null,
4198 };
4199
4200 static int
4201 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
4202 {
4203         gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD;
4204
4205         return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
4206 }
4207
4208 static struct test_command cryptodev_sw_snow3g_cmd = {
4209         .command = "cryptodev_sw_snow3g_autotest",
4210         .callback = test_cryptodev_sw_snow3g,
4211 };
4212
4213 static int
4214 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
4215 {
4216         gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD;
4217
4218         return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
4219 }
4220
4221 static struct test_command cryptodev_sw_kasumi_cmd = {
4222         .command = "cryptodev_sw_kasumi_autotest",
4223         .callback = test_cryptodev_sw_kasumi,
4224 };
4225
4226 REGISTER_TEST_COMMAND(cryptodev_qat_cmd);
4227 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_cmd);
4228 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_cmd);
4229 REGISTER_TEST_COMMAND(cryptodev_null_cmd);
4230 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_cmd);
4231 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_cmd);