app/test/test_cryptodev.c

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