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