test/test/test_cryptodev.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2015-2017 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 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
  44 #include <rte_cryptodev_scheduler.h>
  45 #include <rte_cryptodev_scheduler_operations.h>
  46 #endif
  47
  48 #include "test.h"
  49 #include "test_cryptodev.h"
  50
  51 #include "test_cryptodev_blockcipher.h"
  52 #include "test_cryptodev_aes_test_vectors.h"
  53 #include "test_cryptodev_des_test_vectors.h"
  54 #include "test_cryptodev_hash_test_vectors.h"
  55 #include "test_cryptodev_kasumi_test_vectors.h"
  56 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  57 #include "test_cryptodev_snow3g_test_vectors.h"
  58 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  59 #include "test_cryptodev_zuc_test_vectors.h"
  60 #include "test_cryptodev_gcm_test_vectors.h"
  61 #include "test_cryptodev_hmac_test_vectors.h"
  62
  63 static enum rte_cryptodev_type gbl_cryptodev_type;
  64
  65 struct crypto_testsuite_params {
  66         struct rte_mempool *mbuf_pool;
  67         struct rte_mempool *large_mbuf_pool;
  68         struct rte_mempool *op_mpool;
  69         struct rte_cryptodev_config conf;
  70         struct rte_cryptodev_qp_conf qp_conf;
  71
  72         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  73         uint8_t valid_dev_count;
  74 };
  75
  76 struct crypto_unittest_params {
  77         struct rte_crypto_sym_xform cipher_xform;
  78         struct rte_crypto_sym_xform auth_xform;
  79
  80         struct rte_cryptodev_sym_session *sess;
  81
  82         struct rte_crypto_op *op;
  83
  84         struct rte_mbuf *obuf, *ibuf;
  85
  86         uint8_t *digest;
  87 };
  88
  89 #define ALIGN_POW2_ROUNDUP(num, align) \
  90         (((num) + (align) - 1) & ~((align) - 1))
  91
  92 /*
  93  * Forward declarations.
  94  */
  95 static int
  96 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
  97                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
  98                 uint8_t *hmac_key);
  99
 100 static int
 101 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 102                 struct crypto_unittest_params *ut_params,
 103                 struct crypto_testsuite_params *ts_param,
 104                 const uint8_t *cipher,
 105                 const uint8_t *digest,
 106                 const uint8_t *iv);
 107
 108 static struct rte_mbuf *
 109 setup_test_string(struct rte_mempool *mpool,
 110                 const char *string, size_t len, uint8_t blocksize)
 111 {
 112         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 113         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 114
 115         memset(m->buf_addr, 0, m->buf_len);
 116         if (m) {
 117                 char *dst = rte_pktmbuf_append(m, t_len);
 118
 119                 if (!dst) {
 120                         rte_pktmbuf_free(m);
 121                         return NULL;
 122                 }
 123                 if (string != NULL)
 124                         rte_memcpy(dst, string, t_len);
 125                 else
 126                         memset(dst, 0, t_len);
 127         }
 128
 129         return m;
 130 }
 131
 132 /* Get number of bytes in X bits (rounding up) */
 133 static uint32_t
 134 ceil_byte_length(uint32_t num_bits)
 135 {
 136         if (num_bits % 8)
 137                 return ((num_bits >> 3) + 1);
 138         else
 139                 return (num_bits >> 3);
 140 }
 141
 142 static struct rte_crypto_op *
 143 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 144 {
 145         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 146                 printf("Error sending packet for encryption");
 147                 return NULL;
 148         }
 149
 150         op = NULL;
 151
 152         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 153                 rte_pause();
 154
 155         return op;
 156 }
 157
 158 static struct crypto_testsuite_params testsuite_params = { NULL };
 159 static struct crypto_unittest_params unittest_params;
 160
 161 static int
 162 testsuite_setup(void)
 163 {
 164         struct crypto_testsuite_params *ts_params = &testsuite_params;
 165         struct rte_cryptodev_info info;
 166         uint32_t i = 0, nb_devs, dev_id;
 167         int ret;
 168         uint16_t qp_id;
 169
 170         memset(ts_params, 0, sizeof(*ts_params));
 171
 172         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 173         if (ts_params->mbuf_pool == NULL) {
 174                 /* Not already created so create */
 175                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 176                                 "CRYPTO_MBUFPOOL",
 177                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 178                                 rte_socket_id());
 179                 if (ts_params->mbuf_pool == NULL) {
 180                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 181                         return TEST_FAILED;
 182                 }
 183         }
 184
 185         ts_params->large_mbuf_pool = rte_mempool_lookup(
 186                         "CRYPTO_LARGE_MBUFPOOL");
 187         if (ts_params->large_mbuf_pool == NULL) {
 188                 /* Not already created so create */
 189                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 190                                 "CRYPTO_LARGE_MBUFPOOL",
 191                                 1, 0, 0, UINT16_MAX,
 192                                 rte_socket_id());
 193                 if (ts_params->large_mbuf_pool == NULL) {
 194                         RTE_LOG(ERR, USER1,
 195                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 196                         return TEST_FAILED;
 197                 }
 198         }
 199
 200         ts_params->op_mpool = rte_crypto_op_pool_create(
 201                         "MBUF_CRYPTO_SYM_OP_POOL",
 202                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 203                         NUM_MBUFS, MBUF_CACHE_SIZE,
 204                         DEFAULT_NUM_XFORMS *
 205                         sizeof(struct rte_crypto_sym_xform),
 206                         rte_socket_id());
 207         if (ts_params->op_mpool == NULL) {
 208                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 209                 return TEST_FAILED;
 210         }
 211
 212         /* Create an AESNI MB device if required */
 213         if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) {
 214 #ifndef RTE_LIBRTE_PMD_AESNI_MB
 215                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
 216                         " enabled in config file to run this testsuite.\n");
 217                 return TEST_FAILED;
 218 #endif
 219                 nb_devs = rte_cryptodev_count_devtype(
 220                                 RTE_CRYPTODEV_AESNI_MB_PMD);
 221                 if (nb_devs < 1) {
 222                         ret = rte_vdev_init(
 223                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
 224
 225                         TEST_ASSERT(ret == 0,
 226                                 "Failed to create instance of"
 227                                 " pmd : %s",
 228                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
 229                 }
 230         }
 231
 232         /* Create an AESNI GCM device if required */
 233         if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) {
 234 #ifndef RTE_LIBRTE_PMD_AESNI_GCM
 235                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be"
 236                         " enabled in config file to run this testsuite.\n");
 237                 return TEST_FAILED;
 238 #endif
 239                 nb_devs = rte_cryptodev_count_devtype(
 240                                 RTE_CRYPTODEV_AESNI_GCM_PMD);
 241                 if (nb_devs < 1) {
 242                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 243                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
 244                                 "Failed to create instance of"
 245                                 " pmd : %s",
 246                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
 247                 }
 248         }
 249
 250         /* Create a SNOW 3G device if required */
 251         if (gbl_cryptodev_type == RTE_CRYPTODEV_SNOW3G_PMD) {
 252 #ifndef RTE_LIBRTE_PMD_SNOW3G
 253                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_SNOW3G must be"
 254                         " enabled in config file to run this testsuite.\n");
 255                 return TEST_FAILED;
 256 #endif
 257                 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
 258                 if (nb_devs < 1) {
 259                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 260                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
 261                                 "Failed to create instance of"
 262                                 " pmd : %s",
 263                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
 264                 }
 265         }
 266
 267         /* Create a KASUMI device if required */
 268         if (gbl_cryptodev_type == RTE_CRYPTODEV_KASUMI_PMD) {
 269 #ifndef RTE_LIBRTE_PMD_KASUMI
 270                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_KASUMI must be"
 271                         " enabled in config file to run this testsuite.\n");
 272                 return TEST_FAILED;
 273 #endif
 274                 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD);
 275                 if (nb_devs < 1) {
 276                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 277                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
 278                                 "Failed to create instance of"
 279                                 " pmd : %s",
 280                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
 281                 }
 282         }
 283
 284         /* Create a ZUC device if required */
 285         if (gbl_cryptodev_type == RTE_CRYPTODEV_ZUC_PMD) {
 286 #ifndef RTE_LIBRTE_PMD_ZUC
 287                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ZUC must be"
 288                         " enabled in config file to run this testsuite.\n");
 289                 return TEST_FAILED;
 290 #endif
 291                 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_ZUC_PMD);
 292                 if (nb_devs < 1) {
 293                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 294                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
 295                                 "Failed to create instance of"
 296                                 " pmd : %s",
 297                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
 298                 }
 299         }
 300
 301         /* Create a NULL device if required */
 302         if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) {
 303 #ifndef RTE_LIBRTE_PMD_NULL_CRYPTO
 304                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_NULL_CRYPTO must be"
 305                         " enabled in config file to run this testsuite.\n");
 306                 return TEST_FAILED;
 307 #endif
 308                 nb_devs = rte_cryptodev_count_devtype(
 309                                 RTE_CRYPTODEV_NULL_PMD);
 310                 if (nb_devs < 1) {
 311                         ret = rte_vdev_init(
 312                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
 313
 314                         TEST_ASSERT(ret == 0,
 315                                 "Failed to create instance of"
 316                                 " pmd : %s",
 317                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
 318                 }
 319         }
 320
 321         /* Create an OPENSSL device if required */
 322         if (gbl_cryptodev_type == RTE_CRYPTODEV_OPENSSL_PMD) {
 323 #ifndef RTE_LIBRTE_PMD_OPENSSL
 324                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be"
 325                         " enabled in config file to run this testsuite.\n");
 326                 return TEST_FAILED;
 327 #endif
 328                 nb_devs = rte_cryptodev_count_devtype(
 329                                 RTE_CRYPTODEV_OPENSSL_PMD);
 330                 if (nb_devs < 1) {
 331                         ret = rte_vdev_init(
 332                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
 333                                 NULL);
 334
 335                         TEST_ASSERT(ret == 0, "Failed to create "
 336                                 "instance of pmd : %s",
 337                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
 338                 }
 339         }
 340
 341         /* Create a ARMv8 device if required */
 342         if (gbl_cryptodev_type == RTE_CRYPTODEV_ARMV8_PMD) {
 343 #ifndef RTE_LIBRTE_PMD_ARMV8_CRYPTO
 344                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO must be"
 345                         " enabled in config file to run this testsuite.\n");
 346                 return TEST_FAILED;
 347 #endif
 348                 nb_devs = rte_cryptodev_count_devtype(
 349                                 RTE_CRYPTODEV_ARMV8_PMD);
 350                 if (nb_devs < 1) {
 351                         ret = rte_vdev_init(
 352                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
 353                                 NULL);
 354
 355                         TEST_ASSERT(ret == 0, "Failed to create "
 356                                 "instance of pmd : %s",
 357                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
 358                 }
 359         }
 360
 361 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
 362         if (gbl_cryptodev_type == RTE_CRYPTODEV_SCHEDULER_PMD) {
 363
 364 #ifndef RTE_LIBRTE_PMD_AESNI_MB
 365                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
 366                         " enabled in config file to run this testsuite.\n");
 367                 return TEST_FAILED;
 368 #endif
 369                 nb_devs = rte_cryptodev_count_devtype(
 370                                 RTE_CRYPTODEV_SCHEDULER_PMD);
 371                 if (nb_devs < 1) {
 372                         ret = rte_vdev_init(
 373                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
 374                                 NULL);
 375
 376                         TEST_ASSERT(ret == 0,
 377                                 "Failed to create instance %u of"
 378                                 " pmd : %s",
 379                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
 380                 }
 381         }
 382 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
 383
 384 #ifndef RTE_LIBRTE_PMD_QAT
 385         if (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) {
 386                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
 387                                 "in config file to run this testsuite.\n");
 388                 return TEST_FAILED;
 389         }
 390 #endif
 391
 392         nb_devs = rte_cryptodev_count();
 393         if (nb_devs < 1) {
 394                 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
 395                 return TEST_FAILED;
 396         }
 397
 398         /* Create list of valid crypto devs */
 399         for (i = 0; i < nb_devs; i++) {
 400                 rte_cryptodev_info_get(i, &info);
 401                 if (info.dev_type == gbl_cryptodev_type)
 402                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 403         }
 404
 405         if (ts_params->valid_dev_count < 1)
 406                 return TEST_FAILED;
 407
 408         /* Set up all the qps on the first of the valid devices found */
 409
 410         dev_id = ts_params->valid_devs[0];
 411
 412         rte_cryptodev_info_get(dev_id, &info);
 413
 414         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 415         ts_params->conf.socket_id = SOCKET_ID_ANY;
 416         ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
 417
 418         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 419                         &ts_params->conf),
 420                         "Failed to configure cryptodev %u with %u qps",
 421                         dev_id, ts_params->conf.nb_queue_pairs);
 422
 423         ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 424
 425         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 426                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 427                         dev_id, qp_id, &ts_params->qp_conf,
 428                         rte_cryptodev_socket_id(dev_id)),
 429                         "Failed to setup queue pair %u on cryptodev %u",
 430                         qp_id, dev_id);
 431         }
 432
 433         return TEST_SUCCESS;
 434 }
 435
 436 static void
 437 testsuite_teardown(void)
 438 {
 439         struct crypto_testsuite_params *ts_params = &testsuite_params;
 440
 441         if (ts_params->mbuf_pool != NULL) {
 442                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 443                 rte_mempool_avail_count(ts_params->mbuf_pool));
 444         }
 445
 446         if (ts_params->op_mpool != NULL) {
 447                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 448                 rte_mempool_avail_count(ts_params->op_mpool));
 449         }
 450
 451 }
 452
 453 static int
 454 ut_setup(void)
 455 {
 456         struct crypto_testsuite_params *ts_params = &testsuite_params;
 457         struct crypto_unittest_params *ut_params = &unittest_params;
 458
 459         uint16_t qp_id;
 460
 461         /* Clear unit test parameters before running test */
 462         memset(ut_params, 0, sizeof(*ut_params));
 463
 464         /* Reconfigure device to default parameters */
 465         ts_params->conf.socket_id = SOCKET_ID_ANY;
 466         ts_params->conf.session_mp.nb_objs = DEFAULT_NUM_OPS_INFLIGHT;
 467
 468         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 469                         &ts_params->conf),
 470                         "Failed to configure cryptodev %u",
 471                         ts_params->valid_devs[0]);
 472
 473         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 474                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 475                         ts_params->valid_devs[0], qp_id,
 476                         &ts_params->qp_conf,
 477                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 478                         "Failed to setup queue pair %u on cryptodev %u",
 479                         qp_id, ts_params->valid_devs[0]);
 480         }
 481
 482
 483         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 484
 485         /* Start the device */
 486         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
 487                         "Failed to start cryptodev %u",
 488                         ts_params->valid_devs[0]);
 489
 490         return TEST_SUCCESS;
 491 }
 492
 493 static void
 494 ut_teardown(void)
 495 {
 496         struct crypto_testsuite_params *ts_params = &testsuite_params;
 497         struct crypto_unittest_params *ut_params = &unittest_params;
 498         struct rte_cryptodev_stats stats;
 499
 500         /* free crypto session structure */
 501         if (ut_params->sess) {
 502                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
 503                                 ut_params->sess);
 504                 ut_params->sess = NULL;
 505         }
 506
 507         /* free crypto operation structure */
 508         if (ut_params->op)
 509                 rte_crypto_op_free(ut_params->op);
 510
 511         /*
 512          * free mbuf - both obuf and ibuf are usually the same,
 513          * so check if they point at the same address is necessary,
 514          * to avoid freeing the mbuf twice.
 515          */
 516         if (ut_params->obuf) {
 517                 rte_pktmbuf_free(ut_params->obuf);
 518                 if (ut_params->ibuf == ut_params->obuf)
 519                         ut_params->ibuf = 0;
 520                 ut_params->obuf = 0;
 521         }
 522         if (ut_params->ibuf) {
 523                 rte_pktmbuf_free(ut_params->ibuf);
 524                 ut_params->ibuf = 0;
 525         }
 526
 527         if (ts_params->mbuf_pool != NULL)
 528                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 529                         rte_mempool_avail_count(ts_params->mbuf_pool));
 530
 531         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
 532
 533         /* Stop the device */
 534         rte_cryptodev_stop(ts_params->valid_devs[0]);
 535 }
 536
 537 static int
 538 test_device_configure_invalid_dev_id(void)
 539 {
 540         struct crypto_testsuite_params *ts_params = &testsuite_params;
 541         uint16_t dev_id, num_devs = 0;
 542
 543         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
 544                         "Need at least %d devices for test", 1);
 545
 546         /* valid dev_id values */
 547         dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
 548
 549         /* Stop the device in case it's started so it can be configured */
 550         rte_cryptodev_stop(ts_params->valid_devs[dev_id]);
 551
 552         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
 553                         "Failed test for rte_cryptodev_configure: "
 554                         "invalid dev_num %u", dev_id);
 555
 556         /* invalid dev_id values */
 557         dev_id = num_devs;
 558
 559         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 560                         "Failed test for rte_cryptodev_configure: "
 561                         "invalid dev_num %u", dev_id);
 562
 563         dev_id = 0xff;
 564
 565         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 566                         "Failed test for rte_cryptodev_configure:"
 567                         "invalid dev_num %u", dev_id);
 568
 569         return TEST_SUCCESS;
 570 }
 571
 572 static int
 573 test_device_configure_invalid_queue_pair_ids(void)
 574 {
 575         struct crypto_testsuite_params *ts_params = &testsuite_params;
 576         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
 577
 578         /* Stop the device in case it's started so it can be configured */
 579         rte_cryptodev_stop(ts_params->valid_devs[0]);
 580
 581         /* valid - one queue pairs */
 582         ts_params->conf.nb_queue_pairs = 1;
 583
 584         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 585                         &ts_params->conf),
 586                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 587                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 588
 589
 590         /* valid - max value queue pairs */
 591         ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
 592
 593         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 594                         &ts_params->conf),
 595                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 596                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 597
 598
 599         /* invalid - zero queue pairs */
 600         ts_params->conf.nb_queue_pairs = 0;
 601
 602         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 603                         &ts_params->conf),
 604                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 605                         " invalid qps: %u",
 606                         ts_params->valid_devs[0],
 607                         ts_params->conf.nb_queue_pairs);
 608
 609
 610         /* invalid - max value supported by field queue pairs */
 611         ts_params->conf.nb_queue_pairs = UINT16_MAX;
 612
 613         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 614                         &ts_params->conf),
 615                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 616                         " invalid qps: %u",
 617                         ts_params->valid_devs[0],
 618                         ts_params->conf.nb_queue_pairs);
 619
 620
 621         /* invalid - max value + 1 queue pairs */
 622         ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
 623
 624         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 625                         &ts_params->conf),
 626                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 627                         " invalid qps: %u",
 628                         ts_params->valid_devs[0],
 629                         ts_params->conf.nb_queue_pairs);
 630
 631         /* revert to original testsuite value */
 632         ts_params->conf.nb_queue_pairs = orig_nb_qps;
 633
 634         return TEST_SUCCESS;
 635 }
 636
 637 static int
 638 test_queue_pair_descriptor_setup(void)
 639 {
 640         struct crypto_testsuite_params *ts_params = &testsuite_params;
 641         struct rte_cryptodev_info dev_info;
 642         struct rte_cryptodev_qp_conf qp_conf = {
 643                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
 644         };
 645
 646         uint16_t qp_id;
 647
 648         /* Stop the device in case it's started so it can be configured */
 649         rte_cryptodev_stop(ts_params->valid_devs[0]);
 650
 651
 652         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 653
 654         ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions;
 655
 656         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 657                         &ts_params->conf), "Failed to configure cryptodev %u",
 658                         ts_params->valid_devs[0]);
 659
 660
 661         /*
 662          * Test various ring sizes on this device. memzones can't be
 663          * freed so are re-used if ring is released and re-created.
 664          */
 665         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
 666
 667         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 668                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 669                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 670                                 rte_cryptodev_socket_id(
 671                                                 ts_params->valid_devs[0])),
 672                                 "Failed test for "
 673                                 "rte_cryptodev_queue_pair_setup: num_inflights "
 674                                 "%u on qp %u on cryptodev %u",
 675                                 qp_conf.nb_descriptors, qp_id,
 676                                 ts_params->valid_devs[0]);
 677         }
 678
 679         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
 680
 681         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 682                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 683                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 684                                 rte_cryptodev_socket_id(
 685                                                 ts_params->valid_devs[0])),
 686                                 "Failed test for"
 687                                 " rte_cryptodev_queue_pair_setup: num_inflights"
 688                                 " %u on qp %u on cryptodev %u",
 689                                 qp_conf.nb_descriptors, qp_id,
 690                                 ts_params->valid_devs[0]);
 691         }
 692
 693         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
 694
 695         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 696                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 697                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 698                                 rte_cryptodev_socket_id(
 699                                                 ts_params->valid_devs[0])),
 700                                 "Failed test for "
 701                                 "rte_cryptodev_queue_pair_setup: num_inflights"
 702                                 " %u on qp %u on cryptodev %u",
 703                                 qp_conf.nb_descriptors, qp_id,
 704                                 ts_params->valid_devs[0]);
 705         }
 706
 707         /* invalid number of descriptors - max supported + 2 */
 708         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
 709
 710         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 711                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 712                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 713                                 rte_cryptodev_socket_id(
 714                                                 ts_params->valid_devs[0])),
 715                                 "Unexpectedly passed test for "
 716                                 "rte_cryptodev_queue_pair_setup:"
 717                                 "num_inflights %u on qp %u on cryptodev %u",
 718                                 qp_conf.nb_descriptors, qp_id,
 719                                 ts_params->valid_devs[0]);
 720         }
 721
 722         /* invalid number of descriptors - max value of parameter */
 723         qp_conf.nb_descriptors = UINT32_MAX-1;
 724
 725         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 726                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 727                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 728                                 rte_cryptodev_socket_id(
 729                                                 ts_params->valid_devs[0])),
 730                                 "Unexpectedly passed test for "
 731                                 "rte_cryptodev_queue_pair_setup:"
 732                                 "num_inflights %u on qp %u on cryptodev %u",
 733                                 qp_conf.nb_descriptors, qp_id,
 734                                 ts_params->valid_devs[0]);
 735         }
 736
 737         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 738
 739         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 740                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 741                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 742                                 rte_cryptodev_socket_id(
 743                                                 ts_params->valid_devs[0])),
 744                                 "Failed test for"
 745                                 " rte_cryptodev_queue_pair_setup:"
 746                                 "num_inflights %u on qp %u on cryptodev %u",
 747                                 qp_conf.nb_descriptors, qp_id,
 748                                 ts_params->valid_devs[0]);
 749         }
 750
 751         /* invalid number of descriptors - max supported + 1 */
 752         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
 753
 754         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 755                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 756                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 757                                 rte_cryptodev_socket_id(
 758                                                 ts_params->valid_devs[0])),
 759                                 "Unexpectedly passed test for "
 760                                 "rte_cryptodev_queue_pair_setup:"
 761                                 "num_inflights %u on qp %u on cryptodev %u",
 762                                 qp_conf.nb_descriptors, qp_id,
 763                                 ts_params->valid_devs[0]);
 764         }
 765
 766         /* test invalid queue pair id */
 767         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
 768
 769         qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE;         /*invalid */
 770
 771         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 772                         ts_params->valid_devs[0],
 773                         qp_id, &qp_conf,
 774                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 775                         "Failed test for rte_cryptodev_queue_pair_setup:"
 776                         "invalid qp %u on cryptodev %u",
 777                         qp_id, ts_params->valid_devs[0]);
 778
 779         qp_id = 0xffff; /*invalid*/
 780
 781         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 782                         ts_params->valid_devs[0],
 783                         qp_id, &qp_conf,
 784                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 785                         "Failed test for rte_cryptodev_queue_pair_setup:"
 786                         "invalid qp %u on cryptodev %u",
 787                         qp_id, ts_params->valid_devs[0]);
 788
 789         return TEST_SUCCESS;
 790 }
 791
 792 /* ***** Plaintext data for tests ***** */
 793
 794 const char catch_22_quote_1[] =
 795                 "There was only one catch and that was Catch-22, which "
 796                 "specified that a concern for one's safety in the face of "
 797                 "dangers that were real and immediate was the process of a "
 798                 "rational mind. Orr was crazy and could be grounded. All he "
 799                 "had to do was ask; and as soon as he did, he would no longer "
 800                 "be crazy and would have to fly more missions. Orr would be "
 801                 "crazy to fly more missions and sane if he didn't, but if he "
 802                 "was sane he had to fly them. If he flew them he was crazy "
 803                 "and didn't have to; but if he didn't want to he was sane and "
 804                 "had to. Yossarian was moved very deeply by the absolute "
 805                 "simplicity of this clause of Catch-22 and let out a "
 806                 "respectful whistle. \"That's some catch, that Catch-22\", he "
 807                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
 808
 809 const char catch_22_quote[] =
 810                 "What a lousy earth! He wondered how many people were "
 811                 "destitute that same night even in his own prosperous country, "
 812                 "how many homes were shanties, how many husbands were drunk "
 813                 "and wives socked, and how many children were bullied, abused, "
 814                 "or abandoned. How many families hungered for food they could "
 815                 "not afford to buy? How many hearts were broken? How many "
 816                 "suicides would take place that same night, how many people "
 817                 "would go insane? How many cockroaches and landlords would "
 818                 "triumph? How many winners were losers, successes failures, "
 819                 "and rich men poor men? How many wise guys were stupid? How "
 820                 "many happy endings were unhappy endings? How many honest men "
 821                 "were liars, brave men cowards, loyal men traitors, how many "
 822                 "sainted men were corrupt, how many people in positions of "
 823                 "trust had sold their souls to bodyguards, how many had never "
 824                 "had souls? How many straight-and-narrow paths were crooked "
 825                 "paths? How many best families were worst families and how "
 826                 "many good people were bad people? When you added them all up "
 827                 "and then subtracted, you might be left with only the children, "
 828                 "and perhaps with Albert Einstein and an old violinist or "
 829                 "sculptor somewhere.";
 830
 831 #define QUOTE_480_BYTES         (480)
 832 #define QUOTE_512_BYTES         (512)
 833 #define QUOTE_768_BYTES         (768)
 834 #define QUOTE_1024_BYTES        (1024)
 835
 836
 837
 838 /* ***** SHA1 Hash Tests ***** */
 839
 840 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
 841
 842 static uint8_t hmac_sha1_key[] = {
 843         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 844         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 845         0xDE, 0xF4, 0xDE, 0xAD };
 846
 847 /* ***** SHA224 Hash Tests ***** */
 848
 849 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
 850
 851
 852 /* ***** AES-CBC Cipher Tests ***** */
 853
 854 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
 855 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
 856
 857 static uint8_t aes_cbc_key[] = {
 858         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 859         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
 860
 861 static uint8_t aes_cbc_iv[] = {
 862         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 863         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
 864
 865
 866 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
 867
 868 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
 869         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
 870         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
 871         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
 872         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
 873         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
 874         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
 875         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
 876         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
 877         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
 878         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
 879         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
 880         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
 881         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
 882         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
 883         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
 884         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
 885         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
 886         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
 887         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
 888         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
 889         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
 890         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
 891         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 892         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
 893         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
 894         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
 895         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
 896         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
 897         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
 898         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
 899         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
 900         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
 901         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
 902         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
 903         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
 904         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
 905         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
 906         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
 907         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
 908         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
 909         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
 910         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
 911         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
 912         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
 913         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
 914         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
 915         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
 916         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
 917         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
 918         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
 919         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
 920         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
 921         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
 922         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
 923         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
 924         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
 925         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
 926         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
 927         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
 928         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
 929         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
 930         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
 931         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
 932         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
 933 };
 934
 935 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
 936         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
 937         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
 938         0x18, 0x8c, 0x1d, 0x32
 939 };
 940
 941
 942 /* Multisession Vector context Test */
 943 /*Begin Session 0 */
 944 static uint8_t ms_aes_cbc_key0[] = {
 945         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 946         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 947 };
 948
 949 static uint8_t ms_aes_cbc_iv0[] = {
 950         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 951         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 952 };
 953
 954 static const uint8_t ms_aes_cbc_cipher0[] = {
 955                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
 956                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
 957                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
 958                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
 959                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
 960                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
 961                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
 962                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
 963                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
 964                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
 965                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
 966                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
 967                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
 968                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
 969                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
 970                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
 971                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
 972                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
 973                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
 974                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
 975                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
 976                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
 977                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
 978                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
 979                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
 980                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
 981                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
 982                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
 983                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
 984                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
 985                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
 986                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
 987                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
 988                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
 989                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
 990                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
 991                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
 992                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
 993                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
 994                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
 995                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
 996                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
 997                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
 998                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
 999                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1000                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1001                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1002                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1003                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1004                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1005                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1006                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1007                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1008                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1009                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1010                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1011                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1012                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1013                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1014                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1015                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1016                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1017                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1018                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1019 };
1020
1021
1022 static  uint8_t ms_hmac_key0[] = {
1023                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1024                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1025                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1026                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1027                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1028                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1029                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1030                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1031 };
1032
1033 static const uint8_t ms_hmac_digest0[] = {
1034                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1035                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1036                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1037                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1038                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1039                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1040                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1041                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1042                 };
1043
1044 /* End Session 0 */
1045 /* Begin session 1 */
1046
1047 static  uint8_t ms_aes_cbc_key1[] = {
1048                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1049                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1050 };
1051
1052 static  uint8_t ms_aes_cbc_iv1[] = {
1053         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1054         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1055 };
1056
1057 static const uint8_t ms_aes_cbc_cipher1[] = {
1058                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1059                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1060                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1061                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1062                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1063                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1064                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1065                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1066                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1067                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1068                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1069                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1070                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1071                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1072                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1073                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1074                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1075                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1076                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1077                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1078                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1079                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1080                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1081                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1082                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1083                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1084                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1085                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1086                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1087                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1088                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1089                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1090                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1091                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1092                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1093                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1094                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1095                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1096                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1097                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1098                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1099                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1100                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1101                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1102                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1103                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1104                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1105                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1106                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1107                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1108                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1109                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1110                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1111                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1112                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1113                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1114                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1115                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1116                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1117                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1118                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1119                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1120                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1121                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1122
1123 };
1124
1125 static uint8_t ms_hmac_key1[] = {
1126                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1127                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1128                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1129                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1130                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1131                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1132                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1133                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1134 };
1135
1136 static const uint8_t ms_hmac_digest1[] = {
1137                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1138                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1139                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1140                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1141                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1142                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1143                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1144                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1145 };
1146 /* End Session 1  */
1147 /* Begin Session 2 */
1148 static  uint8_t ms_aes_cbc_key2[] = {
1149                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1150                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1151 };
1152
1153 static  uint8_t ms_aes_cbc_iv2[] = {
1154                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1155                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1156 };
1157
1158 static const uint8_t ms_aes_cbc_cipher2[] = {
1159                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1160                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1161                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1162                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1163                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1164                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1165                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1166                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1167                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1168                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1169                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1170                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1171                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1172                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1173                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1174                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1175                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1176                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1177                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1178                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1179                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1180                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1181                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1182                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1183                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1184                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1185                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1186                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1187                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1188                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1189                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1190                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1191                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1192                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1193                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1194                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1195                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1196                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1197                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1198                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1199                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1200                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1201                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1202                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1203                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1204                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1205                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1206                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1207                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1208                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1209                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1210                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1211                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1212                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1213                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1214                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1215                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1216                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1217                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1218                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1219                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1220                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1221                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1222                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1223 };
1224
1225 static  uint8_t ms_hmac_key2[] = {
1226                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1227                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1228                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1229                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1230                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1231                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1232                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1233                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1234 };
1235
1236 static const uint8_t ms_hmac_digest2[] = {
1237                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1238                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1239                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1240                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1241                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1242                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1243                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1244                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1245 };
1246
1247 /* End Session 2 */
1248
1249
1250 static int
1251 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1252 {
1253         struct crypto_testsuite_params *ts_params = &testsuite_params;
1254         struct crypto_unittest_params *ut_params = &unittest_params;
1255
1256         /* Generate test mbuf data and space for digest */
1257         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1258                         catch_22_quote, QUOTE_512_BYTES, 0);
1259
1260         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1261                         DIGEST_BYTE_LENGTH_SHA1);
1262         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1263
1264         /* Setup Cipher Parameters */
1265         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1266         ut_params->cipher_xform.next = &ut_params->auth_xform;
1267
1268         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1269         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1270         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1271         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1272
1273         /* Setup HMAC Parameters */
1274         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1275
1276         ut_params->auth_xform.next = NULL;
1277
1278         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1279         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1280         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1281         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1282         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1283
1284         /* Create crypto session*/
1285         ut_params->sess = rte_cryptodev_sym_session_create(
1286                         ts_params->valid_devs[0],
1287                         &ut_params->cipher_xform);
1288         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1289
1290         /* Generate crypto op data structure */
1291         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1292                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1293         TEST_ASSERT_NOT_NULL(ut_params->op,
1294                         "Failed to allocate symmetric crypto operation struct");
1295
1296         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1297
1298         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1299
1300         /* set crypto operation source mbuf */
1301         sym_op->m_src = ut_params->ibuf;
1302
1303         /* Set crypto operation authentication parameters */
1304         sym_op->auth.digest.data = ut_params->digest;
1305         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1306                         ut_params->ibuf, QUOTE_512_BYTES);
1307         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
1308
1309         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1310         sym_op->auth.data.length = QUOTE_512_BYTES;
1311
1312         /* Set crypto operation cipher parameters */
1313         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1314                         CIPHER_IV_LENGTH_AES_CBC);
1315         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1316         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1317
1318         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1319                         CIPHER_IV_LENGTH_AES_CBC);
1320
1321         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1322         sym_op->cipher.data.length = QUOTE_512_BYTES;
1323
1324         /* Process crypto operation */
1325         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1326                         ut_params->op), "failed to process sym crypto op");
1327
1328         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1329                         "crypto op processing failed");
1330
1331         /* Validate obuf */
1332         uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
1333                         uint8_t *, CIPHER_IV_LENGTH_AES_CBC);
1334
1335         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1336                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1337                         QUOTE_512_BYTES,
1338                         "ciphertext data not as expected");
1339
1340         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1341
1342         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1343                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1344                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1345                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1346                                         DIGEST_BYTE_LENGTH_SHA1,
1347                         "Generated digest data not as expected");
1348
1349         return TEST_SUCCESS;
1350 }
1351
1352 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1353
1354 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
1355
1356 static uint8_t hmac_sha512_key[] = {
1357         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1358         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1359         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1360         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1361         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1362         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1363         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1364         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1365
1366 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1367         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1368         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1369         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1370         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1371         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1372         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1373         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1374         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1375
1376
1377
1378 static int
1379 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1380                 struct crypto_unittest_params *ut_params,
1381                 uint8_t *cipher_key,
1382                 uint8_t *hmac_key);
1383
1384 static int
1385 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1386                 struct crypto_unittest_params *ut_params,
1387                 struct crypto_testsuite_params *ts_params,
1388                 const uint8_t *cipher,
1389                 const uint8_t *digest,
1390                 const uint8_t *iv);
1391
1392
1393 static int
1394 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1395                 struct crypto_unittest_params *ut_params,
1396                 uint8_t *cipher_key,
1397                 uint8_t *hmac_key)
1398 {
1399
1400         /* Setup Cipher Parameters */
1401         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1402         ut_params->cipher_xform.next = NULL;
1403
1404         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1405         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1406         ut_params->cipher_xform.cipher.key.data = cipher_key;
1407         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1408
1409         /* Setup HMAC Parameters */
1410         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1411         ut_params->auth_xform.next = &ut_params->cipher_xform;
1412
1413         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1414         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1415         ut_params->auth_xform.auth.key.data = hmac_key;
1416         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1417         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1418
1419         return TEST_SUCCESS;
1420 }
1421
1422
1423 static int
1424 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1425                 struct crypto_unittest_params *ut_params,
1426                 struct crypto_testsuite_params *ts_params,
1427                 const uint8_t *cipher,
1428                 const uint8_t *digest,
1429                 const uint8_t *iv)
1430 {
1431         /* Generate test mbuf data and digest */
1432         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1433                         (const char *)
1434                         cipher,
1435                         QUOTE_512_BYTES, 0);
1436
1437         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1438                         DIGEST_BYTE_LENGTH_SHA512);
1439         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1440
1441         rte_memcpy(ut_params->digest,
1442                         digest,
1443                         DIGEST_BYTE_LENGTH_SHA512);
1444
1445         /* Generate Crypto op data structure */
1446         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1447                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1448         TEST_ASSERT_NOT_NULL(ut_params->op,
1449                         "Failed to allocate symmetric crypto operation struct");
1450
1451         rte_crypto_op_attach_sym_session(ut_params->op, sess);
1452
1453         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1454
1455         /* set crypto operation source mbuf */
1456         sym_op->m_src = ut_params->ibuf;
1457
1458         sym_op->auth.digest.data = ut_params->digest;
1459         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1460                         ut_params->ibuf, QUOTE_512_BYTES);
1461         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
1462
1463         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1464         sym_op->auth.data.length = QUOTE_512_BYTES;
1465
1466         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1467                         ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1468         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
1469                         ut_params->ibuf, 0);
1470         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1471
1472         rte_memcpy(sym_op->cipher.iv.data, iv,
1473                         CIPHER_IV_LENGTH_AES_CBC);
1474
1475         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1476         sym_op->cipher.data.length = QUOTE_512_BYTES;
1477
1478         /* Process crypto operation */
1479         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1480                         ut_params->op), "failed to process sym crypto op");
1481
1482         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1483                         "crypto op processing failed");
1484
1485         ut_params->obuf = ut_params->op->sym->m_src;
1486
1487         /* Validate obuf */
1488         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1489                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1490                         CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1491                         QUOTE_512_BYTES,
1492                         "Plaintext data not as expected");
1493
1494         /* Validate obuf */
1495         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1496                         "Digest verification failed");
1497
1498         return TEST_SUCCESS;
1499 }
1500
1501 static int
1502 test_AES_cipheronly_mb_all(void)
1503 {
1504         struct crypto_testsuite_params *ts_params = &testsuite_params;
1505         int status;
1506
1507         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1508                 ts_params->op_mpool, ts_params->valid_devs[0],
1509                 RTE_CRYPTODEV_AESNI_MB_PMD,
1510                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1511
1512         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1513
1514         return TEST_SUCCESS;
1515 }
1516
1517 static int
1518 test_AES_docsis_mb_all(void)
1519 {
1520         struct crypto_testsuite_params *ts_params = &testsuite_params;
1521         int status;
1522
1523         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1524                 ts_params->op_mpool, ts_params->valid_devs[0],
1525                 RTE_CRYPTODEV_AESNI_MB_PMD,
1526                 BLKCIPHER_AES_DOCSIS_TYPE);
1527
1528         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1529
1530         return TEST_SUCCESS;
1531 }
1532
1533 static int
1534 test_AES_docsis_qat_all(void)
1535 {
1536         struct crypto_testsuite_params *ts_params = &testsuite_params;
1537         int status;
1538
1539         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1540                 ts_params->op_mpool, ts_params->valid_devs[0],
1541                 RTE_CRYPTODEV_QAT_SYM_PMD,
1542                 BLKCIPHER_AES_DOCSIS_TYPE);
1543
1544         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1545
1546         return TEST_SUCCESS;
1547 }
1548
1549 static int
1550 test_DES_docsis_qat_all(void)
1551 {
1552         struct crypto_testsuite_params *ts_params = &testsuite_params;
1553         int status;
1554
1555         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1556                 ts_params->op_mpool, ts_params->valid_devs[0],
1557                 RTE_CRYPTODEV_QAT_SYM_PMD,
1558                 BLKCIPHER_DES_DOCSIS_TYPE);
1559
1560         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1561
1562         return TEST_SUCCESS;
1563 }
1564
1565 static int
1566 test_authonly_mb_all(void)
1567 {
1568         struct crypto_testsuite_params *ts_params = &testsuite_params;
1569         int status;
1570
1571         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1572                 ts_params->op_mpool, ts_params->valid_devs[0],
1573                 RTE_CRYPTODEV_AESNI_MB_PMD,
1574                 BLKCIPHER_AUTHONLY_TYPE);
1575
1576         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1577
1578         return TEST_SUCCESS;
1579 }
1580
1581 static int
1582 test_AES_chain_mb_all(void)
1583 {
1584         struct crypto_testsuite_params *ts_params = &testsuite_params;
1585         int status;
1586
1587         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1588                 ts_params->op_mpool, ts_params->valid_devs[0],
1589                 RTE_CRYPTODEV_AESNI_MB_PMD,
1590                 BLKCIPHER_AES_CHAIN_TYPE);
1591
1592         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1593
1594         return TEST_SUCCESS;
1595 }
1596
1597 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
1598
1599 static int
1600 test_AES_cipheronly_scheduler_all(void)
1601 {
1602         struct crypto_testsuite_params *ts_params = &testsuite_params;
1603         int status;
1604
1605         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1606                 ts_params->op_mpool, ts_params->valid_devs[0],
1607                 RTE_CRYPTODEV_SCHEDULER_PMD,
1608                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1609
1610         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1611
1612         return TEST_SUCCESS;
1613 }
1614
1615 static int
1616 test_AES_chain_scheduler_all(void)
1617 {
1618         struct crypto_testsuite_params *ts_params = &testsuite_params;
1619         int status;
1620
1621         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1622                 ts_params->op_mpool, ts_params->valid_devs[0],
1623                 RTE_CRYPTODEV_SCHEDULER_PMD,
1624                 BLKCIPHER_AES_CHAIN_TYPE);
1625
1626         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1627
1628         return TEST_SUCCESS;
1629 }
1630
1631 static int
1632 test_authonly_scheduler_all(void)
1633 {
1634         struct crypto_testsuite_params *ts_params = &testsuite_params;
1635         int status;
1636
1637         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1638                 ts_params->op_mpool, ts_params->valid_devs[0],
1639                 RTE_CRYPTODEV_SCHEDULER_PMD,
1640                 BLKCIPHER_AUTHONLY_TYPE);
1641
1642         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1643
1644         return TEST_SUCCESS;
1645 }
1646
1647 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
1648
1649 static int
1650 test_AES_chain_openssl_all(void)
1651 {
1652         struct crypto_testsuite_params *ts_params = &testsuite_params;
1653         int status;
1654
1655         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1656                 ts_params->op_mpool, ts_params->valid_devs[0],
1657                 RTE_CRYPTODEV_OPENSSL_PMD,
1658                 BLKCIPHER_AES_CHAIN_TYPE);
1659
1660         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1661
1662         return TEST_SUCCESS;
1663 }
1664
1665 static int
1666 test_AES_cipheronly_openssl_all(void)
1667 {
1668         struct crypto_testsuite_params *ts_params = &testsuite_params;
1669         int status;
1670
1671         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1672                 ts_params->op_mpool, ts_params->valid_devs[0],
1673                 RTE_CRYPTODEV_OPENSSL_PMD,
1674                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1675
1676         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1677
1678         return TEST_SUCCESS;
1679 }
1680
1681 static int
1682 test_AES_chain_qat_all(void)
1683 {
1684         struct crypto_testsuite_params *ts_params = &testsuite_params;
1685         int status;
1686
1687         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1688                 ts_params->op_mpool, ts_params->valid_devs[0],
1689                 RTE_CRYPTODEV_QAT_SYM_PMD,
1690                 BLKCIPHER_AES_CHAIN_TYPE);
1691
1692         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1693
1694         return TEST_SUCCESS;
1695 }
1696
1697 static int
1698 test_AES_cipheronly_qat_all(void)
1699 {
1700         struct crypto_testsuite_params *ts_params = &testsuite_params;
1701         int status;
1702
1703         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1704                 ts_params->op_mpool, ts_params->valid_devs[0],
1705                 RTE_CRYPTODEV_QAT_SYM_PMD,
1706                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1707
1708         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1709
1710         return TEST_SUCCESS;
1711 }
1712
1713 static int
1714 test_AES_chain_dpaa2_sec_all(void)
1715 {
1716         struct crypto_testsuite_params *ts_params = &testsuite_params;
1717         int status;
1718
1719         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1720                 ts_params->op_mpool, ts_params->valid_devs[0],
1721                 RTE_CRYPTODEV_DPAA2_SEC_PMD,
1722                 BLKCIPHER_AES_CHAIN_TYPE);
1723
1724         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1725
1726         return TEST_SUCCESS;
1727 }
1728
1729 static int
1730 test_AES_cipheronly_dpaa2_sec_all(void)
1731 {
1732         struct crypto_testsuite_params *ts_params = &testsuite_params;
1733         int status;
1734
1735         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1736                 ts_params->op_mpool, ts_params->valid_devs[0],
1737                 RTE_CRYPTODEV_DPAA2_SEC_PMD,
1738                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1739
1740         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1741
1742         return TEST_SUCCESS;
1743 }
1744
1745 static int
1746 test_authonly_openssl_all(void)
1747 {
1748         struct crypto_testsuite_params *ts_params = &testsuite_params;
1749         int status;
1750
1751         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1752                 ts_params->op_mpool, ts_params->valid_devs[0],
1753                 RTE_CRYPTODEV_OPENSSL_PMD,
1754                 BLKCIPHER_AUTHONLY_TYPE);
1755
1756         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1757
1758         return TEST_SUCCESS;
1759 }
1760
1761 static int
1762 test_AES_chain_armv8_all(void)
1763 {
1764         struct crypto_testsuite_params *ts_params = &testsuite_params;
1765         int status;
1766
1767         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1768                 ts_params->op_mpool, ts_params->valid_devs[0],
1769                 RTE_CRYPTODEV_ARMV8_PMD,
1770                 BLKCIPHER_AES_CHAIN_TYPE);
1771
1772         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1773
1774         return TEST_SUCCESS;
1775 }
1776
1777 /* ***** SNOW 3G Tests ***** */
1778 static int
1779 create_wireless_algo_hash_session(uint8_t dev_id,
1780         const uint8_t *key, const uint8_t key_len,
1781         const uint8_t aad_len, const uint8_t auth_len,
1782         enum rte_crypto_auth_operation op,
1783         enum rte_crypto_auth_algorithm algo)
1784 {
1785         uint8_t hash_key[key_len];
1786
1787         struct crypto_unittest_params *ut_params = &unittest_params;
1788
1789         memcpy(hash_key, key, key_len);
1790
1791         TEST_HEXDUMP(stdout, "key:", key, key_len);
1792
1793         /* Setup Authentication Parameters */
1794         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1795         ut_params->auth_xform.next = NULL;
1796
1797         ut_params->auth_xform.auth.op = op;
1798         ut_params->auth_xform.auth.algo = algo;
1799         ut_params->auth_xform.auth.key.length = key_len;
1800         ut_params->auth_xform.auth.key.data = hash_key;
1801         ut_params->auth_xform.auth.digest_length = auth_len;
1802         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1803         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1804                                 &ut_params->auth_xform);
1805         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1806         return 0;
1807 }
1808
1809 static int
1810 create_wireless_algo_cipher_session(uint8_t dev_id,
1811                         enum rte_crypto_cipher_operation op,
1812                         enum rte_crypto_cipher_algorithm algo,
1813                         const uint8_t *key, const uint8_t key_len)
1814 {
1815         uint8_t cipher_key[key_len];
1816
1817         struct crypto_unittest_params *ut_params = &unittest_params;
1818
1819         memcpy(cipher_key, key, key_len);
1820
1821         /* Setup Cipher Parameters */
1822         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1823         ut_params->cipher_xform.next = NULL;
1824
1825         ut_params->cipher_xform.cipher.algo = algo;
1826         ut_params->cipher_xform.cipher.op = op;
1827         ut_params->cipher_xform.cipher.key.data = cipher_key;
1828         ut_params->cipher_xform.cipher.key.length = key_len;
1829
1830         TEST_HEXDUMP(stdout, "key:", key, key_len);
1831
1832         /* Create Crypto session */
1833         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1834                                                 &ut_params->
1835                                                 cipher_xform);
1836         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1837         return 0;
1838 }
1839
1840 static int
1841 create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len,
1842                         const unsigned cipher_len,
1843                         const unsigned cipher_offset,
1844                         enum rte_crypto_cipher_algorithm algo)
1845 {
1846         struct crypto_testsuite_params *ts_params = &testsuite_params;
1847         struct crypto_unittest_params *ut_params = &unittest_params;
1848         unsigned iv_pad_len = 0;
1849
1850         /* Generate Crypto op data structure */
1851         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1852                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1853         TEST_ASSERT_NOT_NULL(ut_params->op,
1854                                 "Failed to allocate pktmbuf offload");
1855
1856         /* Set crypto operation data parameters */
1857         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1858
1859         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1860
1861         /* set crypto operation source mbuf */
1862         sym_op->m_src = ut_params->ibuf;
1863
1864         /* iv */
1865         if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1866                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1867         else
1868                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1869
1870         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf
1871                         , iv_pad_len);
1872
1873         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1874
1875         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1876         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1877         sym_op->cipher.iv.length = iv_pad_len;
1878
1879         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1880         sym_op->cipher.data.length = cipher_len;
1881         sym_op->cipher.data.offset = cipher_offset;
1882         return 0;
1883 }
1884
1885 static int
1886 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
1887                         const unsigned cipher_len,
1888                         const unsigned cipher_offset,
1889                         enum rte_crypto_cipher_algorithm algo)
1890 {
1891         struct crypto_testsuite_params *ts_params = &testsuite_params;
1892         struct crypto_unittest_params *ut_params = &unittest_params;
1893         unsigned iv_pad_len = 0;
1894
1895         /* Generate Crypto op data structure */
1896         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1897                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1898         TEST_ASSERT_NOT_NULL(ut_params->op,
1899                                 "Failed to allocate pktmbuf offload");
1900
1901         /* Set crypto operation data parameters */
1902         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1903
1904         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1905
1906         /* set crypto operation source mbuf */
1907         sym_op->m_src = ut_params->ibuf;
1908         sym_op->m_dst = ut_params->obuf;
1909
1910         /* iv */
1911         if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1912                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1913         else
1914                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1915         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1916                                         iv_pad_len);
1917
1918         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1919
1920         /* For OOP operation both buffers must have the same size */
1921         if (ut_params->obuf)
1922                 rte_pktmbuf_prepend(ut_params->obuf, iv_pad_len);
1923
1924         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1925         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1926         sym_op->cipher.iv.length = iv_pad_len;
1927
1928         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1929         sym_op->cipher.data.length = cipher_len;
1930         sym_op->cipher.data.offset = cipher_offset;
1931         return 0;
1932 }
1933
1934 static int
1935 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
1936                 enum rte_crypto_cipher_operation cipher_op,
1937                 enum rte_crypto_auth_operation auth_op,
1938                 enum rte_crypto_auth_algorithm auth_algo,
1939                 enum rte_crypto_cipher_algorithm cipher_algo,
1940                 const uint8_t *key, const uint8_t key_len,
1941                 const uint8_t aad_len, const uint8_t auth_len)
1942
1943 {
1944         uint8_t cipher_auth_key[key_len];
1945
1946         struct crypto_unittest_params *ut_params = &unittest_params;
1947
1948         memcpy(cipher_auth_key, key, key_len);
1949
1950         /* Setup Authentication Parameters */
1951         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1952         ut_params->auth_xform.next = NULL;
1953
1954         ut_params->auth_xform.auth.op = auth_op;
1955         ut_params->auth_xform.auth.algo = auth_algo;
1956         ut_params->auth_xform.auth.key.length = key_len;
1957         /* Hash key = cipher key */
1958         ut_params->auth_xform.auth.key.data = cipher_auth_key;
1959         ut_params->auth_xform.auth.digest_length = auth_len;
1960         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1961
1962         /* Setup Cipher Parameters */
1963         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1964         ut_params->cipher_xform.next = &ut_params->auth_xform;
1965
1966         ut_params->cipher_xform.cipher.algo = cipher_algo;
1967         ut_params->cipher_xform.cipher.op = cipher_op;
1968         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
1969         ut_params->cipher_xform.cipher.key.length = key_len;
1970
1971         TEST_HEXDUMP(stdout, "key:", key, key_len);
1972
1973         /* Create Crypto session*/
1974         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1975                                 &ut_params->cipher_xform);
1976
1977         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1978         return 0;
1979 }
1980
1981 static int
1982 create_wireless_cipher_auth_session(uint8_t dev_id,
1983                 enum rte_crypto_cipher_operation cipher_op,
1984                 enum rte_crypto_auth_operation auth_op,
1985                 enum rte_crypto_auth_algorithm auth_algo,
1986                 enum rte_crypto_cipher_algorithm cipher_algo,
1987                 const struct wireless_test_data *tdata)
1988 {
1989         const uint8_t key_len = tdata->key.len;
1990         uint8_t cipher_auth_key[key_len];
1991
1992         struct crypto_unittest_params *ut_params = &unittest_params;
1993         const uint8_t *key = tdata->key.data;
1994         const uint8_t aad_len = tdata->aad.len;
1995         const uint8_t auth_len = tdata->digest.len;
1996
1997         memcpy(cipher_auth_key, key, key_len);
1998
1999         /* Setup Authentication Parameters */
2000         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2001         ut_params->auth_xform.next = NULL;
2002
2003         ut_params->auth_xform.auth.op = auth_op;
2004         ut_params->auth_xform.auth.algo = auth_algo;
2005         ut_params->auth_xform.auth.key.length = key_len;
2006         /* Hash key = cipher key */
2007         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2008         ut_params->auth_xform.auth.digest_length = auth_len;
2009         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
2010
2011         /* Setup Cipher Parameters */
2012         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2013         ut_params->cipher_xform.next = &ut_params->auth_xform;
2014
2015         ut_params->cipher_xform.cipher.algo = cipher_algo;
2016         ut_params->cipher_xform.cipher.op = cipher_op;
2017         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2018         ut_params->cipher_xform.cipher.key.length = key_len;
2019
2020         TEST_HEXDUMP(stdout, "key:", key, key_len);
2021
2022         /* Create Crypto session*/
2023         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
2024                                 &ut_params->cipher_xform);
2025
2026         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2027         return 0;
2028 }
2029
2030 static int
2031 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2032                 const struct wireless_test_data *tdata)
2033 {
2034         return create_wireless_cipher_auth_session(dev_id,
2035                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2036                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2037                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2038 }
2039
2040 static int
2041 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2042                 enum rte_crypto_cipher_operation cipher_op,
2043                 enum rte_crypto_auth_operation auth_op,
2044                 enum rte_crypto_auth_algorithm auth_algo,
2045                 enum rte_crypto_cipher_algorithm cipher_algo,
2046                 const uint8_t *key, const uint8_t key_len,
2047                 const uint8_t aad_len, const uint8_t auth_len)
2048 {
2049         uint8_t auth_cipher_key[key_len];
2050
2051         struct crypto_unittest_params *ut_params = &unittest_params;
2052
2053         memcpy(auth_cipher_key, key, key_len);
2054
2055         /* Setup Authentication Parameters */
2056         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2057         ut_params->auth_xform.auth.op = auth_op;
2058         ut_params->auth_xform.next = &ut_params->cipher_xform;
2059         ut_params->auth_xform.auth.algo = auth_algo;
2060         ut_params->auth_xform.auth.key.length = key_len;
2061         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2062         ut_params->auth_xform.auth.digest_length = auth_len;
2063         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
2064
2065         /* Setup Cipher Parameters */
2066         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2067         ut_params->cipher_xform.next = NULL;
2068         ut_params->cipher_xform.cipher.algo = cipher_algo;
2069         ut_params->cipher_xform.cipher.op = cipher_op;
2070         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2071         ut_params->cipher_xform.cipher.key.length = key_len;
2072
2073         TEST_HEXDUMP(stdout, "key:", key, key_len);
2074
2075         /* Create Crypto session*/
2076         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
2077                                 &ut_params->auth_xform);
2078
2079         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2080
2081         return 0;
2082 }
2083
2084 static int
2085 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2086                 const unsigned auth_tag_len,
2087                 const uint8_t *aad, const unsigned aad_len,
2088                 unsigned data_pad_len,
2089                 enum rte_crypto_auth_operation op,
2090                 enum rte_crypto_auth_algorithm algo,
2091                 const unsigned auth_len, const unsigned auth_offset)
2092 {
2093         struct crypto_testsuite_params *ts_params = &testsuite_params;
2094
2095         struct crypto_unittest_params *ut_params = &unittest_params;
2096
2097         unsigned aad_buffer_len;
2098
2099         /* Generate Crypto op data structure */
2100         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2101                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2102         TEST_ASSERT_NOT_NULL(ut_params->op,
2103                 "Failed to allocate pktmbuf offload");
2104
2105         /* Set crypto operation data parameters */
2106         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2107
2108         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2109
2110         /* set crypto operation source mbuf */
2111         sym_op->m_src = ut_params->ibuf;
2112
2113         /* aad */
2114         /*
2115         * Always allocate the aad up to the block size.
2116         * The cryptodev API calls out -
2117         *  - the array must be big enough to hold the AAD, plus any
2118         *   space to round this up to the nearest multiple of the
2119         *   block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
2120         */
2121         if (algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2122                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2123         else
2124                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2125         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
2126                         ut_params->ibuf, aad_buffer_len);
2127         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2128                                         "no room to prepend aad");
2129         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2130                         ut_params->ibuf);
2131         sym_op->auth.aad.length = aad_len;
2132
2133         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2134         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2135
2136         TEST_HEXDUMP(stdout, "aad:",
2137                         sym_op->auth.aad.data, aad_len);
2138
2139         /* digest */
2140         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2141                                         ut_params->ibuf, auth_tag_len);
2142
2143         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2144                                 "no room to append auth tag");
2145         ut_params->digest = sym_op->auth.digest.data;
2146         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2147                         ut_params->ibuf, data_pad_len + aad_len);
2148         sym_op->auth.digest.length = auth_tag_len;
2149         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2150                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2151         else
2152                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2153
2154         TEST_HEXDUMP(stdout, "digest:",
2155                 sym_op->auth.digest.data,
2156                 sym_op->auth.digest.length);
2157
2158         sym_op->auth.data.length = auth_len;
2159         sym_op->auth.data.offset = auth_offset;
2160
2161         return 0;
2162 }
2163
2164 static int
2165 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2166         enum rte_crypto_auth_operation op,
2167         enum rte_crypto_auth_algorithm auth_algo,
2168         enum rte_crypto_cipher_algorithm cipher_algo)
2169 {
2170         struct crypto_testsuite_params *ts_params = &testsuite_params;
2171         struct crypto_unittest_params *ut_params = &unittest_params;
2172
2173         const uint8_t *auth_tag = tdata->digest.data;
2174         const unsigned int auth_tag_len = tdata->digest.len;
2175         const uint8_t *aad = tdata->aad.data;
2176         const uint8_t aad_len = tdata->aad.len;
2177         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2178         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2179
2180         const uint8_t *iv = tdata->iv.data;
2181         const uint8_t iv_len = tdata->iv.len;
2182         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2183         const unsigned int cipher_offset =
2184                 tdata->validCipherOffsetLenInBits.len;
2185         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2186         const unsigned int auth_offset = tdata->validAuthOffsetLenInBits.len;
2187
2188         unsigned int iv_pad_len = 0;
2189         unsigned int aad_buffer_len;
2190
2191         /* Generate Crypto op data structure */
2192         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2193                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2194         TEST_ASSERT_NOT_NULL(ut_params->op,
2195                         "Failed to allocate pktmbuf offload");
2196         /* Set crypto operation data parameters */
2197         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2198
2199         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2200
2201         /* set crypto operation source mbuf */
2202         sym_op->m_src = ut_params->ibuf;
2203
2204         /* digest */
2205         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2206                         ut_params->ibuf, auth_tag_len);
2207
2208         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2209                         "no room to append auth tag");
2210         ut_params->digest = sym_op->auth.digest.data;
2211         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2212                         ut_params->ibuf, data_pad_len);
2213         sym_op->auth.digest.length = auth_tag_len;
2214         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2215                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2216         else
2217                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2218
2219         TEST_HEXDUMP(stdout, "digest:",
2220                 sym_op->auth.digest.data,
2221                 sym_op->auth.digest.length);
2222
2223         /* aad */
2224         /*
2225         * Always allocate the aad up to the block size.
2226         * The cryptodev API calls out -
2227         *  - the array must be big enough to hold the AAD, plus any
2228         *   space to round this up to the nearest multiple of the
2229         *   block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
2230         */
2231         if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2232                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2233         else
2234                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2235         sym_op->auth.aad.data =
2236                 (uint8_t *)rte_pktmbuf_prepend(
2237                         ut_params->ibuf, aad_buffer_len);
2238         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2239                         "no room to prepend aad");
2240         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2241                         ut_params->ibuf);
2242         sym_op->auth.aad.length = aad_len;
2243         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2244         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2245         TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
2246
2247         /* iv */
2248         if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
2249                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
2250         else
2251                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2252         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2253                 ut_params->ibuf, iv_pad_len);
2254
2255         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2256         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2257         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2258         sym_op->cipher.iv.length = iv_pad_len;
2259         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2260         sym_op->cipher.data.length = cipher_len;
2261         sym_op->cipher.data.offset = cipher_offset + auth_offset;
2262         sym_op->auth.data.length = auth_len;
2263         sym_op->auth.data.offset = auth_offset + cipher_offset;
2264
2265         return 0;
2266 }
2267
2268 static int
2269 create_zuc_cipher_hash_generate_operation(
2270                 const struct wireless_test_data *tdata)
2271 {
2272         return create_wireless_cipher_hash_operation(tdata,
2273                 RTE_CRYPTO_AUTH_OP_GENERATE,
2274                 RTE_CRYPTO_AUTH_ZUC_EIA3,
2275                 RTE_CRYPTO_CIPHER_ZUC_EEA3);
2276 }
2277
2278 static int
2279 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2280                 const unsigned auth_tag_len,
2281                 const uint8_t *aad, const uint8_t aad_len,
2282                 unsigned data_pad_len,
2283                 enum rte_crypto_auth_operation op,
2284                 enum rte_crypto_auth_algorithm auth_algo,
2285                 enum rte_crypto_cipher_algorithm cipher_algo,
2286                 const uint8_t *iv, const uint8_t iv_len,
2287                 const unsigned cipher_len, const unsigned cipher_offset,
2288                 const unsigned auth_len, const unsigned auth_offset)
2289 {
2290         struct crypto_testsuite_params *ts_params = &testsuite_params;
2291         struct crypto_unittest_params *ut_params = &unittest_params;
2292
2293         unsigned iv_pad_len = 0;
2294         unsigned aad_buffer_len;
2295
2296         /* Generate Crypto op data structure */
2297         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2298                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2299         TEST_ASSERT_NOT_NULL(ut_params->op,
2300                         "Failed to allocate pktmbuf offload");
2301         /* Set crypto operation data parameters */
2302         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2303
2304         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2305
2306         /* set crypto operation source mbuf */
2307         sym_op->m_src = ut_params->ibuf;
2308
2309         /* digest */
2310         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2311                         ut_params->ibuf, auth_tag_len);
2312
2313         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2314                         "no room to append auth tag");
2315         ut_params->digest = sym_op->auth.digest.data;
2316         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2317                         ut_params->ibuf, data_pad_len);
2318         sym_op->auth.digest.length = auth_tag_len;
2319         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2320                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2321         else
2322                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2323
2324         TEST_HEXDUMP(stdout, "digest:",
2325                 sym_op->auth.digest.data,
2326                 sym_op->auth.digest.length);
2327
2328         /* aad */
2329         /*
2330         * Always allocate the aad up to the block size.
2331         * The cryptodev API calls out -
2332         *  - the array must be big enough to hold the AAD, plus any
2333         *   space to round this up to the nearest multiple of the
2334         *   block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
2335         */
2336         if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2337                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2338         else
2339                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2340         sym_op->auth.aad.data =
2341                 (uint8_t *)rte_pktmbuf_prepend(
2342                         ut_params->ibuf, aad_buffer_len);
2343         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2344                         "no room to prepend aad");
2345         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2346                         ut_params->ibuf);
2347         sym_op->auth.aad.length = aad_len;
2348         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2349         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2350         TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
2351
2352         /* iv */
2353         if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
2354                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
2355         else
2356                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2357         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2358                 ut_params->ibuf, iv_pad_len);
2359
2360         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2361         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2362         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2363         sym_op->cipher.iv.length = iv_pad_len;
2364         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2365         sym_op->cipher.data.length = cipher_len;
2366         sym_op->cipher.data.offset = cipher_offset + auth_offset;
2367         sym_op->auth.data.length = auth_len;
2368         sym_op->auth.data.offset = auth_offset + cipher_offset;
2369
2370         return 0;
2371 }
2372
2373 static int
2374 create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len,
2375                 const uint8_t *iv, const uint8_t iv_len,
2376                 const uint8_t *aad, const uint8_t aad_len,
2377                 unsigned data_pad_len,
2378                 const unsigned cipher_len, const unsigned cipher_offset,
2379                 const unsigned auth_len, const unsigned auth_offset,
2380                 enum rte_crypto_auth_algorithm auth_algo,
2381                 enum rte_crypto_cipher_algorithm cipher_algo)
2382 {
2383         struct crypto_testsuite_params *ts_params = &testsuite_params;
2384         struct crypto_unittest_params *ut_params = &unittest_params;
2385
2386         unsigned iv_pad_len = 0;
2387         unsigned aad_buffer_len = 0;
2388
2389         /* Generate Crypto op data structure */
2390         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2391                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2392         TEST_ASSERT_NOT_NULL(ut_params->op,
2393                         "Failed to allocate pktmbuf offload");
2394
2395         /* Set crypto operation data parameters */
2396         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2397
2398         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2399
2400         /* set crypto operation source mbuf */
2401         sym_op->m_src = ut_params->ibuf;
2402
2403         /* digest */
2404         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2405                         ut_params->ibuf, auth_tag_len);
2406
2407         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2408                         "no room to append auth tag");
2409
2410         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2411                         ut_params->ibuf, data_pad_len);
2412         sym_op->auth.digest.length = auth_tag_len;
2413
2414         memset(sym_op->auth.digest.data, 0, auth_tag_len);
2415
2416         TEST_HEXDUMP(stdout, "digest:",
2417                         sym_op->auth.digest.data,
2418                         sym_op->auth.digest.length);
2419
2420         /* aad */
2421         /*
2422         * Always allocate the aad up to the block size.
2423         * The cryptodev API calls out -
2424         *  - the array must be big enough to hold the AAD, plus any
2425         *   space to round this up to the nearest multiple of the
2426         *   block size (8 bytes for KASUMI 16 bytes).
2427         */
2428         if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2429                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2430         else
2431                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2432         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
2433         ut_params->ibuf, aad_buffer_len);
2434         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2435                                 "no room to prepend aad");
2436         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2437                                 ut_params->ibuf);
2438         sym_op->auth.aad.length = aad_len;
2439         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2440         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2441         TEST_HEXDUMP(stdout, "aad:",
2442                         sym_op->auth.aad.data, aad_len);
2443
2444         /* iv */
2445         if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
2446                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
2447         else
2448                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2449
2450         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2451                 ut_params->ibuf, iv_pad_len);
2452         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2453
2454         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2455         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2456         sym_op->cipher.iv.length = iv_pad_len;
2457
2458         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2459
2460         sym_op->cipher.data.length = cipher_len;
2461         sym_op->cipher.data.offset = auth_offset + cipher_offset;
2462
2463         sym_op->auth.data.length = auth_len;
2464         sym_op->auth.data.offset = auth_offset + cipher_offset;
2465
2466         return 0;
2467 }
2468
2469 static int
2470 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2471 {
2472         struct crypto_testsuite_params *ts_params = &testsuite_params;
2473         struct crypto_unittest_params *ut_params = &unittest_params;
2474
2475         int retval;
2476         unsigned plaintext_pad_len;
2477         unsigned plaintext_len;
2478         uint8_t *plaintext;
2479
2480         /* Create SNOW 3G session */
2481         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2482                         tdata->key.data, tdata->key.len,
2483                         tdata->aad.len, tdata->digest.len,
2484                         RTE_CRYPTO_AUTH_OP_GENERATE,
2485                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2486         if (retval < 0)
2487                 return retval;
2488
2489         /* alloc mbuf and set payload */
2490         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2491
2492         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2493         rte_pktmbuf_tailroom(ut_params->ibuf));
2494
2495         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2496         /* Append data which is padded to a multiple of */
2497         /* the algorithms block size */
2498         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2499         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2500                                 plaintext_pad_len);
2501         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2502
2503         /* Create SNOW 3G operation */
2504         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2505                         tdata->aad.data, tdata->aad.len,
2506                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2507                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2508                         tdata->validAuthLenInBits.len,
2509                         tdata->validAuthOffsetLenInBits.len);
2510         if (retval < 0)
2511                 return retval;
2512
2513         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2514                                 ut_params->op);
2515         ut_params->obuf = ut_params->op->sym->m_src;
2516         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2517         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2518                         + plaintext_pad_len + tdata->aad.len;
2519
2520         /* Validate obuf */
2521         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2522         ut_params->digest,
2523         tdata->digest.data,
2524         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2525         "SNOW 3G Generated auth tag not as expected");
2526
2527         return 0;
2528 }
2529
2530 static int
2531 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2532 {
2533         struct crypto_testsuite_params *ts_params = &testsuite_params;
2534         struct crypto_unittest_params *ut_params = &unittest_params;
2535
2536         int retval;
2537         unsigned plaintext_pad_len;
2538         unsigned plaintext_len;
2539         uint8_t *plaintext;
2540
2541         /* Create SNOW 3G session */
2542         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2543                                 tdata->key.data, tdata->key.len,
2544                                 tdata->aad.len, tdata->digest.len,
2545                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2546                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2547         if (retval < 0)
2548                 return retval;
2549         /* alloc mbuf and set payload */
2550         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2551
2552         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2553         rte_pktmbuf_tailroom(ut_params->ibuf));
2554
2555         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2556         /* Append data which is padded to a multiple of */
2557         /* the algorithms block size */
2558         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2559         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2560                                 plaintext_pad_len);
2561         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2562
2563         /* Create SNOW 3G operation */
2564         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2565                         tdata->digest.len,
2566                         tdata->aad.data, tdata->aad.len,
2567                         plaintext_pad_len,
2568                         RTE_CRYPTO_AUTH_OP_VERIFY,
2569                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2570                         tdata->validAuthLenInBits.len,
2571                         tdata->validAuthOffsetLenInBits.len);
2572         if (retval < 0)
2573                 return retval;
2574
2575         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2576                                 ut_params->op);
2577         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2578         ut_params->obuf = ut_params->op->sym->m_src;
2579         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2580                                 + plaintext_pad_len + tdata->aad.len;
2581
2582         /* Validate obuf */
2583         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2584                 return 0;
2585         else
2586                 return -1;
2587
2588         return 0;
2589 }
2590
2591 static int
2592 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2593 {
2594         struct crypto_testsuite_params *ts_params = &testsuite_params;
2595         struct crypto_unittest_params *ut_params = &unittest_params;
2596
2597         int retval;
2598         unsigned plaintext_pad_len;
2599         unsigned plaintext_len;
2600         uint8_t *plaintext;
2601
2602         /* Create KASUMI session */
2603         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2604                         tdata->key.data, tdata->key.len,
2605                         tdata->aad.len, tdata->digest.len,
2606                         RTE_CRYPTO_AUTH_OP_GENERATE,
2607                         RTE_CRYPTO_AUTH_KASUMI_F9);
2608         if (retval < 0)
2609                 return retval;
2610
2611         /* alloc mbuf and set payload */
2612         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2613
2614         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2615         rte_pktmbuf_tailroom(ut_params->ibuf));
2616
2617         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2618         /* Append data which is padded to a multiple of */
2619         /* the algorithms block size */
2620         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2621         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2622                                 plaintext_pad_len);
2623         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2624
2625         /* Create KASUMI operation */
2626         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2627                         tdata->aad.data, tdata->aad.len,
2628                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2629                         RTE_CRYPTO_AUTH_KASUMI_F9,
2630                         tdata->validAuthLenInBits.len,
2631                         tdata->validAuthOffsetLenInBits.len);
2632         if (retval < 0)
2633                 return retval;
2634
2635         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2636                                 ut_params->op);
2637         ut_params->obuf = ut_params->op->sym->m_src;
2638         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2639         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2640                         + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
2641
2642         /* Validate obuf */
2643         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2644         ut_params->digest,
2645         tdata->digest.data,
2646         DIGEST_BYTE_LENGTH_KASUMI_F9,
2647         "KASUMI Generated auth tag not as expected");
2648
2649         return 0;
2650 }
2651
2652 static int
2653 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
2654 {
2655         struct crypto_testsuite_params *ts_params = &testsuite_params;
2656         struct crypto_unittest_params *ut_params = &unittest_params;
2657
2658         int retval;
2659         unsigned plaintext_pad_len;
2660         unsigned plaintext_len;
2661         uint8_t *plaintext;
2662
2663         /* Create KASUMI session */
2664         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2665                                 tdata->key.data, tdata->key.len,
2666                                 tdata->aad.len, tdata->digest.len,
2667                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2668                                 RTE_CRYPTO_AUTH_KASUMI_F9);
2669         if (retval < 0)
2670                 return retval;
2671         /* alloc mbuf and set payload */
2672         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2673
2674         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2675         rte_pktmbuf_tailroom(ut_params->ibuf));
2676
2677         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2678         /* Append data which is padded to a multiple */
2679         /* of the algorithms block size */
2680         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2681         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2682                                 plaintext_pad_len);
2683         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2684
2685         /* Create KASUMI operation */
2686         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2687                         tdata->digest.len,
2688                         tdata->aad.data, tdata->aad.len,
2689                         plaintext_pad_len,
2690                         RTE_CRYPTO_AUTH_OP_VERIFY,
2691                         RTE_CRYPTO_AUTH_KASUMI_F9,
2692                         tdata->validAuthLenInBits.len,
2693                         tdata->validAuthOffsetLenInBits.len);
2694         if (retval < 0)
2695                 return retval;
2696
2697         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2698                                 ut_params->op);
2699         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2700         ut_params->obuf = ut_params->op->sym->m_src;
2701         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2702                                 + plaintext_pad_len + tdata->aad.len;
2703
2704         /* Validate obuf */
2705         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2706                 return 0;
2707         else
2708                 return -1;
2709
2710         return 0;
2711 }
2712
2713 static int
2714 test_snow3g_hash_generate_test_case_1(void)
2715 {
2716         return test_snow3g_authentication(&snow3g_hash_test_case_1);
2717 }
2718
2719 static int
2720 test_snow3g_hash_generate_test_case_2(void)
2721 {
2722         return test_snow3g_authentication(&snow3g_hash_test_case_2);
2723 }
2724
2725 static int
2726 test_snow3g_hash_generate_test_case_3(void)
2727 {
2728         return test_snow3g_authentication(&snow3g_hash_test_case_3);
2729 }
2730
2731 static int
2732 test_snow3g_hash_generate_test_case_4(void)
2733 {
2734         return test_snow3g_authentication(&snow3g_hash_test_case_4);
2735 }
2736
2737 static int
2738 test_snow3g_hash_generate_test_case_5(void)
2739 {
2740         return test_snow3g_authentication(&snow3g_hash_test_case_5);
2741 }
2742
2743 static int
2744 test_snow3g_hash_generate_test_case_6(void)
2745 {
2746         return test_snow3g_authentication(&snow3g_hash_test_case_6);
2747 }
2748
2749 static int
2750 test_snow3g_hash_verify_test_case_1(void)
2751 {
2752         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
2753
2754 }
2755
2756 static int
2757 test_snow3g_hash_verify_test_case_2(void)
2758 {
2759         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
2760 }
2761
2762 static int
2763 test_snow3g_hash_verify_test_case_3(void)
2764 {
2765         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
2766 }
2767
2768 static int
2769 test_snow3g_hash_verify_test_case_4(void)
2770 {
2771         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
2772 }
2773
2774 static int
2775 test_snow3g_hash_verify_test_case_5(void)
2776 {
2777         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
2778 }
2779
2780 static int
2781 test_snow3g_hash_verify_test_case_6(void)
2782 {
2783         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
2784 }
2785
2786 static int
2787 test_kasumi_hash_generate_test_case_1(void)
2788 {
2789         return test_kasumi_authentication(&kasumi_hash_test_case_1);
2790 }
2791
2792 static int
2793 test_kasumi_hash_generate_test_case_2(void)
2794 {
2795         return test_kasumi_authentication(&kasumi_hash_test_case_2);
2796 }
2797
2798 static int
2799 test_kasumi_hash_generate_test_case_3(void)
2800 {
2801         return test_kasumi_authentication(&kasumi_hash_test_case_3);
2802 }
2803
2804 static int
2805 test_kasumi_hash_generate_test_case_4(void)
2806 {
2807         return test_kasumi_authentication(&kasumi_hash_test_case_4);
2808 }
2809
2810 static int
2811 test_kasumi_hash_generate_test_case_5(void)
2812 {
2813         return test_kasumi_authentication(&kasumi_hash_test_case_5);
2814 }
2815
2816 static int
2817 test_kasumi_hash_generate_test_case_6(void)
2818 {
2819         return test_kasumi_authentication(&kasumi_hash_test_case_6);
2820 }
2821
2822 static int
2823 test_kasumi_hash_verify_test_case_1(void)
2824 {
2825         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
2826 }
2827
2828 static int
2829 test_kasumi_hash_verify_test_case_2(void)
2830 {
2831         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
2832 }
2833
2834 static int
2835 test_kasumi_hash_verify_test_case_3(void)
2836 {
2837         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
2838 }
2839
2840 static int
2841 test_kasumi_hash_verify_test_case_4(void)
2842 {
2843         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
2844 }
2845
2846 static int
2847 test_kasumi_hash_verify_test_case_5(void)
2848 {
2849         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
2850 }
2851
2852 static int
2853 test_kasumi_encryption(const struct kasumi_test_data *tdata)
2854 {
2855         struct crypto_testsuite_params *ts_params = &testsuite_params;
2856         struct crypto_unittest_params *ut_params = &unittest_params;
2857
2858         int retval;
2859         uint8_t *plaintext, *ciphertext;
2860         unsigned plaintext_pad_len;
2861         unsigned plaintext_len;
2862
2863         /* Create KASUMI session */
2864         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2865                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2866                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2867                                         tdata->key.data, tdata->key.len);
2868         if (retval < 0)
2869                 return retval;
2870
2871         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2872
2873         /* Clear mbuf payload */
2874         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2875                rte_pktmbuf_tailroom(ut_params->ibuf));
2876
2877         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2878         /* Append data which is padded to a multiple */
2879         /* of the algorithms block size */
2880         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2881         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2882                                 plaintext_pad_len);
2883         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2884
2885         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2886
2887         /* Create KASUMI operation */
2888         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
2889                                         tdata->plaintext.len,
2890                                         tdata->validCipherOffsetLenInBits.len,
2891                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2892         if (retval < 0)
2893                 return retval;
2894
2895         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2896                                                 ut_params->op);
2897         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2898
2899         ut_params->obuf = ut_params->op->sym->m_dst;
2900         if (ut_params->obuf)
2901                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2902                                 + tdata->iv.len;
2903         else
2904                 ciphertext = plaintext;
2905
2906         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2907
2908         /* Validate obuf */
2909         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2910                 ciphertext,
2911                 tdata->ciphertext.data,
2912                 tdata->validCipherLenInBits.len,
2913                 "KASUMI Ciphertext data not as expected");
2914         return 0;
2915 }
2916
2917 static int
2918 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
2919 {
2920         struct crypto_testsuite_params *ts_params = &testsuite_params;
2921         struct crypto_unittest_params *ut_params = &unittest_params;
2922
2923         int retval;
2924
2925         unsigned int plaintext_pad_len;
2926         unsigned int plaintext_len;
2927
2928         uint8_t buffer[10000];
2929         const uint8_t *ciphertext;
2930
2931         struct rte_cryptodev_info dev_info;
2932
2933         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2934         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
2935                 printf("Device doesn't support scatter-gather. "
2936                                 "Test Skipped.\n");
2937                 return 0;
2938         }
2939
2940         /* Create KASUMI session */
2941         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2942                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2943                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2944                                         tdata->key.data, tdata->key.len);
2945         if (retval < 0)
2946                 return retval;
2947
2948         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2949
2950
2951         /* Append data which is padded to a multiple */
2952         /* of the algorithms block size */
2953         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2954
2955         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
2956                         plaintext_pad_len, 10, 0);
2957
2958         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
2959
2960         /* Create KASUMI operation */
2961         retval = create_wireless_algo_cipher_operation(tdata->iv.data,
2962                                         tdata->iv.len,
2963                                         tdata->plaintext.len,
2964                                         tdata->validCipherOffsetLenInBits.len,
2965                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2966         if (retval < 0)
2967                 return retval;
2968
2969         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2970                                                 ut_params->op);
2971         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2972
2973         ut_params->obuf = ut_params->op->sym->m_dst;
2974
2975         if (ut_params->obuf)
2976                 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
2977                                 plaintext_len, buffer);
2978         else
2979                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
2980                                 plaintext_len, buffer);
2981
2982         /* Validate obuf */
2983         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2984
2985                 /* Validate obuf */
2986                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2987                         ciphertext,
2988                         tdata->ciphertext.data,
2989                         tdata->validCipherLenInBits.len,
2990                         "KASUMI Ciphertext data not as expected");
2991                 return 0;
2992 }
2993
2994 static int
2995 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
2996 {
2997         struct crypto_testsuite_params *ts_params = &testsuite_params;
2998         struct crypto_unittest_params *ut_params = &unittest_params;
2999
3000         int retval;
3001         uint8_t *plaintext, *ciphertext;
3002         unsigned plaintext_pad_len;
3003         unsigned plaintext_len;
3004
3005         /* Create KASUMI session */
3006         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3007                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3008                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3009                                         tdata->key.data, tdata->key.len);
3010         if (retval < 0)
3011                 return retval;
3012
3013         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3014         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3015
3016         /* Clear mbuf payload */
3017         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3018                rte_pktmbuf_tailroom(ut_params->ibuf));
3019
3020         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3021         /* Append data which is padded to a multiple */
3022         /* of the algorithms block size */
3023         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3024         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3025                                 plaintext_pad_len);
3026         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3027         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3028
3029         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3030
3031         /* Create KASUMI operation */
3032         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3033                                         tdata->iv.len,
3034                                         tdata->plaintext.len,
3035                                         tdata->validCipherOffsetLenInBits.len,
3036                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
3037         if (retval < 0)
3038                 return retval;
3039
3040         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3041                                                 ut_params->op);
3042         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3043
3044         ut_params->obuf = ut_params->op->sym->m_dst;
3045         if (ut_params->obuf)
3046                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3047                                 + tdata->iv.len;
3048         else
3049                 ciphertext = plaintext;
3050
3051         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3052
3053         /* Validate obuf */
3054         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3055                 ciphertext,
3056                 tdata->ciphertext.data,
3057                 tdata->validCipherLenInBits.len,
3058                 "KASUMI Ciphertext data not as expected");
3059         return 0;
3060 }
3061
3062 static int
3063 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3064 {
3065         struct crypto_testsuite_params *ts_params = &testsuite_params;
3066         struct crypto_unittest_params *ut_params = &unittest_params;
3067
3068         int retval;
3069         unsigned int plaintext_pad_len;
3070         unsigned int plaintext_len;
3071
3072         const uint8_t *ciphertext;
3073         uint8_t buffer[2048];
3074
3075         struct rte_cryptodev_info dev_info;
3076
3077         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3078         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
3079                 printf("Device doesn't support scatter-gather. "
3080                                 "Test Skipped.\n");
3081                 return 0;
3082         }
3083
3084         /* Create KASUMI session */
3085         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3086                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3087                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3088                                         tdata->key.data, tdata->key.len);
3089         if (retval < 0)
3090                 return retval;
3091
3092         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3093         /* Append data which is padded to a multiple */
3094         /* of the algorithms block size */
3095         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3096
3097         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3098                         plaintext_pad_len, 10, 0);
3099         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3100                         plaintext_pad_len, 3, 0);
3101
3102         /* Append data which is padded to a multiple */
3103         /* of the algorithms block size */
3104         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3105
3106         /* Create KASUMI operation */
3107         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3108                                         tdata->iv.len,
3109                                         tdata->plaintext.len,
3110                                         tdata->validCipherOffsetLenInBits.len,
3111                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
3112         if (retval < 0)
3113                 return retval;
3114
3115         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3116                                                 ut_params->op);
3117         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3118
3119         ut_params->obuf = ut_params->op->sym->m_dst;
3120         if (ut_params->obuf)
3121                 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
3122                                 plaintext_pad_len, buffer);
3123         else
3124                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
3125                                 plaintext_pad_len, buffer);
3126
3127         /* Validate obuf */
3128         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3129                 ciphertext,
3130                 tdata->ciphertext.data,
3131                 tdata->validCipherLenInBits.len,
3132                 "KASUMI Ciphertext data not as expected");
3133         return 0;
3134 }
3135
3136
3137 static int
3138 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3139 {
3140         struct crypto_testsuite_params *ts_params = &testsuite_params;
3141         struct crypto_unittest_params *ut_params = &unittest_params;
3142
3143         int retval;
3144         uint8_t *ciphertext, *plaintext;
3145         unsigned ciphertext_pad_len;
3146         unsigned ciphertext_len;
3147
3148         /* Create KASUMI session */
3149         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3150                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3151                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3152                                         tdata->key.data, tdata->key.len);
3153         if (retval < 0)
3154                 return retval;
3155
3156         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3157         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3158
3159         /* Clear mbuf payload */
3160         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3161                rte_pktmbuf_tailroom(ut_params->ibuf));
3162
3163         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3164         /* Append data which is padded to a multiple */
3165         /* of the algorithms block size */
3166         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3167         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3168                                 ciphertext_pad_len);
3169         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3170         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3171
3172         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3173
3174         /* Create KASUMI operation */
3175         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3176                                         tdata->iv.len,
3177                                         tdata->ciphertext.len,
3178                                         tdata->validCipherOffsetLenInBits.len,
3179                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
3180         if (retval < 0)
3181                 return retval;
3182
3183         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3184                                                 ut_params->op);
3185         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3186
3187         ut_params->obuf = ut_params->op->sym->m_dst;
3188         if (ut_params->obuf)
3189                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3190                                 + tdata->iv.len;
3191         else
3192                 plaintext = ciphertext;
3193
3194         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3195
3196         /* Validate obuf */
3197         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3198                 plaintext,
3199                 tdata->plaintext.data,
3200                 tdata->validCipherLenInBits.len,
3201                 "KASUMI Plaintext data not as expected");
3202         return 0;
3203 }
3204
3205 static int
3206 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3207 {
3208         struct crypto_testsuite_params *ts_params = &testsuite_params;
3209         struct crypto_unittest_params *ut_params = &unittest_params;
3210
3211         int retval;
3212         uint8_t *ciphertext, *plaintext;
3213         unsigned ciphertext_pad_len;
3214         unsigned ciphertext_len;
3215
3216         /* Create KASUMI session */
3217         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3218                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3219                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3220                                         tdata->key.data, tdata->key.len);
3221         if (retval < 0)
3222                 return retval;
3223
3224         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3225
3226         /* Clear mbuf payload */
3227         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3228                rte_pktmbuf_tailroom(ut_params->ibuf));
3229
3230         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3231         /* Append data which is padded to a multiple */
3232         /* of the algorithms block size */
3233         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3234         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3235                                 ciphertext_pad_len);
3236         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3237
3238         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3239
3240         /* Create KASUMI operation */
3241         retval = create_wireless_algo_cipher_operation(tdata->iv.data,
3242                                         tdata->iv.len,
3243                                         tdata->ciphertext.len,
3244                                         tdata->validCipherOffsetLenInBits.len,
3245                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
3246         if (retval < 0)
3247                 return retval;
3248
3249         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3250                                                 ut_params->op);
3251         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3252
3253         ut_params->obuf = ut_params->op->sym->m_dst;
3254         if (ut_params->obuf)
3255                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3256                                 + tdata->iv.len;
3257         else
3258                 plaintext = ciphertext;
3259
3260         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3261
3262         /* Validate obuf */
3263         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3264                 plaintext,
3265                 tdata->plaintext.data,
3266                 tdata->validCipherLenInBits.len,
3267                 "KASUMI Plaintext data not as expected");
3268         return 0;
3269 }
3270
3271 static int
3272 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3273 {
3274         struct crypto_testsuite_params *ts_params = &testsuite_params;
3275         struct crypto_unittest_params *ut_params = &unittest_params;
3276
3277         int retval;
3278         uint8_t *plaintext, *ciphertext;
3279         unsigned plaintext_pad_len;
3280         unsigned plaintext_len;
3281
3282         /* Create SNOW 3G session */
3283         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3284                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3285                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3286                                         tdata->key.data, tdata->key.len);
3287         if (retval < 0)
3288                 return retval;
3289
3290         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3291
3292         /* Clear mbuf payload */
3293         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3294                rte_pktmbuf_tailroom(ut_params->ibuf));
3295
3296         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3297         /* Append data which is padded to a multiple of */
3298         /* the algorithms block size */
3299         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3300         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3301                                 plaintext_pad_len);
3302         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3303
3304         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3305
3306         /* Create SNOW 3G operation */
3307         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3308                                         tdata->validCipherLenInBits.len,
3309                                         tdata->validCipherOffsetLenInBits.len,
3310                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3311         if (retval < 0)
3312                 return retval;
3313
3314         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3315                                                 ut_params->op);
3316         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3317
3318         ut_params->obuf = ut_params->op->sym->m_dst;
3319         if (ut_params->obuf)
3320                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3321                                 + tdata->iv.len;
3322         else
3323                 ciphertext = plaintext;
3324
3325         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3326
3327         /* Validate obuf */
3328         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3329                 ciphertext,
3330                 tdata->ciphertext.data,
3331                 tdata->validDataLenInBits.len,
3332                 "SNOW 3G Ciphertext data not as expected");
3333         return 0;
3334 }
3335
3336
3337 static int
3338 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
3339 {
3340         struct crypto_testsuite_params *ts_params = &testsuite_params;
3341         struct crypto_unittest_params *ut_params = &unittest_params;
3342         uint8_t *plaintext, *ciphertext;
3343
3344         int retval;
3345         unsigned plaintext_pad_len;
3346         unsigned plaintext_len;
3347
3348         /* Create SNOW 3G session */
3349         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3350                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3351                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3352                                         tdata->key.data, tdata->key.len);
3353         if (retval < 0)
3354                 return retval;
3355
3356         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3357         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3358
3359         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3360                         "Failed to allocate input buffer in mempool");
3361         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3362                         "Failed to allocate output buffer in mempool");
3363
3364         /* Clear mbuf payload */
3365         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3366                rte_pktmbuf_tailroom(ut_params->ibuf));
3367
3368         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3369         /* Append data which is padded to a multiple of */
3370         /* the algorithms block size */
3371         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3372         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3373                                 plaintext_pad_len);
3374         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3375         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3376
3377         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3378
3379         /* Create SNOW 3G operation */
3380         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3381                                         tdata->iv.len,
3382                                         tdata->validCipherLenInBits.len,
3383                                         tdata->validCipherOffsetLenInBits.len,
3384                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3385         if (retval < 0)
3386                 return retval;
3387
3388         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3389                                                 ut_params->op);
3390         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3391
3392         ut_params->obuf = ut_params->op->sym->m_dst;
3393         if (ut_params->obuf)
3394                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3395                                 + tdata->iv.len;
3396         else
3397                 ciphertext = plaintext;
3398
3399         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3400
3401         /* Validate obuf */
3402         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3403                 ciphertext,
3404                 tdata->ciphertext.data,
3405                 tdata->validDataLenInBits.len,
3406                 "SNOW 3G Ciphertext data not as expected");
3407         return 0;
3408 }
3409
3410 static int
3411 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
3412 {
3413         struct crypto_testsuite_params *ts_params = &testsuite_params;
3414         struct crypto_unittest_params *ut_params = &unittest_params;
3415
3416         int retval;
3417         unsigned int plaintext_pad_len;
3418         unsigned int plaintext_len;
3419         uint8_t buffer[10000];
3420         const uint8_t *ciphertext;
3421
3422         struct rte_cryptodev_info dev_info;
3423
3424         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3425         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
3426                 printf("Device doesn't support scatter-gather. "
3427                                 "Test Skipped.\n");
3428                 return 0;
3429         }
3430
3431         /* Create SNOW 3G session */
3432         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3433                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3434                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3435                                         tdata->key.data, tdata->key.len);
3436         if (retval < 0)
3437                 return retval;
3438
3439         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3440         /* Append data which is padded to a multiple of */
3441         /* the algorithms block size */
3442         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3443
3444         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3445                         plaintext_pad_len, 10, 0);
3446         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3447                         plaintext_pad_len, 3, 0);
3448
3449         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3450                         "Failed to allocate input buffer in mempool");
3451         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3452                         "Failed to allocate output buffer in mempool");
3453
3454         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3455
3456         /* Create SNOW 3G operation */
3457         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3458                                         tdata->iv.len,
3459                                         tdata->validCipherLenInBits.len,
3460                                         tdata->validCipherOffsetLenInBits.len,
3461                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3462         if (retval < 0)
3463                 return retval;
3464
3465         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3466                                                 ut_params->op);
3467         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3468
3469         ut_params->obuf = ut_params->op->sym->m_dst;
3470         if (ut_params->obuf)
3471                 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
3472                                 plaintext_len, buffer);
3473         else
3474                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
3475                                 plaintext_len, buffer);
3476
3477         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3478
3479         /* Validate obuf */
3480         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3481                 ciphertext,
3482                 tdata->ciphertext.data,
3483                 tdata->validDataLenInBits.len,
3484                 "SNOW 3G Ciphertext data not as expected");
3485
3486         return 0;
3487 }
3488
3489 /* Shift right a buffer by "offset" bits, "offset" < 8 */
3490 static void
3491 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
3492 {
3493         uint8_t curr_byte, prev_byte;
3494         uint32_t length_in_bytes = ceil_byte_length(length + offset);
3495         uint8_t lower_byte_mask = (1 << offset) - 1;
3496         unsigned i;
3497
3498         prev_byte = buffer[0];
3499         buffer[0] >>= offset;
3500
3501         for (i = 1; i < length_in_bytes; i++) {
3502                 curr_byte = buffer[i];
3503                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
3504                                 (curr_byte >> offset);
3505                 prev_byte = curr_byte;
3506         }
3507 }
3508
3509 static int
3510 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
3511 {
3512         struct crypto_testsuite_params *ts_params = &testsuite_params;
3513         struct crypto_unittest_params *ut_params = &unittest_params;
3514         uint8_t *plaintext, *ciphertext;
3515         int retval;
3516         uint32_t plaintext_len;
3517         uint32_t plaintext_pad_len;
3518         uint8_t extra_offset = 4;
3519         uint8_t *expected_ciphertext_shifted;
3520
3521         /* Create SNOW 3G session */
3522         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3523                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3524                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3525                                         tdata->key.data, tdata->key.len);
3526         if (retval < 0)
3527                 return retval;
3528
3529         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3530         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3531
3532         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3533                         "Failed to allocate input buffer in mempool");
3534         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3535                         "Failed to allocate output buffer in mempool");
3536
3537         /* Clear mbuf payload */
3538         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3539                rte_pktmbuf_tailroom(ut_params->ibuf));
3540
3541         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
3542         /*
3543          * Append data which is padded to a
3544          * multiple of the algorithms block size
3545          */
3546         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3547
3548         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
3549                                                 plaintext_pad_len);
3550
3551         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3552
3553         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
3554         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
3555
3556 #ifdef RTE_APP_TEST_DEBUG
3557         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3558 #endif
3559         /* Create SNOW 3G operation */
3560         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3561                                         tdata->iv.len,
3562                                         tdata->validCipherLenInBits.len,
3563                                         tdata->validCipherOffsetLenInBits.len +
3564                                         extra_offset,
3565                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3566         if (retval < 0)
3567                 return retval;
3568
3569         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3570                                                 ut_params->op);
3571         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3572
3573         ut_params->obuf = ut_params->op->sym->m_dst;
3574         if (ut_params->obuf)
3575                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3576                                 + tdata->iv.len;
3577         else
3578                 ciphertext = plaintext;
3579
3580 #ifdef RTE_APP_TEST_DEBUG
3581         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3582 #endif
3583
3584         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
3585
3586         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
3587                         "failed to reserve memory for ciphertext shifted\n");
3588
3589         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
3590                         ceil_byte_length(tdata->ciphertext.len));
3591         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
3592                         extra_offset);
3593         /* Validate obuf */
3594         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
3595                 ciphertext,
3596                 expected_ciphertext_shifted,
3597                 tdata->validDataLenInBits.len,
3598                 extra_offset,
3599                 "SNOW 3G Ciphertext data not as expected");
3600         return 0;
3601 }
3602
3603 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
3604 {
3605         struct crypto_testsuite_params *ts_params = &testsuite_params;
3606         struct crypto_unittest_params *ut_params = &unittest_params;
3607
3608         int retval;
3609
3610         uint8_t *plaintext, *ciphertext;
3611         unsigned ciphertext_pad_len;
3612         unsigned ciphertext_len;
3613
3614         /* Create SNOW 3G session */
3615         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3616                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3617                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3618                                         tdata->key.data, tdata->key.len);
3619         if (retval < 0)
3620                 return retval;
3621
3622         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3623
3624         /* Clear mbuf payload */
3625         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3626                rte_pktmbuf_tailroom(ut_params->ibuf));
3627
3628         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3629         /* Append data which is padded to a multiple of */
3630         /* the algorithms block size */
3631         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3632         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3633                                 ciphertext_pad_len);
3634         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3635
3636         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3637
3638         /* Create SNOW 3G operation */
3639         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3640                                         tdata->validCipherLenInBits.len,
3641                                         tdata->validCipherOffsetLenInBits.len,
3642                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3643         if (retval < 0)
3644                 return retval;
3645
3646         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3647                                                 ut_params->op);
3648         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3649         ut_params->obuf = ut_params->op->sym->m_dst;
3650         if (ut_params->obuf)
3651                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3652                                 + tdata->iv.len;
3653         else
3654                 plaintext = ciphertext;
3655
3656         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3657
3658         /* Validate obuf */
3659         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3660                                 tdata->plaintext.data,
3661                                 tdata->validDataLenInBits.len,
3662                                 "SNOW 3G Plaintext data not as expected");
3663         return 0;
3664 }
3665
3666 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
3667 {
3668         struct crypto_testsuite_params *ts_params = &testsuite_params;
3669         struct crypto_unittest_params *ut_params = &unittest_params;
3670
3671         int retval;
3672
3673         uint8_t *plaintext, *ciphertext;
3674         unsigned ciphertext_pad_len;
3675         unsigned ciphertext_len;
3676
3677         /* Create SNOW 3G session */
3678         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3679                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3680                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3681                                         tdata->key.data, tdata->key.len);
3682         if (retval < 0)
3683                 return retval;
3684
3685         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3686         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3687
3688         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3689                         "Failed to allocate input buffer");
3690         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3691                         "Failed to allocate output buffer");
3692
3693         /* Clear mbuf payload */
3694         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3695                rte_pktmbuf_tailroom(ut_params->ibuf));
3696
3697         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
3698                        rte_pktmbuf_tailroom(ut_params->obuf));
3699
3700         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3701         /* Append data which is padded to a multiple of */
3702         /* the algorithms block size */
3703         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3704         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3705                                 ciphertext_pad_len);
3706         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3707         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3708
3709         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3710
3711         /* Create SNOW 3G operation */
3712         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3713                                         tdata->iv.len,
3714                                         tdata->validCipherLenInBits.len,
3715                                         tdata->validCipherOffsetLenInBits.len,
3716                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3717         if (retval < 0)
3718                 return retval;
3719
3720         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3721                                                 ut_params->op);
3722         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3723         ut_params->obuf = ut_params->op->sym->m_dst;
3724         if (ut_params->obuf)
3725                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3726                                 + tdata->iv.len;
3727         else
3728                 plaintext = ciphertext;
3729
3730         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3731
3732         /* Validate obuf */
3733         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3734                                 tdata->plaintext.data,
3735                                 tdata->validDataLenInBits.len,
3736                                 "SNOW 3G Plaintext data not as expected");
3737         return 0;
3738 }
3739
3740 static int
3741 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
3742 {
3743         struct crypto_testsuite_params *ts_params = &testsuite_params;
3744         struct crypto_unittest_params *ut_params = &unittest_params;
3745
3746         int retval;
3747
3748         uint8_t *plaintext, *ciphertext;
3749         unsigned int plaintext_pad_len;
3750         unsigned int plaintext_len;
3751
3752         struct rte_cryptodev_sym_capability_idx cap_idx;
3753
3754         /* Check if device supports ZUC EEA3 */
3755         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3756         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
3757
3758         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3759                         &cap_idx) == NULL)
3760                 return -ENOTSUP;
3761
3762         /* Check if device supports ZUC EIA3 */
3763         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3764         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
3765
3766         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3767                         &cap_idx) == NULL)
3768                 return -ENOTSUP;
3769
3770         /* Create ZUC session */
3771         retval = create_zuc_cipher_auth_encrypt_generate_session(
3772                         ts_params->valid_devs[0],
3773                         tdata);
3774         if (retval < 0)
3775                 return retval;
3776         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3777
3778         /* clear mbuf payload */
3779         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3780                         rte_pktmbuf_tailroom(ut_params->ibuf));
3781
3782         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3783         /* Append data which is padded to a multiple of */
3784         /* the algorithms block size */
3785         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3786         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3787                                 plaintext_pad_len);
3788         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3789
3790         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3791
3792         /* Create ZUC operation */
3793         retval = create_zuc_cipher_hash_generate_operation(tdata);
3794         if (retval < 0)
3795                 return retval;
3796
3797         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3798                         ut_params->op);
3799         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3800         ut_params->obuf = ut_params->op->sym->m_src;
3801         if (ut_params->obuf)
3802                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3803                                 + tdata->iv.len + tdata->aad.len;
3804         else
3805                 ciphertext = plaintext;
3806
3807         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3808         /* Validate obuf */
3809         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3810                         ciphertext,
3811                         tdata->ciphertext.data,
3812                         tdata->validDataLenInBits.len,
3813                         "ZUC Ciphertext data not as expected");
3814
3815         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3816             + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3817
3818         /* Validate obuf */
3819         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3820                         ut_params->digest,
3821                         tdata->digest.data,
3822                         4,
3823                         "ZUC Generated auth tag not as expected");
3824         return 0;
3825 }
3826
3827 static int
3828 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
3829 {
3830         struct crypto_testsuite_params *ts_params = &testsuite_params;
3831         struct crypto_unittest_params *ut_params = &unittest_params;
3832
3833         int retval;
3834
3835         uint8_t *plaintext, *ciphertext;
3836         unsigned plaintext_pad_len;
3837         unsigned plaintext_len;
3838
3839         /* Create SNOW 3G session */
3840         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
3841                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3842                         RTE_CRYPTO_AUTH_OP_GENERATE,
3843                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3844                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3845                         tdata->key.data, tdata->key.len,
3846                         tdata->aad.len, tdata->digest.len);
3847         if (retval < 0)
3848                 return retval;
3849         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3850
3851         /* clear mbuf payload */
3852         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3853                         rte_pktmbuf_tailroom(ut_params->ibuf));
3854
3855         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3856         /* Append data which is padded to a multiple of */
3857         /* the algorithms block size */
3858         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3859         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3860                                 plaintext_pad_len);
3861         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3862
3863         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3864
3865         /* Create SNOW 3G operation */
3866         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3867                         tdata->digest.len, tdata->aad.data,
3868                         tdata->aad.len, /*tdata->plaintext.len,*/
3869                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3870                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3871                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3872                         tdata->iv.data, tdata->iv.len,
3873                         tdata->validCipherLenInBits.len,
3874                         tdata->validCipherOffsetLenInBits.len,
3875                         tdata->validAuthLenInBits.len,
3876                         tdata->validAuthOffsetLenInBits.len
3877                         );
3878         if (retval < 0)
3879                 return retval;
3880
3881         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3882                         ut_params->op);
3883         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3884         ut_params->obuf = ut_params->op->sym->m_src;
3885         if (ut_params->obuf)
3886                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3887                                 + tdata->iv.len + tdata->aad.len;
3888         else
3889                 ciphertext = plaintext;
3890
3891         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3892         /* Validate obuf */
3893         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3894                         ciphertext,
3895                         tdata->ciphertext.data,
3896                         tdata->validDataLenInBits.len,
3897                         "SNOW 3G Ciphertext data not as expected");
3898
3899         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3900             + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3901
3902         /* Validate obuf */
3903         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3904                         ut_params->digest,
3905                         tdata->digest.data,
3906                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3907                         "SNOW 3G Generated auth tag not as expected");
3908         return 0;
3909 }
3910 static int
3911 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
3912 {
3913         struct crypto_testsuite_params *ts_params = &testsuite_params;
3914         struct crypto_unittest_params *ut_params = &unittest_params;
3915
3916         int retval;
3917
3918         uint8_t *plaintext, *ciphertext;
3919         unsigned plaintext_pad_len;
3920         unsigned plaintext_len;
3921
3922         /* Create SNOW 3G session */
3923         retval = create_wireless_algo_auth_cipher_session(ts_params->valid_devs[0],
3924                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3925                         RTE_CRYPTO_AUTH_OP_GENERATE,
3926                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3927                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3928                         tdata->key.data, tdata->key.len,
3929                         tdata->aad.len, tdata->digest.len);
3930         if (retval < 0)
3931                 return retval;
3932
3933         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3934
3935         /* clear mbuf payload */
3936         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3937                         rte_pktmbuf_tailroom(ut_params->ibuf));
3938
3939         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3940         /* Append data which is padded to a multiple of */
3941         /* the algorithms block size */
3942         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3943         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3944                                 plaintext_pad_len);
3945         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3946
3947         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3948
3949         /* Create SNOW 3G operation */
3950         retval = create_wireless_algo_auth_cipher_operation(
3951                 tdata->digest.len,
3952                 tdata->iv.data, tdata->iv.len,
3953                 tdata->aad.data, tdata->aad.len,
3954                 plaintext_pad_len,
3955                 tdata->validCipherLenInBits.len,
3956                 tdata->validCipherOffsetLenInBits.len,
3957                 tdata->validAuthLenInBits.len,
3958                 tdata->validAuthOffsetLenInBits.len,
3959                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3960                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
3961         );
3962
3963         if (retval < 0)
3964                 return retval;
3965
3966         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3967                         ut_params->op);
3968         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3969         ut_params->obuf = ut_params->op->sym->m_src;
3970         if (ut_params->obuf)
3971                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3972                                 + tdata->aad.len + tdata->iv.len;
3973         else
3974                 ciphertext = plaintext;
3975
3976         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3977                         + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3978         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3979
3980         /* Validate obuf */
3981         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3982                 ciphertext,
3983                 tdata->ciphertext.data,
3984                 tdata->validDataLenInBits.len,
3985                 "SNOW 3G Ciphertext data not as expected");
3986
3987         /* Validate obuf */
3988         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3989                 ut_params->digest,
3990                 tdata->digest.data,
3991                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3992                 "SNOW 3G Generated auth tag not as expected");
3993         return 0;
3994 }
3995
3996 static int
3997 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
3998 {
3999         struct crypto_testsuite_params *ts_params = &testsuite_params;
4000         struct crypto_unittest_params *ut_params = &unittest_params;
4001
4002         int retval;
4003
4004         uint8_t *plaintext, *ciphertext;
4005         unsigned plaintext_pad_len;
4006         unsigned plaintext_len;
4007
4008         /* Create KASUMI session */
4009         retval = create_wireless_algo_auth_cipher_session(
4010                         ts_params->valid_devs[0],
4011                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4012                         RTE_CRYPTO_AUTH_OP_GENERATE,
4013                         RTE_CRYPTO_AUTH_KASUMI_F9,
4014                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4015                         tdata->key.data, tdata->key.len,
4016                         tdata->aad.len, tdata->digest.len);
4017         if (retval < 0)
4018                 return retval;
4019         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4020
4021         /* clear mbuf payload */
4022         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4023                         rte_pktmbuf_tailroom(ut_params->ibuf));
4024
4025         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4026         /* Append data which is padded to a multiple of */
4027         /* the algorithms block size */
4028         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4029         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4030                                 plaintext_pad_len);
4031         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4032
4033         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
4034
4035         /* Create KASUMI operation */
4036         retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len,
4037                                 tdata->iv.data, tdata->iv.len,
4038                                 tdata->aad.data, tdata->aad.len,
4039                                 plaintext_pad_len,
4040                                 tdata->validCipherLenInBits.len,
4041                                 tdata->validCipherOffsetLenInBits.len,
4042                                 tdata->validAuthLenInBits.len,
4043                                 tdata->validAuthOffsetLenInBits.len,
4044                                 RTE_CRYPTO_AUTH_KASUMI_F9,
4045                                 RTE_CRYPTO_CIPHER_KASUMI_F8
4046                                 );
4047
4048         if (retval < 0)
4049                 return retval;
4050
4051         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4052                         ut_params->op);
4053         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4054         ut_params->obuf = ut_params->op->sym->m_src;
4055         if (ut_params->obuf)
4056                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4057                                 + tdata->iv.len + tdata->aad.len;
4058         else
4059                 ciphertext = plaintext;
4060
4061         /* Validate obuf */
4062         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4063                         ciphertext,
4064                         tdata->ciphertext.data,
4065                         tdata->validCipherLenInBits.len,
4066                         "KASUMI Ciphertext data not as expected");
4067         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4068             + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
4069
4070         /* Validate obuf */
4071         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4072                         ut_params->digest,
4073                         tdata->digest.data,
4074                         DIGEST_BYTE_LENGTH_KASUMI_F9,
4075                         "KASUMI Generated auth tag not as expected");
4076         return 0;
4077 }
4078
4079 static int
4080 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
4081 {
4082         struct crypto_testsuite_params *ts_params = &testsuite_params;
4083         struct crypto_unittest_params *ut_params = &unittest_params;
4084
4085         int retval;
4086
4087         uint8_t *plaintext, *ciphertext;
4088         unsigned plaintext_pad_len;
4089         unsigned plaintext_len;
4090
4091         /* Create KASUMI session */
4092         retval = create_wireless_algo_cipher_auth_session(
4093                         ts_params->valid_devs[0],
4094                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4095                         RTE_CRYPTO_AUTH_OP_GENERATE,
4096                         RTE_CRYPTO_AUTH_KASUMI_F9,
4097                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4098                         tdata->key.data, tdata->key.len,
4099                         tdata->aad.len, tdata->digest.len);
4100         if (retval < 0)
4101                 return retval;
4102
4103         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4104
4105         /* clear mbuf payload */
4106         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4107                         rte_pktmbuf_tailroom(ut_params->ibuf));
4108
4109         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4110         /* Append data which is padded to a multiple of */
4111         /* the algorithms block size */
4112         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4113         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4114                                 plaintext_pad_len);
4115         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4116
4117         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
4118
4119         /* Create KASUMI operation */
4120         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4121                                 tdata->digest.len, tdata->aad.data,
4122                                 tdata->aad.len,
4123                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4124                                 RTE_CRYPTO_AUTH_KASUMI_F9,
4125                                 RTE_CRYPTO_CIPHER_KASUMI_F8,
4126                                 tdata->iv.data, tdata->iv.len,
4127                                 tdata->validCipherLenInBits.len,
4128                                 tdata->validCipherOffsetLenInBits.len,
4129                                 tdata->validAuthLenInBits.len,
4130                                 tdata->validAuthOffsetLenInBits.len
4131                                 );
4132         if (retval < 0)
4133                 return retval;
4134
4135         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4136                         ut_params->op);
4137         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4138         ut_params->obuf = ut_params->op->sym->m_src;
4139         if (ut_params->obuf)
4140                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4141                                 + tdata->aad.len + tdata->iv.len;
4142         else
4143                 ciphertext = plaintext;
4144
4145         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4146                         + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
4147
4148         /* Validate obuf */
4149         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4150                 ciphertext,
4151                 tdata->ciphertext.data,
4152                 tdata->validCipherLenInBits.len,
4153                 "KASUMI Ciphertext data not as expected");
4154
4155         /* Validate obuf */
4156         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4157                 ut_params->digest,
4158                 tdata->digest.data,
4159                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4160                 "KASUMI Generated auth tag not as expected");
4161         return 0;
4162 }
4163
4164 static int
4165 test_zuc_encryption(const struct wireless_test_data *tdata)
4166 {
4167         struct crypto_testsuite_params *ts_params = &testsuite_params;
4168         struct crypto_unittest_params *ut_params = &unittest_params;
4169
4170         int retval;
4171         uint8_t *plaintext, *ciphertext;
4172         unsigned plaintext_pad_len;
4173         unsigned plaintext_len;
4174
4175         struct rte_cryptodev_sym_capability_idx cap_idx;
4176
4177         /* Check if device supports ZUC EEA3 */
4178         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4179         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4180
4181         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4182                         &cap_idx) == NULL)
4183                 return -ENOTSUP;
4184
4185         /* Create ZUC session */
4186         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4187                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4188                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
4189                                         tdata->key.data, tdata->key.len);
4190         if (retval < 0)
4191                 return retval;
4192
4193         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4194
4195         /* Clear mbuf payload */
4196         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4197                rte_pktmbuf_tailroom(ut_params->ibuf));
4198
4199         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4200         /* Append data which is padded to a multiple */
4201         /* of the algorithms block size */
4202         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4203         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4204                                 plaintext_pad_len);
4205         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4206
4207         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
4208
4209         /* Create ZUC operation */
4210         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
4211                                         tdata->plaintext.len,
4212                                         tdata->validCipherOffsetLenInBits.len,
4213                                         RTE_CRYPTO_CIPHER_ZUC_EEA3);
4214         if (retval < 0)
4215                 return retval;
4216
4217         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4218                                                 ut_params->op);
4219         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4220
4221         ut_params->obuf = ut_params->op->sym->m_dst;
4222         if (ut_params->obuf)
4223                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4224                                 + tdata->iv.len;
4225         else
4226                 ciphertext = plaintext;
4227
4228         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
4229
4230         /* Validate obuf */
4231         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4232                 ciphertext,
4233                 tdata->ciphertext.data,
4234                 tdata->validCipherLenInBits.len,
4235                 "ZUC Ciphertext data not as expected");
4236         return 0;
4237 }
4238
4239 static int
4240 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
4241 {
4242         struct crypto_testsuite_params *ts_params = &testsuite_params;
4243         struct crypto_unittest_params *ut_params = &unittest_params;
4244
4245         int retval;
4246
4247         unsigned int plaintext_pad_len;
4248         unsigned int plaintext_len;
4249         const uint8_t *ciphertext;
4250         uint8_t ciphertext_buffer[2048];
4251         struct rte_cryptodev_info dev_info;
4252
4253         struct rte_cryptodev_sym_capability_idx cap_idx;
4254
4255         /* Check if device supports ZUC EEA3 */
4256         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4257         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4258
4259         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4260                         &cap_idx) == NULL)
4261                 return -ENOTSUP;
4262
4263         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4264         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
4265                 printf("Device doesn't support scatter-gather. "
4266                                 "Test Skipped.\n");
4267                 return -ENOTSUP;
4268         }
4269
4270         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4271
4272         /* Append data which is padded to a multiple */
4273         /* of the algorithms block size */
4274         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4275
4276         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4277                         plaintext_pad_len, 10, 0);
4278
4279         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4280                         tdata->plaintext.data);
4281
4282         /* Create ZUC session */
4283         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4284                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4285                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
4286                         tdata->key.data, tdata->key.len);
4287         if (retval < 0)
4288                 return retval;
4289
4290         /* Clear mbuf payload */
4291
4292         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4293
4294         /* Create ZUC operation */
4295         retval = create_wireless_algo_cipher_operation(tdata->iv.data,
4296                         tdata->iv.len, tdata->plaintext.len,
4297                         tdata->validCipherOffsetLenInBits.len,
4298                         RTE_CRYPTO_CIPHER_ZUC_EEA3);
4299         if (retval < 0)
4300                 return retval;
4301
4302         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4303                                                 ut_params->op);
4304         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4305
4306         ut_params->obuf = ut_params->op->sym->m_dst;
4307         if (ut_params->obuf)
4308                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
4309                         tdata->iv.len, plaintext_len, ciphertext_buffer);
4310         else
4311                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
4312                         tdata->iv.len, plaintext_len, ciphertext_buffer);
4313
4314         /* Validate obuf */
4315         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
4316
4317         /* Validate obuf */
4318         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4319                 ciphertext,
4320                 tdata->ciphertext.data,
4321                 tdata->validCipherLenInBits.len,
4322                 "ZUC Ciphertext data not as expected");
4323
4324         return 0;
4325 }
4326
4327 static int
4328 test_zuc_authentication(const struct wireless_test_data *tdata)
4329 {
4330         struct crypto_testsuite_params *ts_params = &testsuite_params;
4331         struct crypto_unittest_params *ut_params = &unittest_params;
4332
4333         int retval;
4334         unsigned plaintext_pad_len;
4335         unsigned plaintext_len;
4336         uint8_t *plaintext;
4337
4338         struct rte_cryptodev_sym_capability_idx cap_idx;
4339
4340         /* Check if device supports ZUC EIA3 */
4341         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4342         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4343
4344         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4345                         &cap_idx) == NULL)
4346                 return -ENOTSUP;
4347
4348         /* Create ZUC session */
4349         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
4350                         tdata->key.data, tdata->key.len,
4351                         tdata->aad.len, tdata->digest.len,
4352                         RTE_CRYPTO_AUTH_OP_GENERATE,
4353                         RTE_CRYPTO_AUTH_ZUC_EIA3);
4354         if (retval < 0)
4355                 return retval;
4356
4357         /* alloc mbuf and set payload */
4358         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4359
4360         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4361         rte_pktmbuf_tailroom(ut_params->ibuf));
4362
4363         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4364         /* Append data which is padded to a multiple of */
4365         /* the algorithms block size */
4366         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4367         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4368                                 plaintext_pad_len);
4369         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4370
4371         /* Create ZUC operation */
4372         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
4373                         tdata->aad.data, tdata->aad.len,
4374                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4375                         RTE_CRYPTO_AUTH_ZUC_EIA3,
4376                         tdata->validAuthLenInBits.len,
4377                         tdata->validAuthOffsetLenInBits.len);
4378         if (retval < 0)
4379                 return retval;
4380
4381         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4382                                 ut_params->op);
4383         ut_params->obuf = ut_params->op->sym->m_src;
4384         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4385         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4386                         + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
4387
4388         /* Validate obuf */
4389         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4390         ut_params->digest,
4391         tdata->digest.data,
4392         DIGEST_BYTE_LENGTH_KASUMI_F9,
4393         "ZUC Generated auth tag not as expected");
4394
4395         return 0;
4396 }
4397
4398 static int
4399 test_kasumi_encryption_test_case_1(void)
4400 {
4401         return test_kasumi_encryption(&kasumi_test_case_1);
4402 }
4403
4404 static int
4405 test_kasumi_encryption_test_case_1_sgl(void)
4406 {
4407         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
4408 }
4409
4410 static int
4411 test_kasumi_encryption_test_case_1_oop(void)
4412 {
4413         return test_kasumi_encryption_oop(&kasumi_test_case_1);
4414 }
4415
4416 static int
4417 test_kasumi_encryption_test_case_1_oop_sgl(void)
4418 {
4419         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
4420 }
4421
4422 static int
4423 test_kasumi_encryption_test_case_2(void)
4424 {
4425         return test_kasumi_encryption(&kasumi_test_case_2);
4426 }
4427
4428 static int
4429 test_kasumi_encryption_test_case_3(void)
4430 {
4431         return test_kasumi_encryption(&kasumi_test_case_3);
4432 }
4433
4434 static int
4435 test_kasumi_encryption_test_case_4(void)
4436 {
4437         return test_kasumi_encryption(&kasumi_test_case_4);
4438 }
4439
4440 static int
4441 test_kasumi_encryption_test_case_5(void)
4442 {
4443         return test_kasumi_encryption(&kasumi_test_case_5);
4444 }
4445
4446 static int
4447 test_kasumi_decryption_test_case_1(void)
4448 {
4449         return test_kasumi_decryption(&kasumi_test_case_1);
4450 }
4451
4452 static int
4453 test_kasumi_decryption_test_case_1_oop(void)
4454 {
4455         return test_kasumi_decryption_oop(&kasumi_test_case_1);
4456 }
4457
4458 static int
4459 test_kasumi_decryption_test_case_2(void)
4460 {
4461         return test_kasumi_decryption(&kasumi_test_case_2);
4462 }
4463
4464 static int
4465 test_kasumi_decryption_test_case_3(void)
4466 {
4467         return test_kasumi_decryption(&kasumi_test_case_3);
4468 }
4469
4470 static int
4471 test_kasumi_decryption_test_case_4(void)
4472 {
4473         return test_kasumi_decryption(&kasumi_test_case_4);
4474 }
4475
4476 static int
4477 test_kasumi_decryption_test_case_5(void)
4478 {
4479         return test_kasumi_decryption(&kasumi_test_case_5);
4480 }
4481 static int
4482 test_snow3g_encryption_test_case_1(void)
4483 {
4484         return test_snow3g_encryption(&snow3g_test_case_1);
4485 }
4486
4487 static int
4488 test_snow3g_encryption_test_case_1_oop(void)
4489 {
4490         return test_snow3g_encryption_oop(&snow3g_test_case_1);
4491 }
4492
4493 static int
4494 test_snow3g_encryption_test_case_1_oop_sgl(void)
4495 {
4496         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
4497 }
4498
4499
4500 static int
4501 test_snow3g_encryption_test_case_1_offset_oop(void)
4502 {
4503         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
4504 }
4505
4506 static int
4507 test_snow3g_encryption_test_case_2(void)
4508 {
4509         return test_snow3g_encryption(&snow3g_test_case_2);
4510 }
4511
4512 static int
4513 test_snow3g_encryption_test_case_3(void)
4514 {
4515         return test_snow3g_encryption(&snow3g_test_case_3);
4516 }
4517
4518 static int
4519 test_snow3g_encryption_test_case_4(void)
4520 {
4521         return test_snow3g_encryption(&snow3g_test_case_4);
4522 }
4523
4524 static int
4525 test_snow3g_encryption_test_case_5(void)
4526 {
4527         return test_snow3g_encryption(&snow3g_test_case_5);
4528 }
4529
4530 static int
4531 test_snow3g_decryption_test_case_1(void)
4532 {
4533         return test_snow3g_decryption(&snow3g_test_case_1);
4534 }
4535
4536 static int
4537 test_snow3g_decryption_test_case_1_oop(void)
4538 {
4539         return test_snow3g_decryption_oop(&snow3g_test_case_1);
4540 }
4541
4542 static int
4543 test_snow3g_decryption_test_case_2(void)
4544 {
4545         return test_snow3g_decryption(&snow3g_test_case_2);
4546 }
4547
4548 static int
4549 test_snow3g_decryption_test_case_3(void)
4550 {
4551         return test_snow3g_decryption(&snow3g_test_case_3);
4552 }
4553
4554 static int
4555 test_snow3g_decryption_test_case_4(void)
4556 {
4557         return test_snow3g_decryption(&snow3g_test_case_4);
4558 }
4559
4560 static int
4561 test_snow3g_decryption_test_case_5(void)
4562 {
4563         return test_snow3g_decryption(&snow3g_test_case_5);
4564 }
4565 static int
4566 test_snow3g_cipher_auth_test_case_1(void)
4567 {
4568         return test_snow3g_cipher_auth(&snow3g_test_case_3);
4569 }
4570
4571 static int
4572 test_snow3g_auth_cipher_test_case_1(void)
4573 {
4574         return test_snow3g_auth_cipher(&snow3g_test_case_6);
4575 }
4576
4577 static int
4578 test_kasumi_auth_cipher_test_case_1(void)
4579 {
4580         return test_kasumi_auth_cipher(&kasumi_test_case_3);
4581 }
4582
4583 static int
4584 test_kasumi_cipher_auth_test_case_1(void)
4585 {
4586         return test_kasumi_cipher_auth(&kasumi_test_case_6);
4587 }
4588
4589 static int
4590 test_zuc_encryption_test_case_1(void)
4591 {
4592         return test_zuc_encryption(&zuc_test_case_cipher_193b);
4593 }
4594
4595 static int
4596 test_zuc_encryption_test_case_2(void)
4597 {
4598         return test_zuc_encryption(&zuc_test_case_cipher_800b);
4599 }
4600
4601 static int
4602 test_zuc_encryption_test_case_3(void)
4603 {
4604         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
4605 }
4606
4607 static int
4608 test_zuc_encryption_test_case_4(void)
4609 {
4610         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
4611 }
4612
4613 static int
4614 test_zuc_encryption_test_case_5(void)
4615 {
4616         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
4617 }
4618
4619 static int
4620 test_zuc_encryption_test_case_6_sgl(void)
4621 {
4622         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
4623 }
4624
4625 static int
4626 test_zuc_hash_generate_test_case_1(void)
4627 {
4628         return test_zuc_authentication(&zuc_test_case_auth_1b);
4629 }
4630
4631 static int
4632 test_zuc_hash_generate_test_case_2(void)
4633 {
4634         return test_zuc_authentication(&zuc_test_case_auth_90b);
4635 }
4636
4637 static int
4638 test_zuc_hash_generate_test_case_3(void)
4639 {
4640         return test_zuc_authentication(&zuc_test_case_auth_577b);
4641 }
4642
4643 static int
4644 test_zuc_hash_generate_test_case_4(void)
4645 {
4646         return test_zuc_authentication(&zuc_test_case_auth_2079b);
4647 }
4648
4649 static int
4650 test_zuc_hash_generate_test_case_5(void)
4651 {
4652         return test_zuc_authentication(&zuc_test_auth_5670b);
4653 }
4654
4655 static int
4656 test_zuc_hash_generate_test_case_6(void)
4657 {
4658         return test_zuc_authentication(&zuc_test_case_auth_128b);
4659 }
4660
4661 static int
4662 test_zuc_hash_generate_test_case_7(void)
4663 {
4664         return test_zuc_authentication(&zuc_test_case_auth_2080b);
4665 }
4666
4667 static int
4668 test_zuc_hash_generate_test_case_8(void)
4669 {
4670         return test_zuc_authentication(&zuc_test_case_auth_584b);
4671 }
4672
4673 static int
4674 test_zuc_cipher_auth_test_case_1(void)
4675 {
4676         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
4677 }
4678
4679 static int
4680 test_zuc_cipher_auth_test_case_2(void)
4681 {
4682         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
4683 }
4684
4685 static int
4686 test_3DES_chain_qat_all(void)
4687 {
4688         struct crypto_testsuite_params *ts_params = &testsuite_params;
4689         int status;
4690
4691         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4692                 ts_params->op_mpool, ts_params->valid_devs[0],
4693                 RTE_CRYPTODEV_QAT_SYM_PMD,
4694                 BLKCIPHER_3DES_CHAIN_TYPE);
4695
4696         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4697
4698         return TEST_SUCCESS;
4699 }
4700
4701 static int
4702 test_DES_cipheronly_qat_all(void)
4703 {
4704         struct crypto_testsuite_params *ts_params = &testsuite_params;
4705         int status;
4706
4707         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4708                 ts_params->op_mpool, ts_params->valid_devs[0],
4709                 RTE_CRYPTODEV_QAT_SYM_PMD,
4710                 BLKCIPHER_DES_CIPHERONLY_TYPE);
4711
4712         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4713
4714         return TEST_SUCCESS;
4715 }
4716
4717 static int
4718 test_DES_docsis_openssl_all(void)
4719 {
4720         struct crypto_testsuite_params *ts_params = &testsuite_params;
4721         int status;
4722
4723         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4724                 ts_params->op_mpool, ts_params->valid_devs[0],
4725                 RTE_CRYPTODEV_OPENSSL_PMD,
4726                 BLKCIPHER_DES_DOCSIS_TYPE);
4727
4728         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4729
4730         return TEST_SUCCESS;
4731 }
4732
4733 static int
4734 test_3DES_chain_dpaa2_sec_all(void)
4735 {
4736         struct crypto_testsuite_params *ts_params = &testsuite_params;
4737         int status;
4738
4739         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4740                 ts_params->op_mpool, ts_params->valid_devs[0],
4741                 RTE_CRYPTODEV_DPAA2_SEC_PMD,
4742                 BLKCIPHER_3DES_CHAIN_TYPE);
4743
4744         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4745
4746         return TEST_SUCCESS;
4747 }
4748
4749 static int
4750 test_3DES_cipheronly_dpaa2_sec_all(void)
4751 {
4752         struct crypto_testsuite_params *ts_params = &testsuite_params;
4753         int status;
4754
4755         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4756                 ts_params->op_mpool, ts_params->valid_devs[0],
4757                 RTE_CRYPTODEV_DPAA2_SEC_PMD,
4758                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4759
4760         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4761
4762         return TEST_SUCCESS;
4763 }
4764
4765 static int
4766 test_3DES_cipheronly_qat_all(void)
4767 {
4768         struct crypto_testsuite_params *ts_params = &testsuite_params;
4769         int status;
4770
4771         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4772                 ts_params->op_mpool, ts_params->valid_devs[0],
4773                 RTE_CRYPTODEV_QAT_SYM_PMD,
4774                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4775
4776         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4777
4778         return TEST_SUCCESS;
4779 }
4780
4781 static int
4782 test_3DES_chain_openssl_all(void)
4783 {
4784         struct crypto_testsuite_params *ts_params = &testsuite_params;
4785         int status;
4786
4787         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4788                 ts_params->op_mpool, ts_params->valid_devs[0],
4789                 RTE_CRYPTODEV_OPENSSL_PMD,
4790                 BLKCIPHER_3DES_CHAIN_TYPE);
4791
4792         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4793
4794         return TEST_SUCCESS;
4795 }
4796
4797 static int
4798 test_3DES_cipheronly_openssl_all(void)
4799 {
4800         struct crypto_testsuite_params *ts_params = &testsuite_params;
4801         int status;
4802
4803         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4804                 ts_params->op_mpool, ts_params->valid_devs[0],
4805                 RTE_CRYPTODEV_OPENSSL_PMD,
4806                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4807
4808         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4809
4810         return TEST_SUCCESS;
4811 }
4812
4813 /* ***** AES-GCM Tests ***** */
4814
4815 static int
4816 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
4817                 const uint8_t *key, const uint8_t key_len,
4818                 const uint8_t aad_len, const uint8_t auth_len,
4819                 enum rte_crypto_auth_operation auth_op)
4820 {
4821         uint8_t cipher_key[key_len];
4822
4823         struct crypto_unittest_params *ut_params = &unittest_params;
4824
4825         memcpy(cipher_key, key, key_len);
4826
4827         /* Setup Cipher Parameters */
4828         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4829         ut_params->cipher_xform.next = NULL;
4830
4831         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
4832         ut_params->auth_xform.auth.op = auth_op;
4833         ut_params->cipher_xform.cipher.op = op;
4834         ut_params->cipher_xform.cipher.key.data = cipher_key;
4835         ut_params->cipher_xform.cipher.key.length = key_len;
4836
4837         TEST_HEXDUMP(stdout, "key:", key, key_len);
4838
4839         /* Setup Authentication Parameters */
4840         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4841         ut_params->auth_xform.next = NULL;
4842
4843         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
4844
4845         ut_params->auth_xform.auth.digest_length = auth_len;
4846         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
4847         ut_params->auth_xform.auth.key.length = 0;
4848         ut_params->auth_xform.auth.key.data = NULL;
4849
4850         if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4851                 ut_params->cipher_xform.next = &ut_params->auth_xform;
4852
4853                 /* Create Crypto session*/
4854                 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
4855                                 &ut_params->cipher_xform);
4856         } else {/* Create Crypto session*/
4857                 ut_params->auth_xform.next = &ut_params->cipher_xform;
4858                 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
4859                                 &ut_params->auth_xform);
4860         }
4861
4862         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4863
4864         return 0;
4865 }
4866
4867 static int
4868 create_gcm_xforms(struct rte_crypto_op *op,
4869                 enum rte_crypto_cipher_operation cipher_op,
4870                 uint8_t *key, const uint8_t key_len,
4871                 const uint8_t aad_len, const uint8_t auth_len,
4872                 enum rte_crypto_auth_operation auth_op)
4873 {
4874         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 2),
4875                         "failed to allocate space for crypto transforms");
4876
4877         struct rte_crypto_sym_op *sym_op = op->sym;
4878
4879         /* Setup Cipher Parameters */
4880         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4881         sym_op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
4882         sym_op->xform->cipher.op = cipher_op;
4883         sym_op->xform->cipher.key.data = key;
4884         sym_op->xform->cipher.key.length = key_len;
4885
4886         TEST_HEXDUMP(stdout, "key:", key, key_len);
4887
4888         /* Setup Authentication Parameters */
4889         sym_op->xform->next->type = RTE_CRYPTO_SYM_XFORM_AUTH;
4890         sym_op->xform->next->auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
4891         sym_op->xform->next->auth.op = auth_op;
4892         sym_op->xform->next->auth.digest_length = auth_len;
4893         sym_op->xform->next->auth.add_auth_data_length = aad_len;
4894         sym_op->xform->next->auth.key.length = 0;
4895         sym_op->xform->next->auth.key.data = NULL;
4896         sym_op->xform->next->next = NULL;
4897
4898         return 0;
4899 }
4900
4901 static int
4902 create_gcm_operation(enum rte_crypto_cipher_operation op,
4903                 const struct gcm_test_data *tdata)
4904 {
4905         struct crypto_testsuite_params *ts_params = &testsuite_params;
4906         struct crypto_unittest_params *ut_params = &unittest_params;
4907
4908         uint8_t *plaintext, *ciphertext;
4909         unsigned int iv_pad_len, aad_pad_len, plaintext_pad_len;
4910
4911         /* Generate Crypto op data structure */
4912         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4913                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4914         TEST_ASSERT_NOT_NULL(ut_params->op,
4915                         "Failed to allocate symmetric crypto operation struct");
4916
4917         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4918
4919         /* Append aad data */
4920         aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
4921         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4922                         aad_pad_len);
4923         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
4924                         "no room to append aad");
4925
4926         sym_op->auth.aad.length = tdata->aad.len;
4927         sym_op->auth.aad.phys_addr =
4928                         rte_pktmbuf_mtophys(ut_params->ibuf);
4929         memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len);
4930         TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data,
4931                 sym_op->auth.aad.length);
4932
4933         /* Prepend iv */
4934         iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
4935         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
4936                         ut_params->ibuf, iv_pad_len);
4937         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
4938
4939         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
4940         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
4941         sym_op->cipher.iv.length = tdata->iv.len;
4942
4943         rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
4944         TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data,
4945                 sym_op->cipher.iv.length);
4946
4947         /* Append plaintext/ciphertext */
4948         if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4949                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
4950                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4951                                 plaintext_pad_len);
4952                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
4953
4954                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
4955                 TEST_HEXDUMP(stdout, "plaintext:", plaintext,
4956                                 tdata->plaintext.len);
4957
4958                 if (ut_params->obuf) {
4959                         ciphertext = (uint8_t *)rte_pktmbuf_append(
4960                                         ut_params->obuf,
4961                                         plaintext_pad_len + aad_pad_len +
4962                                         iv_pad_len);
4963                         TEST_ASSERT_NOT_NULL(ciphertext,
4964                                         "no room to append ciphertext");
4965
4966                         memset(ciphertext + aad_pad_len + iv_pad_len, 0,
4967                                         tdata->ciphertext.len);
4968                 }
4969         } else {
4970                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
4971                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4972                                 plaintext_pad_len);
4973                 TEST_ASSERT_NOT_NULL(ciphertext,
4974                                 "no room to append ciphertext");
4975
4976                 memcpy(ciphertext, tdata->ciphertext.data,
4977                                 tdata->ciphertext.len);
4978                 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext,
4979                                 tdata->ciphertext.len);
4980
4981                 if (ut_params->obuf) {
4982                         plaintext = (uint8_t *)rte_pktmbuf_append(
4983                                         ut_params->obuf,
4984                                         plaintext_pad_len + aad_pad_len +
4985                                         iv_pad_len);
4986                         TEST_ASSERT_NOT_NULL(plaintext,
4987                                         "no room to append plaintext");
4988
4989                         memset(plaintext + aad_pad_len + iv_pad_len, 0,
4990                                         tdata->plaintext.len);
4991                 }
4992         }
4993
4994         /* Append digest data */
4995         if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4996                 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
4997                                 ut_params->obuf ? ut_params->obuf :
4998                                                 ut_params->ibuf,
4999                                                 tdata->auth_tag.len);
5000                 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5001                                 "no room to append digest");
5002                 memset(sym_op->auth.digest.data, 0, tdata->auth_tag.len);
5003                 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5004                                 ut_params->obuf ? ut_params->obuf :
5005                                                 ut_params->ibuf,
5006                                                 plaintext_pad_len +
5007                                                 aad_pad_len + iv_pad_len);
5008                 sym_op->auth.digest.length = tdata->auth_tag.len;
5009         } else {
5010                 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5011                                 ut_params->ibuf, tdata->auth_tag.len);
5012                 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5013                                 "no room to append digest");
5014                 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5015                                 ut_params->ibuf,
5016                                 plaintext_pad_len + aad_pad_len + iv_pad_len);
5017                 sym_op->auth.digest.length = tdata->auth_tag.len;
5018
5019                 rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data,
5020                         tdata->auth_tag.len);
5021                 TEST_HEXDUMP(stdout, "digest:",
5022                         sym_op->auth.digest.data,
5023                         sym_op->auth.digest.length);
5024         }
5025
5026         sym_op->cipher.data.length = tdata->plaintext.len;
5027         sym_op->cipher.data.offset = aad_pad_len + iv_pad_len;
5028
5029         sym_op->auth.data.length = tdata->plaintext.len;
5030         sym_op->auth.data.offset = aad_pad_len + iv_pad_len;
5031
5032         return 0;
5033 }
5034
5035 static int
5036 test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
5037 {
5038         struct crypto_testsuite_params *ts_params = &testsuite_params;
5039         struct crypto_unittest_params *ut_params = &unittest_params;
5040
5041         int retval;
5042         uint8_t *ciphertext, *auth_tag;
5043         uint16_t plaintext_pad_len;
5044         uint32_t i;
5045
5046         /* Create GCM session */
5047         retval = create_gcm_session(ts_params->valid_devs[0],
5048                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5049                         tdata->key.data, tdata->key.len,
5050                         tdata->aad.len, tdata->auth_tag.len,
5051                         RTE_CRYPTO_AUTH_OP_GENERATE);
5052         if (retval < 0)
5053                 return retval;
5054
5055         if (tdata->aad.len > MBUF_SIZE) {
5056                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5057                 /* Populate full size of add data */
5058                 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
5059                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
5060         } else
5061                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5062
5063         /* clear mbuf payload */
5064         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5065                         rte_pktmbuf_tailroom(ut_params->ibuf));
5066
5067         /* Create GCM operation */
5068         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
5069         if (retval < 0)
5070                 return retval;
5071
5072         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5073
5074         ut_params->op->sym->m_src = ut_params->ibuf;
5075
5076         /* Process crypto operation */
5077         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5078                         ut_params->op), "failed to process sym crypto op");
5079
5080         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5081                         "crypto op processing failed");
5082
5083         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5084
5085         if (ut_params->op->sym->m_dst) {
5086                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
5087                                 uint8_t *);
5088                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5089                                 uint8_t *, plaintext_pad_len);
5090         } else {
5091                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
5092                                 uint8_t *,
5093                                 ut_params->op->sym->cipher.data.offset);
5094                 auth_tag = ciphertext + plaintext_pad_len;
5095         }
5096
5097         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5098         TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5099
5100         /* Validate obuf */
5101         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5102                         ciphertext,
5103                         tdata->ciphertext.data,
5104                         tdata->ciphertext.len,
5105                         "GCM Ciphertext data not as expected");
5106
5107         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5108                         auth_tag,
5109                         tdata->auth_tag.data,
5110                         tdata->auth_tag.len,
5111                         "GCM Generated auth tag not as expected");
5112
5113         return 0;
5114
5115 }
5116
5117 static int
5118 test_mb_AES_GCM_authenticated_encryption_test_case_1(void)
5119 {
5120         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1);
5121 }
5122
5123 static int
5124 test_mb_AES_GCM_authenticated_encryption_test_case_2(void)
5125 {
5126         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2);
5127 }
5128
5129 static int
5130 test_mb_AES_GCM_authenticated_encryption_test_case_3(void)
5131 {
5132         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3);
5133 }
5134
5135 static int
5136 test_mb_AES_GCM_authenticated_encryption_test_case_4(void)
5137 {
5138         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4);
5139 }
5140
5141 static int
5142 test_mb_AES_GCM_authenticated_encryption_test_case_5(void)
5143 {
5144         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5);
5145 }
5146
5147 static int
5148 test_mb_AES_GCM_authenticated_encryption_test_case_6(void)
5149 {
5150         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6);
5151 }
5152
5153 static int
5154 test_mb_AES_GCM_authenticated_encryption_test_case_7(void)
5155 {
5156         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7);
5157 }
5158
5159 static int
5160 test_mb_AES_GCM_auth_encryption_test_case_256_1(void)
5161 {
5162         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_1);
5163 }
5164
5165 static int
5166 test_mb_AES_GCM_auth_encryption_test_case_256_2(void)
5167 {
5168         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_2);
5169 }
5170
5171 static int
5172 test_mb_AES_GCM_auth_encryption_test_case_256_3(void)
5173 {
5174         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_3);
5175 }
5176
5177 static int
5178 test_mb_AES_GCM_auth_encryption_test_case_256_4(void)
5179 {
5180         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_4);
5181 }
5182
5183 static int
5184 test_mb_AES_GCM_auth_encryption_test_case_256_5(void)
5185 {
5186         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_5);
5187 }
5188
5189 static int
5190 test_mb_AES_GCM_auth_encryption_test_case_256_6(void)
5191 {
5192         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_6);
5193 }
5194
5195 static int
5196 test_mb_AES_GCM_auth_encryption_test_case_256_7(void)
5197 {
5198         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_7);
5199 }
5200
5201 static int
5202 test_mb_AES_GCM_auth_encryption_test_case_aad_1(void)
5203 {
5204         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_1);
5205 }
5206
5207 static int
5208 test_mb_AES_GCM_auth_encryption_test_case_aad_2(void)
5209 {
5210         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_2);
5211 }
5212
5213 static int
5214 test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
5215 {
5216         struct crypto_testsuite_params *ts_params = &testsuite_params;
5217         struct crypto_unittest_params *ut_params = &unittest_params;
5218
5219         int retval;
5220         uint8_t *plaintext;
5221         uint32_t i;
5222
5223         /* Create GCM session */
5224         retval = create_gcm_session(ts_params->valid_devs[0],
5225                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
5226                         tdata->key.data, tdata->key.len,
5227                         tdata->aad.len, tdata->auth_tag.len,
5228                         RTE_CRYPTO_AUTH_OP_VERIFY);
5229         if (retval < 0)
5230                 return retval;
5231
5232         /* alloc mbuf and set payload */
5233         if (tdata->aad.len > MBUF_SIZE) {
5234                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5235                 /* Populate full size of add data */
5236                 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
5237                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
5238         } else
5239                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5240
5241         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5242                         rte_pktmbuf_tailroom(ut_params->ibuf));
5243
5244         /* Create GCM operation */
5245         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
5246         if (retval < 0)
5247                 return retval;
5248
5249         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5250
5251         ut_params->op->sym->m_src = ut_params->ibuf;
5252
5253         /* Process crypto operation */
5254         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5255                         ut_params->op), "failed to process sym crypto op");
5256
5257         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5258                         "crypto op processing failed");
5259
5260         if (ut_params->op->sym->m_dst)
5261                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
5262                                 uint8_t *);
5263         else
5264                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
5265                                 uint8_t *,
5266                                 ut_params->op->sym->cipher.data.offset);
5267
5268         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5269
5270         /* Validate obuf */
5271         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5272                         plaintext,
5273                         tdata->plaintext.data,
5274                         tdata->plaintext.len,
5275                         "GCM plaintext data not as expected");
5276
5277         TEST_ASSERT_EQUAL(ut_params->op->status,
5278                         RTE_CRYPTO_OP_STATUS_SUCCESS,
5279                         "GCM authentication failed");
5280         return 0;
5281 }
5282
5283 static int
5284 test_mb_AES_GCM_authenticated_decryption_test_case_1(void)
5285 {
5286         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1);
5287 }
5288
5289 static int
5290 test_mb_AES_GCM_authenticated_decryption_test_case_2(void)
5291 {
5292         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2);
5293 }
5294
5295 static int
5296 test_mb_AES_GCM_authenticated_decryption_test_case_3(void)
5297 {
5298         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3);
5299 }
5300
5301 static int
5302 test_mb_AES_GCM_authenticated_decryption_test_case_4(void)
5303 {
5304         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4);
5305 }
5306
5307 static int
5308 test_mb_AES_GCM_authenticated_decryption_test_case_5(void)
5309 {
5310         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5);
5311 }
5312
5313 static int
5314 test_mb_AES_GCM_authenticated_decryption_test_case_6(void)
5315 {
5316         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6);
5317 }
5318
5319 static int
5320 test_mb_AES_GCM_authenticated_decryption_test_case_7(void)
5321 {
5322         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7);
5323 }
5324
5325 static int
5326 test_mb_AES_GCM_auth_decryption_test_case_256_1(void)
5327 {
5328         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_1);
5329 }
5330
5331 static int
5332 test_mb_AES_GCM_auth_decryption_test_case_256_2(void)
5333 {
5334         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_2);
5335 }
5336
5337 static int
5338 test_mb_AES_GCM_auth_decryption_test_case_256_3(void)
5339 {
5340         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_3);
5341 }
5342
5343 static int
5344 test_mb_AES_GCM_auth_decryption_test_case_256_4(void)
5345 {
5346         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_4);
5347 }
5348
5349 static int
5350 test_mb_AES_GCM_auth_decryption_test_case_256_5(void)
5351 {
5352         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_5);
5353 }
5354
5355 static int
5356 test_mb_AES_GCM_auth_decryption_test_case_256_6(void)
5357 {
5358         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_6);
5359 }
5360
5361 static int
5362 test_mb_AES_GCM_auth_decryption_test_case_256_7(void)
5363 {
5364         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_7);
5365 }
5366
5367 static int
5368 test_mb_AES_GCM_auth_decryption_test_case_aad_1(void)
5369 {
5370         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_1);
5371 }
5372
5373 static int
5374 test_mb_AES_GCM_auth_decryption_test_case_aad_2(void)
5375 {
5376         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_2);
5377 }
5378
5379 static int
5380 test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata)
5381 {
5382         struct crypto_testsuite_params *ts_params = &testsuite_params;
5383         struct crypto_unittest_params *ut_params = &unittest_params;
5384
5385         int retval;
5386         uint8_t *ciphertext, *auth_tag;
5387         uint16_t plaintext_pad_len;
5388
5389         /* Create GCM session */
5390         retval = create_gcm_session(ts_params->valid_devs[0],
5391                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5392                         tdata->key.data, tdata->key.len,
5393                         tdata->aad.len, tdata->auth_tag.len,
5394                         RTE_CRYPTO_AUTH_OP_GENERATE);
5395         if (retval < 0)
5396                 return retval;
5397
5398         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5399         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5400
5401         /* clear mbuf payload */
5402         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5403                         rte_pktmbuf_tailroom(ut_params->ibuf));
5404         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5405                         rte_pktmbuf_tailroom(ut_params->obuf));
5406
5407         /* Create GCM operation */
5408         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
5409         if (retval < 0)
5410                 return retval;
5411
5412         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5413
5414         ut_params->op->sym->m_src = ut_params->ibuf;
5415         ut_params->op->sym->m_dst = ut_params->obuf;
5416
5417         /* Process crypto operation */
5418         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5419                         ut_params->op), "failed to process sym crypto op");
5420
5421         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5422                         "crypto op processing failed");
5423
5424         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5425
5426         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5427                         ut_params->op->sym->cipher.data.offset);
5428         auth_tag = ciphertext + plaintext_pad_len;
5429
5430         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5431         TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5432
5433         /* Validate obuf */
5434         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5435                         ciphertext,
5436                         tdata->ciphertext.data,
5437                         tdata->ciphertext.len,
5438                         "GCM Ciphertext data not as expected");
5439
5440         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5441                         auth_tag,
5442                         tdata->auth_tag.data,
5443                         tdata->auth_tag.len,
5444                         "GCM Generated auth tag not as expected");
5445
5446         return 0;
5447
5448 }
5449
5450 static int
5451 test_mb_AES_GCM_authenticated_encryption_oop(void)
5452 {
5453         return test_AES_GCM_authenticated_encryption_oop(&gcm_test_case_5);
5454 }
5455
5456 static int
5457 test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata)
5458 {
5459         struct crypto_testsuite_params *ts_params = &testsuite_params;
5460         struct crypto_unittest_params *ut_params = &unittest_params;
5461
5462         int retval;
5463         uint8_t *plaintext;
5464
5465         /* Create GCM session */
5466         retval = create_gcm_session(ts_params->valid_devs[0],
5467                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
5468                         tdata->key.data, tdata->key.len,
5469                         tdata->aad.len, tdata->auth_tag.len,
5470                         RTE_CRYPTO_AUTH_OP_VERIFY);
5471         if (retval < 0)
5472                 return retval;
5473
5474         /* alloc mbuf and set payload */
5475         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5476         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5477
5478         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5479                         rte_pktmbuf_tailroom(ut_params->ibuf));
5480         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5481                         rte_pktmbuf_tailroom(ut_params->obuf));
5482
5483         /* Create GCM operation */
5484         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
5485         if (retval < 0)
5486                 return retval;
5487
5488         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5489
5490         ut_params->op->sym->m_src = ut_params->ibuf;
5491         ut_params->op->sym->m_dst = ut_params->obuf;
5492
5493         /* Process crypto operation */
5494         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5495                         ut_params->op), "failed to process sym crypto op");
5496
5497         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5498                         "crypto op processing failed");
5499
5500         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5501                         ut_params->op->sym->cipher.data.offset);
5502
5503         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5504
5505         /* Validate obuf */
5506         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5507                         plaintext,
5508                         tdata->plaintext.data,
5509                         tdata->plaintext.len,
5510                         "GCM plaintext data not as expected");
5511
5512         TEST_ASSERT_EQUAL(ut_params->op->status,
5513                         RTE_CRYPTO_OP_STATUS_SUCCESS,
5514                         "GCM authentication failed");
5515         return 0;
5516 }
5517
5518 static int
5519 test_mb_AES_GCM_authenticated_decryption_oop(void)
5520 {
5521         return test_AES_GCM_authenticated_decryption_oop(&gcm_test_case_5);
5522 }
5523
5524 static int
5525 test_AES_GCM_authenticated_encryption_sessionless(
5526                 const struct gcm_test_data *tdata)
5527 {
5528         struct crypto_testsuite_params *ts_params = &testsuite_params;
5529         struct crypto_unittest_params *ut_params = &unittest_params;
5530
5531         int retval;
5532         uint8_t *ciphertext, *auth_tag;
5533         uint16_t plaintext_pad_len;
5534         uint8_t key[tdata->key.len + 1];
5535
5536         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5537
5538         /* clear mbuf payload */
5539         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5540                         rte_pktmbuf_tailroom(ut_params->ibuf));
5541
5542         /* Create GCM operation */
5543         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
5544         if (retval < 0)
5545                 return retval;
5546
5547         /* Create GCM xforms */
5548         memcpy(key, tdata->key.data, tdata->key.len);
5549         retval = create_gcm_xforms(ut_params->op,
5550                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5551                         key, tdata->key.len,
5552                         tdata->aad.len, tdata->auth_tag.len,
5553                         RTE_CRYPTO_AUTH_OP_GENERATE);
5554         if (retval < 0)
5555                 return retval;
5556
5557         ut_params->op->sym->m_src = ut_params->ibuf;
5558
5559         TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type,
5560                         RTE_CRYPTO_SYM_OP_SESSIONLESS,
5561                         "crypto op session type not sessionless");
5562
5563         /* Process crypto operation */
5564         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5565                         ut_params->op), "failed to process sym crypto op");
5566
5567         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5568
5569         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5570                         "crypto op status not success");
5571
5572         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5573
5574         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
5575                         ut_params->op->sym->cipher.data.offset);
5576         auth_tag = ciphertext + plaintext_pad_len;
5577
5578         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5579         TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5580
5581         /* Validate obuf */
5582         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5583                         ciphertext,
5584                         tdata->ciphertext.data,
5585                         tdata->ciphertext.len,
5586                         "GCM Ciphertext data not as expected");
5587
5588         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5589                         auth_tag,
5590                         tdata->auth_tag.data,
5591                         tdata->auth_tag.len,
5592                         "GCM Generated auth tag not as expected");
5593
5594         return 0;
5595
5596 }
5597
5598 static int
5599 test_mb_AES_GCM_authenticated_encryption_sessionless(void)
5600 {
5601         return test_AES_GCM_authenticated_encryption_sessionless(
5602                         &gcm_test_case_5);
5603 }
5604
5605 static int
5606 test_AES_GCM_authenticated_decryption_sessionless(
5607                 const struct gcm_test_data *tdata)
5608 {
5609         struct crypto_testsuite_params *ts_params = &testsuite_params;
5610         struct crypto_unittest_params *ut_params = &unittest_params;
5611
5612         int retval;
5613         uint8_t *plaintext;
5614         uint8_t key[tdata->key.len + 1];
5615
5616         /* alloc mbuf and set payload */
5617         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5618
5619         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5620                         rte_pktmbuf_tailroom(ut_params->ibuf));
5621
5622         /* Create GCM operation */
5623         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
5624         if (retval < 0)
5625                 return retval;
5626
5627         /* Create GCM xforms */
5628         memcpy(key, tdata->key.data, tdata->key.len);
5629         retval = create_gcm_xforms(ut_params->op,
5630                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
5631                         key, tdata->key.len,
5632                         tdata->aad.len, tdata->auth_tag.len,
5633                         RTE_CRYPTO_AUTH_OP_VERIFY);
5634         if (retval < 0)
5635                 return retval;
5636
5637         ut_params->op->sym->m_src = ut_params->ibuf;
5638
5639         TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type,
5640                         RTE_CRYPTO_SYM_OP_SESSIONLESS,
5641                         "crypto op session type not sessionless");
5642
5643         /* Process crypto operation */
5644         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5645                         ut_params->op), "failed to process sym crypto op");
5646
5647         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5648
5649         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5650                         "crypto op status not success");
5651
5652         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
5653                         ut_params->op->sym->cipher.data.offset);
5654
5655         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5656
5657         /* Validate obuf */
5658         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5659                         plaintext,
5660                         tdata->plaintext.data,
5661                         tdata->plaintext.len,
5662                         "GCM plaintext data not as expected");
5663
5664         TEST_ASSERT_EQUAL(ut_params->op->status,
5665                         RTE_CRYPTO_OP_STATUS_SUCCESS,
5666                         "GCM authentication failed");
5667         return 0;
5668 }
5669
5670 static int
5671 test_mb_AES_GCM_authenticated_decryption_sessionless(void)
5672 {
5673         return test_AES_GCM_authenticated_decryption_sessionless(
5674                         &gcm_test_case_5);
5675 }
5676
5677 static int
5678 test_stats(void)
5679 {
5680         struct crypto_testsuite_params *ts_params = &testsuite_params;
5681         struct rte_cryptodev_stats stats;
5682         struct rte_cryptodev *dev;
5683         cryptodev_stats_get_t temp_pfn;
5684
5685         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
5686         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
5687                         &stats) == -ENODEV),
5688                 "rte_cryptodev_stats_get invalid dev failed");
5689         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
5690                 "rte_cryptodev_stats_get invalid Param failed");
5691         dev = &rte_cryptodevs[ts_params->valid_devs[0]];
5692         temp_pfn = dev->dev_ops->stats_get;
5693         dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
5694         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
5695                         == -ENOTSUP),
5696                 "rte_cryptodev_stats_get invalid Param failed");
5697         dev->dev_ops->stats_get = temp_pfn;
5698
5699         /* Test expected values */
5700         ut_setup();
5701         test_AES_CBC_HMAC_SHA1_encrypt_digest();
5702         ut_teardown();
5703         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5704                         &stats),
5705                 "rte_cryptodev_stats_get failed");
5706         TEST_ASSERT((stats.enqueued_count == 1),
5707                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5708         TEST_ASSERT((stats.dequeued_count == 1),
5709                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5710         TEST_ASSERT((stats.enqueue_err_count == 0),
5711                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5712         TEST_ASSERT((stats.dequeue_err_count == 0),
5713                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5714
5715         /* invalid device but should ignore and not reset device stats*/
5716         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
5717         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5718                         &stats),
5719                 "rte_cryptodev_stats_get failed");
5720         TEST_ASSERT((stats.enqueued_count == 1),
5721                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5722
5723         /* check that a valid reset clears stats */
5724         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
5725         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5726                         &stats),
5727                                           "rte_cryptodev_stats_get failed");
5728         TEST_ASSERT((stats.enqueued_count == 0),
5729                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5730         TEST_ASSERT((stats.dequeued_count == 0),
5731                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5732
5733         return TEST_SUCCESS;
5734 }
5735
5736 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
5737                                    struct crypto_unittest_params *ut_params,
5738                                    enum rte_crypto_auth_operation op,
5739                                    const struct HMAC_MD5_vector *test_case)
5740 {
5741         uint8_t key[64];
5742
5743         memcpy(key, test_case->key.data, test_case->key.len);
5744
5745         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5746         ut_params->auth_xform.next = NULL;
5747         ut_params->auth_xform.auth.op = op;
5748
5749         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
5750
5751         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
5752         ut_params->auth_xform.auth.add_auth_data_length = 0;
5753         ut_params->auth_xform.auth.key.length = test_case->key.len;
5754         ut_params->auth_xform.auth.key.data = key;
5755
5756         ut_params->sess = rte_cryptodev_sym_session_create(
5757                 ts_params->valid_devs[0], &ut_params->auth_xform);
5758
5759         if (ut_params->sess == NULL)
5760                 return TEST_FAILED;
5761
5762         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5763
5764         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5765                         rte_pktmbuf_tailroom(ut_params->ibuf));
5766
5767         return 0;
5768 }
5769
5770 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
5771                               const struct HMAC_MD5_vector *test_case,
5772                               uint8_t **plaintext)
5773 {
5774         uint16_t plaintext_pad_len;
5775
5776         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5777
5778         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
5779                                 16);
5780
5781         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5782                         plaintext_pad_len);
5783         memcpy(*plaintext, test_case->plaintext.data,
5784                         test_case->plaintext.len);
5785
5786         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5787                         ut_params->ibuf, MD5_DIGEST_LEN);
5788         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5789                         "no room to append digest");
5790         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5791                         ut_params->ibuf, plaintext_pad_len);
5792         sym_op->auth.digest.length = MD5_DIGEST_LEN;
5793
5794         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
5795                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
5796                            test_case->auth_tag.len);
5797         }
5798
5799         sym_op->auth.data.offset = 0;
5800         sym_op->auth.data.length = test_case->plaintext.len;
5801
5802         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5803         ut_params->op->sym->m_src = ut_params->ibuf;
5804
5805         return 0;
5806 }
5807
5808 static int
5809 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
5810 {
5811         uint16_t plaintext_pad_len;
5812         uint8_t *plaintext, *auth_tag;
5813
5814         struct crypto_testsuite_params *ts_params = &testsuite_params;
5815         struct crypto_unittest_params *ut_params = &unittest_params;
5816
5817         if (MD5_HMAC_create_session(ts_params, ut_params,
5818                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
5819                 return TEST_FAILED;
5820
5821         /* Generate Crypto op data structure */
5822         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5823                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5824         TEST_ASSERT_NOT_NULL(ut_params->op,
5825                         "Failed to allocate symmetric crypto operation struct");
5826
5827         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
5828                                 16);
5829
5830         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
5831                 return TEST_FAILED;
5832
5833         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5834                         ut_params->op), "failed to process sym crypto op");
5835
5836         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5837                         "crypto op processing failed");
5838
5839         if (ut_params->op->sym->m_dst) {
5840                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5841                                 uint8_t *, plaintext_pad_len);
5842         } else {
5843                 auth_tag = plaintext + plaintext_pad_len;
5844         }
5845
5846         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5847                         auth_tag,
5848                         test_case->auth_tag.data,
5849                         test_case->auth_tag.len,
5850                         "HMAC_MD5 generated tag not as expected");
5851
5852         return TEST_SUCCESS;
5853 }
5854
5855 static int
5856 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
5857 {
5858         uint8_t *plaintext;
5859
5860         struct crypto_testsuite_params *ts_params = &testsuite_params;
5861         struct crypto_unittest_params *ut_params = &unittest_params;
5862
5863         if (MD5_HMAC_create_session(ts_params, ut_params,
5864                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
5865                 return TEST_FAILED;
5866         }
5867
5868         /* Generate Crypto op data structure */
5869         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5870                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5871         TEST_ASSERT_NOT_NULL(ut_params->op,
5872                         "Failed to allocate symmetric crypto operation struct");
5873
5874         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
5875                 return TEST_FAILED;
5876
5877         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5878                         ut_params->op), "failed to process sym crypto op");
5879
5880         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5881                         "HMAC_MD5 crypto op processing failed");
5882
5883         return TEST_SUCCESS;
5884 }
5885
5886 static int
5887 test_MD5_HMAC_generate_case_1(void)
5888 {
5889         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
5890 }
5891
5892 static int
5893 test_MD5_HMAC_verify_case_1(void)
5894 {
5895         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
5896 }
5897
5898 static int
5899 test_MD5_HMAC_generate_case_2(void)
5900 {
5901         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
5902 }
5903
5904 static int
5905 test_MD5_HMAC_verify_case_2(void)
5906 {
5907         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
5908 }
5909
5910 static int
5911 test_multi_session(void)
5912 {
5913         struct crypto_testsuite_params *ts_params = &testsuite_params;
5914         struct crypto_unittest_params *ut_params = &unittest_params;
5915
5916         struct rte_cryptodev_info dev_info;
5917         struct rte_cryptodev_sym_session **sessions;
5918
5919         uint16_t i;
5920
5921         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
5922                         aes_cbc_key, hmac_sha512_key);
5923
5924
5925         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5926
5927         sessions = rte_malloc(NULL,
5928                         (sizeof(struct rte_cryptodev_sym_session *) *
5929                         dev_info.sym.max_nb_sessions) + 1, 0);
5930
5931         /* Create multiple crypto sessions*/
5932         for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
5933                 sessions[i] = rte_cryptodev_sym_session_create(
5934                                 ts_params->valid_devs[0],
5935                         &ut_params->auth_xform);
5936                 TEST_ASSERT_NOT_NULL(sessions[i],
5937                                 "Session creation failed at session number %u",
5938                                 i);
5939
5940                 /* Attempt to send a request on each session */
5941                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
5942                         sessions[i],
5943                         ut_params,
5944                         ts_params,
5945                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
5946                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
5947                         aes_cbc_iv),
5948                         "Failed to perform decrypt on request number %u.", i);
5949                 /* free crypto operation structure */
5950                 if (ut_params->op)
5951                         rte_crypto_op_free(ut_params->op);
5952
5953                 /*
5954                  * free mbuf - both obuf and ibuf are usually the same,
5955                  * so check if they point at the same address is necessary,
5956                  * to avoid freeing the mbuf twice.
5957                  */
5958                 if (ut_params->obuf) {
5959                         rte_pktmbuf_free(ut_params->obuf);
5960                         if (ut_params->ibuf == ut_params->obuf)
5961                                 ut_params->ibuf = 0;
5962                         ut_params->obuf = 0;
5963                 }
5964                 if (ut_params->ibuf) {
5965                         rte_pktmbuf_free(ut_params->ibuf);
5966                         ut_params->ibuf = 0;
5967                 }
5968         }
5969
5970         /* Next session create should fail */
5971         sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
5972                         &ut_params->auth_xform);
5973         TEST_ASSERT_NULL(sessions[i],
5974                         "Session creation succeeded unexpectedly!");
5975
5976         for (i = 0; i < dev_info.sym.max_nb_sessions; i++)
5977                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
5978                                 sessions[i]);
5979
5980         rte_free(sessions);
5981
5982         return TEST_SUCCESS;
5983 }
5984
5985 struct multi_session_params {
5986         struct crypto_unittest_params ut_params;
5987         uint8_t *cipher_key;
5988         uint8_t *hmac_key;
5989         const uint8_t *cipher;
5990         const uint8_t *digest;
5991         uint8_t *iv;
5992 };
5993
5994 #define MB_SESSION_NUMBER 3
5995
5996 static int
5997 test_multi_session_random_usage(void)
5998 {
5999         struct crypto_testsuite_params *ts_params = &testsuite_params;
6000         struct rte_cryptodev_info dev_info;
6001         struct rte_cryptodev_sym_session **sessions;
6002         uint32_t i, j;
6003         struct multi_session_params ut_paramz[] = {
6004
6005                 {
6006                         .cipher_key = ms_aes_cbc_key0,
6007                         .hmac_key = ms_hmac_key0,
6008                         .cipher = ms_aes_cbc_cipher0,
6009                         .digest = ms_hmac_digest0,
6010                         .iv = ms_aes_cbc_iv0
6011                 },
6012                 {
6013                         .cipher_key = ms_aes_cbc_key1,
6014                         .hmac_key = ms_hmac_key1,
6015                         .cipher = ms_aes_cbc_cipher1,
6016                         .digest = ms_hmac_digest1,
6017                         .iv = ms_aes_cbc_iv1
6018                 },
6019                 {
6020                         .cipher_key = ms_aes_cbc_key2,
6021                         .hmac_key = ms_hmac_key2,
6022                         .cipher = ms_aes_cbc_cipher2,
6023                         .digest = ms_hmac_digest2,
6024                         .iv = ms_aes_cbc_iv2
6025                 },
6026
6027         };
6028
6029         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6030
6031         sessions = rte_malloc(NULL,
6032                         (sizeof(struct rte_cryptodev_sym_session *)
6033                                         * dev_info.sym.max_nb_sessions) + 1, 0);
6034
6035         for (i = 0; i < MB_SESSION_NUMBER; i++) {
6036                 rte_memcpy(&ut_paramz[i].ut_params, &testsuite_params,
6037                                 sizeof(struct crypto_unittest_params));
6038
6039                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
6040                                 &ut_paramz[i].ut_params,
6041                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
6042
6043                 /* Create multiple crypto sessions*/
6044                 sessions[i] = rte_cryptodev_sym_session_create(
6045                                 ts_params->valid_devs[0],
6046                                 &ut_paramz[i].ut_params.auth_xform);
6047
6048                 TEST_ASSERT_NOT_NULL(sessions[i],
6049                                 "Session creation failed at session number %u",
6050                                 i);
6051
6052         }
6053
6054         srand(time(NULL));
6055         for (i = 0; i < 40000; i++) {
6056
6057                 j = rand() % MB_SESSION_NUMBER;
6058
6059                 TEST_ASSERT_SUCCESS(
6060                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
6061                                         sessions[j],
6062                                         &ut_paramz[j].ut_params,
6063                                         ts_params, ut_paramz[j].cipher,
6064                                         ut_paramz[j].digest,
6065                                         ut_paramz[j].iv),
6066                         "Failed to perform decrypt on request number %u.", i);
6067
6068                 if (ut_paramz[j].ut_params.op)
6069                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
6070
6071                 /*
6072                  * free mbuf - both obuf and ibuf are usually the same,
6073                  * so check if they point at the same address is necessary,
6074                  * to avoid freeing the mbuf twice.
6075                  */
6076                 if (ut_paramz[j].ut_params.obuf) {
6077                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
6078                         if (ut_paramz[j].ut_params.ibuf
6079                                         == ut_paramz[j].ut_params.obuf)
6080                                 ut_paramz[j].ut_params.ibuf = 0;
6081                         ut_paramz[j].ut_params.obuf = 0;
6082                 }
6083                 if (ut_paramz[j].ut_params.ibuf) {
6084                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
6085                         ut_paramz[j].ut_params.ibuf = 0;
6086                 }
6087         }
6088
6089         for (i = 0; i < MB_SESSION_NUMBER; i++)
6090                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
6091                                 sessions[i]);
6092
6093         rte_free(sessions);
6094
6095         return TEST_SUCCESS;
6096 }
6097
6098 static int
6099 test_null_cipher_only_operation(void)
6100 {
6101         struct crypto_testsuite_params *ts_params = &testsuite_params;
6102         struct crypto_unittest_params *ut_params = &unittest_params;
6103
6104         /* Generate test mbuf data and space for digest */
6105         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6106                         catch_22_quote, QUOTE_512_BYTES, 0);
6107
6108         /* Setup Cipher Parameters */
6109         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6110         ut_params->cipher_xform.next = NULL;
6111
6112         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6113         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6114
6115         /* Create Crypto session*/
6116         ut_params->sess = rte_cryptodev_sym_session_create(
6117                         ts_params->valid_devs[0], &ut_params->cipher_xform);
6118         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6119
6120         /* Generate Crypto op data structure */
6121         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6122                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6123         TEST_ASSERT_NOT_NULL(ut_params->op,
6124                         "Failed to allocate symmetric crypto operation struct");
6125
6126         /* Set crypto operation data parameters */
6127         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6128
6129         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6130
6131         /* set crypto operation source mbuf */
6132         sym_op->m_src = ut_params->ibuf;
6133
6134         sym_op->cipher.data.offset = 0;
6135         sym_op->cipher.data.length = QUOTE_512_BYTES;
6136
6137         /* Process crypto operation */
6138         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6139                         ut_params->op);
6140         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6141
6142         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6143                         "crypto operation processing failed");
6144
6145         /* Validate obuf */
6146         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6147                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6148                         catch_22_quote,
6149                         QUOTE_512_BYTES,
6150                         "Ciphertext data not as expected");
6151
6152         return TEST_SUCCESS;
6153 }
6154
6155 static int
6156 test_null_auth_only_operation(void)
6157 {
6158         struct crypto_testsuite_params *ts_params = &testsuite_params;
6159         struct crypto_unittest_params *ut_params = &unittest_params;
6160
6161         /* Generate test mbuf data and space for digest */
6162         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6163                         catch_22_quote, QUOTE_512_BYTES, 0);
6164
6165         /* Setup HMAC Parameters */
6166         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6167         ut_params->auth_xform.next = NULL;
6168
6169         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6170         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6171
6172         /* Create Crypto session*/
6173         ut_params->sess = rte_cryptodev_sym_session_create(
6174                         ts_params->valid_devs[0], &ut_params->auth_xform);
6175         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6176
6177         /* Generate Crypto op data structure */
6178         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6179                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6180         TEST_ASSERT_NOT_NULL(ut_params->op,
6181                         "Failed to allocate symmetric crypto operation struct");
6182
6183         /* Set crypto operation data parameters */
6184         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6185
6186         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6187
6188         sym_op->m_src = ut_params->ibuf;
6189
6190         sym_op->auth.data.offset = 0;
6191         sym_op->auth.data.length = QUOTE_512_BYTES;
6192
6193         /* Process crypto operation */
6194         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6195                         ut_params->op);
6196         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6197
6198         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6199                         "crypto operation processing failed");
6200
6201         return TEST_SUCCESS;
6202 }
6203
6204 static int
6205 test_null_cipher_auth_operation(void)
6206 {
6207         struct crypto_testsuite_params *ts_params = &testsuite_params;
6208         struct crypto_unittest_params *ut_params = &unittest_params;
6209
6210         /* Generate test mbuf data and space for digest */
6211         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6212                         catch_22_quote, QUOTE_512_BYTES, 0);
6213
6214         /* Setup Cipher Parameters */
6215         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6216         ut_params->cipher_xform.next = &ut_params->auth_xform;
6217
6218         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6219         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6220
6221         /* Setup HMAC Parameters */
6222         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6223         ut_params->auth_xform.next = NULL;
6224
6225         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6226         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6227
6228         /* Create Crypto session*/
6229         ut_params->sess = rte_cryptodev_sym_session_create(
6230                         ts_params->valid_devs[0], &ut_params->cipher_xform);
6231         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6232
6233         /* Generate Crypto op data structure */
6234         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6235                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6236         TEST_ASSERT_NOT_NULL(ut_params->op,
6237                         "Failed to allocate symmetric crypto operation struct");
6238
6239         /* Set crypto operation data parameters */
6240         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6241
6242         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6243
6244         sym_op->m_src = ut_params->ibuf;
6245
6246         sym_op->cipher.data.offset = 0;
6247         sym_op->cipher.data.length = QUOTE_512_BYTES;
6248
6249         sym_op->auth.data.offset = 0;
6250         sym_op->auth.data.length = QUOTE_512_BYTES;
6251
6252         /* Process crypto operation */
6253         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6254                         ut_params->op);
6255         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6256
6257         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6258                         "crypto operation processing failed");
6259
6260         /* Validate obuf */
6261         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6262                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6263                         catch_22_quote,
6264                         QUOTE_512_BYTES,
6265                         "Ciphertext data not as expected");
6266
6267         return TEST_SUCCESS;
6268 }
6269
6270 static int
6271 test_null_auth_cipher_operation(void)
6272 {
6273         struct crypto_testsuite_params *ts_params = &testsuite_params;
6274         struct crypto_unittest_params *ut_params = &unittest_params;
6275
6276         /* Generate test mbuf data and space for digest */
6277         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6278                         catch_22_quote, QUOTE_512_BYTES, 0);
6279
6280         /* Setup Cipher Parameters */
6281         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6282         ut_params->cipher_xform.next = NULL;
6283
6284         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6285         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6286
6287         /* Setup HMAC Parameters */
6288         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6289         ut_params->auth_xform.next = &ut_params->cipher_xform;
6290
6291         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6292         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6293
6294         /* Create Crypto session*/
6295         ut_params->sess = rte_cryptodev_sym_session_create(
6296                         ts_params->valid_devs[0], &ut_params->cipher_xform);
6297         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6298
6299         /* Generate Crypto op data structure */
6300         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6301                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6302         TEST_ASSERT_NOT_NULL(ut_params->op,
6303                         "Failed to allocate symmetric crypto operation struct");
6304
6305         /* Set crypto operation data parameters */
6306         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6307
6308         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6309
6310         sym_op->m_src = ut_params->ibuf;
6311
6312         sym_op->cipher.data.offset = 0;
6313         sym_op->cipher.data.length = QUOTE_512_BYTES;
6314
6315         sym_op->auth.data.offset = 0;
6316         sym_op->auth.data.length = QUOTE_512_BYTES;
6317
6318         /* Process crypto operation */
6319         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6320                         ut_params->op);
6321         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6322
6323         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6324                         "crypto operation processing failed");
6325
6326         /* Validate obuf */
6327         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6328                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6329                         catch_22_quote,
6330                         QUOTE_512_BYTES,
6331                         "Ciphertext data not as expected");
6332
6333         return TEST_SUCCESS;
6334 }
6335
6336
6337 static int
6338 test_null_invalid_operation(void)
6339 {
6340         struct crypto_testsuite_params *ts_params = &testsuite_params;
6341         struct crypto_unittest_params *ut_params = &unittest_params;
6342
6343         /* Setup Cipher Parameters */
6344         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6345         ut_params->cipher_xform.next = NULL;
6346
6347         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
6348         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6349
6350         /* Create Crypto session*/
6351         ut_params->sess = rte_cryptodev_sym_session_create(
6352                         ts_params->valid_devs[0], &ut_params->cipher_xform);
6353         TEST_ASSERT_NULL(ut_params->sess,
6354                         "Session creation succeeded unexpectedly");
6355
6356
6357         /* Setup HMAC Parameters */
6358         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6359         ut_params->auth_xform.next = NULL;
6360
6361         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
6362         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6363
6364         /* Create Crypto session*/
6365         ut_params->sess = rte_cryptodev_sym_session_create(
6366                         ts_params->valid_devs[0], &ut_params->auth_xform);
6367         TEST_ASSERT_NULL(ut_params->sess,
6368                         "Session creation succeeded unexpectedly");
6369
6370         return TEST_SUCCESS;
6371 }
6372
6373
6374 #define NULL_BURST_LENGTH (32)
6375
6376 static int
6377 test_null_burst_operation(void)
6378 {
6379         struct crypto_testsuite_params *ts_params = &testsuite_params;
6380         struct crypto_unittest_params *ut_params = &unittest_params;
6381
6382         unsigned i, burst_len = NULL_BURST_LENGTH;
6383
6384         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
6385         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
6386
6387         /* Setup Cipher Parameters */
6388         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6389         ut_params->cipher_xform.next = &ut_params->auth_xform;
6390
6391         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6392         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6393
6394         /* Setup HMAC Parameters */
6395         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6396         ut_params->auth_xform.next = NULL;
6397
6398         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6399         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6400
6401         /* Create Crypto session*/
6402         ut_params->sess = rte_cryptodev_sym_session_create(
6403                         ts_params->valid_devs[0], &ut_params->cipher_xform);
6404         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6405
6406         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
6407                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
6408                         burst_len, "failed to generate burst of crypto ops");
6409
6410         /* Generate an operation for each mbuf in burst */
6411         for (i = 0; i < burst_len; i++) {
6412                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6413
6414                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
6415
6416                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
6417                                 sizeof(unsigned));
6418                 *data = i;
6419
6420                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
6421
6422                 burst[i]->sym->m_src = m;
6423         }
6424
6425         /* Process crypto operation */
6426         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
6427                         0, burst, burst_len),
6428                         burst_len,
6429                         "Error enqueuing burst");
6430
6431         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
6432                         0, burst_dequeued, burst_len),
6433                         burst_len,
6434                         "Error dequeuing burst");
6435
6436
6437         for (i = 0; i < burst_len; i++) {
6438                 TEST_ASSERT_EQUAL(
6439                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
6440                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
6441                                         uint32_t *),
6442                         "data not as expected");
6443
6444                 rte_pktmbuf_free(burst[i]->sym->m_src);
6445                 rte_crypto_op_free(burst[i]);
6446         }
6447
6448         return TEST_SUCCESS;
6449 }
6450
6451 static void
6452 generate_gmac_large_plaintext(uint8_t *data)
6453 {
6454         uint16_t i;
6455
6456         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
6457                 memcpy(&data[i], &data[0], 32);
6458 }
6459
6460 static int
6461 create_gmac_operation(enum rte_crypto_auth_operation op,
6462                 const struct gmac_test_data *tdata)
6463 {
6464         struct crypto_testsuite_params *ts_params = &testsuite_params;
6465         struct crypto_unittest_params *ut_params = &unittest_params;
6466         struct rte_crypto_sym_op *sym_op;
6467
6468         unsigned iv_pad_len;
6469         unsigned aad_pad_len;
6470
6471         iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
6472         aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
6473
6474         /*
6475          * Runtime generate the large plain text instead of use hard code
6476          * plain text vector. It is done to avoid create huge source file
6477          * with the test vector.
6478          */
6479         if (tdata->aad.len == GMAC_LARGE_PLAINTEXT_LENGTH)
6480                 generate_gmac_large_plaintext(tdata->aad.data);
6481
6482         /* Generate Crypto op data structure */
6483         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6484                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6485         TEST_ASSERT_NOT_NULL(ut_params->op,
6486                         "Failed to allocate symmetric crypto operation struct");
6487
6488         sym_op = ut_params->op->sym;
6489         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6490                         aad_pad_len);
6491         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
6492                         "no room to append aad");
6493
6494         sym_op->auth.aad.length = tdata->aad.len;
6495         sym_op->auth.aad.phys_addr =
6496                         rte_pktmbuf_mtophys(ut_params->ibuf);
6497         memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len);
6498
6499         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
6500                         ut_params->ibuf, tdata->gmac_tag.len);
6501         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6502                         "no room to append digest");
6503
6504         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
6505                         ut_params->ibuf, aad_pad_len);
6506         sym_op->auth.digest.length = tdata->gmac_tag.len;
6507
6508         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
6509                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
6510                                 tdata->gmac_tag.len);
6511                 TEST_HEXDUMP(stdout, "digest:",
6512                                 sym_op->auth.digest.data,
6513                                 sym_op->auth.digest.length);
6514         }
6515
6516         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
6517                         ut_params->ibuf, iv_pad_len);
6518         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
6519
6520         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
6521         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
6522         sym_op->cipher.iv.length = tdata->iv.len;
6523
6524         rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
6525
6526         TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
6527
6528         sym_op->cipher.data.length = 0;
6529         sym_op->cipher.data.offset = 0;
6530
6531         sym_op->auth.data.offset = 0;
6532         sym_op->auth.data.length = 0;
6533
6534         return 0;
6535 }
6536
6537 static int create_gmac_session(uint8_t dev_id,
6538                 enum rte_crypto_cipher_operation op,
6539                 const struct gmac_test_data *tdata,
6540                 enum rte_crypto_auth_operation auth_op)
6541 {
6542         uint8_t cipher_key[tdata->key.len];
6543
6544         struct crypto_unittest_params *ut_params = &unittest_params;
6545
6546         memcpy(cipher_key, tdata->key.data, tdata->key.len);
6547
6548         /* For GMAC we setup cipher parameters */
6549         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6550         ut_params->cipher_xform.next = NULL;
6551         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
6552         ut_params->cipher_xform.cipher.op = op;
6553         ut_params->cipher_xform.cipher.key.data = cipher_key;
6554         ut_params->cipher_xform.cipher.key.length = tdata->key.len;
6555
6556         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6557         ut_params->auth_xform.next = NULL;
6558
6559         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
6560         ut_params->auth_xform.auth.op = auth_op;
6561         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
6562         ut_params->auth_xform.auth.add_auth_data_length = 0;
6563         ut_params->auth_xform.auth.key.length = 0;
6564         ut_params->auth_xform.auth.key.data = NULL;
6565
6566         ut_params->cipher_xform.next = &ut_params->auth_xform;
6567
6568         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
6569                         &ut_params->cipher_xform);
6570
6571         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6572
6573         return 0;
6574 }
6575
6576 static int
6577 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
6578 {
6579         struct crypto_testsuite_params *ts_params = &testsuite_params;
6580         struct crypto_unittest_params *ut_params = &unittest_params;
6581
6582         int retval;
6583
6584         uint8_t *auth_tag, *p;
6585         uint16_t aad_pad_len;
6586
6587         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
6588                               "No GMAC length in the source data");
6589
6590         retval = create_gmac_session(ts_params->valid_devs[0],
6591                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6592                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
6593
6594         if (retval < 0)
6595                 return retval;
6596
6597         if (tdata->aad.len > MBUF_SIZE)
6598                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
6599         else
6600                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6601         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6602                         "Failed to allocate input buffer in mempool");
6603
6604         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6605                         rte_pktmbuf_tailroom(ut_params->ibuf));
6606
6607         aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
6608
6609         p = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *);
6610
6611         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
6612                         tdata);
6613
6614         if (retval < 0)
6615                 return retval;
6616
6617         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6618
6619         ut_params->op->sym->m_src = ut_params->ibuf;
6620
6621         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6622                         ut_params->op), "failed to process sym crypto op");
6623
6624         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6625                         "crypto op processing failed");
6626
6627         if (ut_params->op->sym->m_dst) {
6628                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
6629                                 uint8_t *, aad_pad_len);
6630         } else {
6631                 auth_tag = p + aad_pad_len;
6632         }
6633
6634         TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
6635
6636         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6637                         auth_tag,
6638                         tdata->gmac_tag.data,
6639                         tdata->gmac_tag.len,
6640                         "GMAC Generated auth tag not as expected");
6641
6642         return 0;
6643 }
6644
6645 static int
6646 test_AES_GMAC_authentication_test_case_1(void)
6647 {
6648         return test_AES_GMAC_authentication(&gmac_test_case_1);
6649 }
6650
6651 static int
6652 test_AES_GMAC_authentication_test_case_2(void)
6653 {
6654         return test_AES_GMAC_authentication(&gmac_test_case_2);
6655 }
6656
6657 static int
6658 test_AES_GMAC_authentication_test_case_3(void)
6659 {
6660         return test_AES_GMAC_authentication(&gmac_test_case_3);
6661 }
6662
6663 static int
6664 test_AES_GMAC_authentication_test_case_4(void)
6665 {
6666         return test_AES_GMAC_authentication(&gmac_test_case_4);
6667 }
6668
6669 static int
6670 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
6671 {
6672         struct crypto_testsuite_params *ts_params = &testsuite_params;
6673         struct crypto_unittest_params *ut_params = &unittest_params;
6674         int retval;
6675
6676         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
6677                               "No GMAC length in the source data");
6678
6679         retval = create_gmac_session(ts_params->valid_devs[0],
6680                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
6681                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
6682
6683         if (retval < 0)
6684                 return retval;
6685
6686         if (tdata->aad.len > MBUF_SIZE)
6687                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
6688         else
6689                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6690         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6691                         "Failed to allocate input buffer in mempool");
6692
6693         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6694                         rte_pktmbuf_tailroom(ut_params->ibuf));
6695
6696         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
6697                         tdata);
6698
6699         if (retval < 0)
6700                 return retval;
6701
6702         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6703
6704         ut_params->op->sym->m_src = ut_params->ibuf;
6705
6706         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6707                         ut_params->op), "failed to process sym crypto op");
6708
6709         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6710                         "crypto op processing failed");
6711
6712         return 0;
6713
6714 }
6715
6716 static int
6717 test_AES_GMAC_authentication_verify_test_case_1(void)
6718 {
6719         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
6720 }
6721
6722 static int
6723 test_AES_GMAC_authentication_verify_test_case_2(void)
6724 {
6725         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
6726 }
6727
6728 static int
6729 test_AES_GMAC_authentication_verify_test_case_3(void)
6730 {
6731         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
6732 }
6733
6734 static int
6735 test_AES_GMAC_authentication_verify_test_case_4(void)
6736 {
6737         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
6738 }
6739
6740 struct test_crypto_vector {
6741         enum rte_crypto_cipher_algorithm crypto_algo;
6742
6743         struct {
6744                 uint8_t data[64];
6745                 unsigned int len;
6746         } cipher_key;
6747
6748         struct {
6749                 uint8_t data[64];
6750                 unsigned int len;
6751         } iv;
6752
6753         struct {
6754                 const uint8_t *data;
6755                 unsigned int len;
6756         } plaintext;
6757
6758         struct {
6759                 const uint8_t *data;
6760                 unsigned int len;
6761         } ciphertext;
6762
6763         enum rte_crypto_auth_algorithm auth_algo;
6764
6765         struct {
6766                 uint8_t data[128];
6767                 unsigned int len;
6768         } auth_key;
6769
6770         struct {
6771                 const uint8_t *data;
6772                 unsigned int len;
6773         } aad;
6774
6775         struct {
6776                 uint8_t data[128];
6777                 unsigned int len;
6778         } digest;
6779 };
6780
6781 static const struct test_crypto_vector
6782 hmac_sha1_test_crypto_vector = {
6783         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
6784         .plaintext = {
6785                 .data = plaintext_hash,
6786                 .len = 512
6787         },
6788         .auth_key = {
6789                 .data = {
6790                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
6791                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
6792                         0xDE, 0xF4, 0xDE, 0xAD
6793                 },
6794                 .len = 20
6795         },
6796         .digest = {
6797                 .data = {
6798                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
6799                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
6800                         0x3F, 0x91, 0x64, 0x59
6801                 },
6802                 .len = 20
6803         }
6804 };
6805
6806 static const struct test_crypto_vector
6807 aes128_gmac_test_vector = {
6808         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
6809         .crypto_algo = RTE_CRYPTO_CIPHER_AES_GCM,
6810         .aad = {
6811                 .data = plaintext_hash,
6812                 .len = 512
6813         },
6814         .iv = {
6815                 .data = {
6816                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
6817                         0x08, 0x09, 0x0A, 0x0B
6818                 },
6819                 .len = 12
6820         },
6821         .cipher_key = {
6822                 .data = {
6823                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
6824                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
6825                 },
6826                 .len = 16
6827         },
6828         .digest = {
6829                 .data = {
6830                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
6831                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
6832                 },
6833                 .len = 16
6834         }
6835 };
6836
6837 static const struct test_crypto_vector
6838 aes128cbc_hmac_sha1_test_vector = {
6839         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
6840         .cipher_key = {
6841                 .data = {
6842                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
6843                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
6844                 },
6845                 .len = 16
6846         },
6847         .iv = {
6848                 .data = {
6849                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
6850                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
6851                 },
6852                 .len = 16
6853         },
6854         .plaintext = {
6855                 .data = plaintext_hash,
6856                 .len = 512
6857         },
6858         .ciphertext = {
6859                 .data = ciphertext512_aes128cbc,
6860                 .len = 512
6861         },
6862         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
6863         .auth_key = {
6864                 .data = {
6865                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
6866                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
6867                         0xDE, 0xF4, 0xDE, 0xAD
6868                 },
6869                 .len = 20
6870         },
6871         .digest = {
6872                 .data = {
6873                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
6874                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
6875                         0x18, 0x8C, 0x1D, 0x32
6876                 },
6877                 .len = 20
6878         }
6879 };
6880
6881 static void
6882 data_corruption(uint8_t *data)
6883 {
6884         data[0] += 1;
6885 }
6886
6887 static void
6888 tag_corruption(uint8_t *data, unsigned int tag_offset)
6889 {
6890         data[tag_offset] += 1;
6891 }
6892
6893 static int
6894 create_auth_session(struct crypto_unittest_params *ut_params,
6895                 uint8_t dev_id,
6896                 const struct test_crypto_vector *reference,
6897                 enum rte_crypto_auth_operation auth_op)
6898 {
6899         uint8_t auth_key[reference->auth_key.len + 1];
6900
6901         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
6902
6903         /* Setup Authentication Parameters */
6904         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6905         ut_params->auth_xform.auth.op = auth_op;
6906         ut_params->auth_xform.next = NULL;
6907         ut_params->auth_xform.auth.algo = reference->auth_algo;
6908         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
6909         ut_params->auth_xform.auth.key.data = auth_key;
6910         ut_params->auth_xform.auth.digest_length = reference->digest.len;
6911         ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
6912
6913         /* Create Crypto session*/
6914         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
6915                                 &ut_params->auth_xform);
6916
6917         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6918
6919         return 0;
6920 }
6921
6922 static int
6923 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
6924                 uint8_t dev_id,
6925                 const struct test_crypto_vector *reference,
6926                 enum rte_crypto_auth_operation auth_op,
6927                 enum rte_crypto_cipher_operation cipher_op)
6928 {
6929         uint8_t cipher_key[reference->cipher_key.len + 1];
6930         uint8_t auth_key[reference->auth_key.len + 1];
6931
6932         memcpy(cipher_key, reference->cipher_key.data,
6933                         reference->cipher_key.len);
6934         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
6935
6936         /* Setup Authentication Parameters */
6937         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6938         ut_params->auth_xform.auth.op = auth_op;
6939         ut_params->auth_xform.next = &ut_params->cipher_xform;
6940         ut_params->auth_xform.auth.algo = reference->auth_algo;
6941         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
6942         ut_params->auth_xform.auth.key.data = auth_key;
6943         ut_params->auth_xform.auth.digest_length = reference->digest.len;
6944         ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
6945
6946         /* Setup Cipher Parameters */
6947         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6948         ut_params->cipher_xform.next = NULL;
6949         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
6950         ut_params->cipher_xform.cipher.op = cipher_op;
6951         ut_params->cipher_xform.cipher.key.data = cipher_key;
6952         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
6953
6954         /* Create Crypto session*/
6955         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
6956                                 &ut_params->auth_xform);
6957
6958         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6959
6960         return 0;
6961 }
6962
6963 static int
6964 create_auth_operation(struct crypto_testsuite_params *ts_params,
6965                 struct crypto_unittest_params *ut_params,
6966                 const struct test_crypto_vector *reference,
6967                 unsigned int auth_generate)
6968 {
6969         /* Generate Crypto op data structure */
6970         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6971                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6972         TEST_ASSERT_NOT_NULL(ut_params->op,
6973                         "Failed to allocate pktmbuf offload");
6974
6975         /* Set crypto operation data parameters */
6976         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6977
6978         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6979
6980         /* set crypto operation source mbuf */
6981         sym_op->m_src = ut_params->ibuf;
6982
6983         /* digest */
6984         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
6985                         ut_params->ibuf, reference->digest.len);
6986
6987         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6988                         "no room to append auth tag");
6989
6990         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
6991                         ut_params->ibuf, reference->plaintext.len);
6992         sym_op->auth.digest.length = reference->digest.len;
6993
6994         if (auth_generate)
6995                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
6996         else
6997                 memcpy(sym_op->auth.digest.data,
6998                                 reference->digest.data,
6999                                 reference->digest.len);
7000
7001         TEST_HEXDUMP(stdout, "digest:",
7002                         sym_op->auth.digest.data,
7003                         sym_op->auth.digest.length);
7004
7005         sym_op->auth.data.length = reference->plaintext.len;
7006         sym_op->auth.data.offset = 0;
7007
7008         return 0;
7009 }
7010
7011 static int
7012 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
7013                 struct crypto_unittest_params *ut_params,
7014                 const struct test_crypto_vector *reference,
7015                 unsigned int auth_generate)
7016 {
7017         /* Generate Crypto op data structure */
7018         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7019                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7020         TEST_ASSERT_NOT_NULL(ut_params->op,
7021                         "Failed to allocate pktmbuf offload");
7022
7023         /* Set crypto operation data parameters */
7024         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7025
7026         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7027
7028         /* set crypto operation source mbuf */
7029         sym_op->m_src = ut_params->ibuf;
7030
7031         /* aad */
7032         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7033                         reference->aad.len);
7034         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, "no room to append AAD");
7035         memcpy(sym_op->auth.aad.data, reference->aad.data, reference->aad.len);
7036
7037         TEST_HEXDUMP(stdout, "AAD:", sym_op->auth.aad.data, reference->aad.len);
7038
7039         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
7040         sym_op->auth.aad.length = reference->aad.len;
7041
7042         /* digest */
7043         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7044                         ut_params->ibuf, reference->digest.len);
7045
7046         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7047                         "no room to append auth tag");
7048
7049         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
7050                         ut_params->ibuf, reference->ciphertext.len);
7051         sym_op->auth.digest.length = reference->digest.len;
7052
7053         if (auth_generate)
7054                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7055         else
7056                 memcpy(sym_op->auth.digest.data,
7057                                 reference->digest.data,
7058                                 reference->digest.len);
7059
7060         TEST_HEXDUMP(stdout, "digest:",
7061                         sym_op->auth.digest.data,
7062                         sym_op->auth.digest.length);
7063
7064         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
7065                 ut_params->ibuf, reference->iv.len);
7066         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
7067
7068         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
7069         sym_op->cipher.iv.length = reference->iv.len;
7070
7071         memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
7072
7073         sym_op->cipher.data.length = 0;
7074         sym_op->cipher.data.offset = 0;
7075
7076         sym_op->auth.data.length = 0;
7077         sym_op->auth.data.offset = 0;
7078
7079         return 0;
7080 }
7081
7082 static int
7083 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
7084                 struct crypto_unittest_params *ut_params,
7085                 const struct test_crypto_vector *reference,
7086                 unsigned int auth_generate)
7087 {
7088         /* Generate Crypto op data structure */
7089         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7090                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7091         TEST_ASSERT_NOT_NULL(ut_params->op,
7092                         "Failed to allocate pktmbuf offload");
7093
7094         /* Set crypto operation data parameters */
7095         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7096
7097         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7098
7099         /* set crypto operation source mbuf */
7100         sym_op->m_src = ut_params->ibuf;
7101
7102         /* digest */
7103         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7104                         ut_params->ibuf, reference->digest.len);
7105
7106         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7107                         "no room to append auth tag");
7108
7109         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
7110                         ut_params->ibuf, reference->ciphertext.len);
7111         sym_op->auth.digest.length = reference->digest.len;
7112
7113         if (auth_generate)
7114                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7115         else
7116                 memcpy(sym_op->auth.digest.data,
7117                                 reference->digest.data,
7118                                 reference->digest.len);
7119
7120         TEST_HEXDUMP(stdout, "digest:",
7121                         sym_op->auth.digest.data,
7122                         sym_op->auth.digest.length);
7123
7124         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
7125                 ut_params->ibuf, reference->iv.len);
7126         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
7127
7128         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
7129         sym_op->cipher.iv.length = reference->iv.len;
7130
7131         memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
7132
7133         sym_op->cipher.data.length = reference->ciphertext.len;
7134         sym_op->cipher.data.offset = reference->iv.len;
7135
7136         sym_op->auth.data.length = reference->ciphertext.len;
7137         sym_op->auth.data.offset = reference->iv.len;
7138
7139         return 0;
7140 }
7141
7142 static int
7143 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
7144                 struct crypto_unittest_params *ut_params,
7145                 const struct test_crypto_vector *reference)
7146 {
7147         return create_auth_operation(ts_params, ut_params, reference, 0);
7148 }
7149
7150 static int
7151 create_auth_verify_GMAC_operation(
7152                 struct crypto_testsuite_params *ts_params,
7153                 struct crypto_unittest_params *ut_params,
7154                 const struct test_crypto_vector *reference)
7155 {
7156         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
7157 }
7158
7159 static int
7160 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
7161                 struct crypto_unittest_params *ut_params,
7162                 const struct test_crypto_vector *reference)
7163 {
7164         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
7165 }
7166
7167 static int
7168 test_authentication_verify_fail_when_data_corruption(
7169                 struct crypto_testsuite_params *ts_params,
7170                 struct crypto_unittest_params *ut_params,
7171                 const struct test_crypto_vector *reference,
7172                 unsigned int data_corrupted)
7173 {
7174         int retval;
7175
7176         uint8_t *plaintext;
7177
7178         /* Create session */
7179         retval = create_auth_session(ut_params,
7180                         ts_params->valid_devs[0],
7181                         reference,
7182                         RTE_CRYPTO_AUTH_OP_VERIFY);
7183         if (retval < 0)
7184                 return retval;
7185
7186         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7187         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7188                         "Failed to allocate input buffer in mempool");
7189
7190         /* clear mbuf payload */
7191         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7192                         rte_pktmbuf_tailroom(ut_params->ibuf));
7193
7194         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7195                         reference->plaintext.len);
7196         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7197         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
7198
7199         TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len);
7200
7201         /* Create operation */
7202         retval = create_auth_verify_operation(ts_params, ut_params, reference);
7203
7204         if (retval < 0)
7205                 return retval;
7206
7207         if (data_corrupted)
7208                 data_corruption(plaintext);
7209         else
7210                 tag_corruption(plaintext, reference->plaintext.len);
7211
7212         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7213                         ut_params->op);
7214         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7215         TEST_ASSERT_EQUAL(ut_params->op->status,
7216                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7217                         "authentication not failed");
7218
7219         ut_params->obuf = ut_params->op->sym->m_src;
7220         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7221
7222         return 0;
7223 }
7224
7225 static int
7226 test_authentication_verify_GMAC_fail_when_corruption(
7227                 struct crypto_testsuite_params *ts_params,
7228                 struct crypto_unittest_params *ut_params,
7229                 const struct test_crypto_vector *reference,
7230                 unsigned int data_corrupted)
7231 {
7232         int retval;
7233
7234         /* Create session */
7235         retval = create_auth_cipher_session(ut_params,
7236                         ts_params->valid_devs[0],
7237                         reference,
7238                         RTE_CRYPTO_AUTH_OP_VERIFY,
7239                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
7240         if (retval < 0)
7241                 return retval;
7242
7243         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7244         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7245                         "Failed to allocate input buffer in mempool");
7246
7247         /* clear mbuf payload */
7248         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7249                         rte_pktmbuf_tailroom(ut_params->ibuf));
7250
7251         /* Create operation */
7252         retval = create_auth_verify_GMAC_operation(ts_params,
7253                         ut_params,
7254                         reference);
7255
7256         if (retval < 0)
7257                 return retval;
7258
7259         if (data_corrupted)
7260                 data_corruption(ut_params->op->sym->auth.aad.data);
7261         else
7262                 tag_corruption(ut_params->op->sym->auth.aad.data,
7263                                 reference->aad.len);
7264
7265         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7266                         ut_params->op);
7267         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7268         TEST_ASSERT_EQUAL(ut_params->op->status,
7269                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7270                         "authentication not failed");
7271
7272         ut_params->obuf = ut_params->op->sym->m_src;
7273         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7274
7275         return 0;
7276 }
7277
7278 static int
7279 test_authenticated_decryption_fail_when_corruption(
7280                 struct crypto_testsuite_params *ts_params,
7281                 struct crypto_unittest_params *ut_params,
7282                 const struct test_crypto_vector *reference,
7283                 unsigned int data_corrupted)
7284 {
7285         int retval;
7286
7287         uint8_t *ciphertext;
7288
7289         /* Create session */
7290         retval = create_auth_cipher_session(ut_params,
7291                         ts_params->valid_devs[0],
7292                         reference,
7293                         RTE_CRYPTO_AUTH_OP_VERIFY,
7294                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
7295         if (retval < 0)
7296                 return retval;
7297
7298         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7299         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7300                         "Failed to allocate input buffer in mempool");
7301
7302         /* clear mbuf payload */
7303         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7304                         rte_pktmbuf_tailroom(ut_params->ibuf));
7305
7306         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7307                         reference->ciphertext.len);
7308         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
7309         memcpy(ciphertext, reference->ciphertext.data,
7310                         reference->ciphertext.len);
7311
7312         /* Create operation */
7313         retval = create_cipher_auth_verify_operation(ts_params,
7314                         ut_params,
7315                         reference);
7316
7317         if (retval < 0)
7318                 return retval;
7319
7320         if (data_corrupted)
7321                 data_corruption(ciphertext);
7322         else
7323                 tag_corruption(ciphertext, reference->ciphertext.len);
7324
7325         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7326                         ut_params->op);
7327
7328         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
7329         TEST_ASSERT_EQUAL(ut_params->op->status,
7330                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
7331                         "authentication not failed");
7332
7333         ut_params->obuf = ut_params->op->sym->m_src;
7334         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
7335
7336         return 0;
7337 }
7338
7339 static int
7340 create_gcm_operation_SGL(enum rte_crypto_cipher_operation op,
7341                 const struct gcm_test_data *tdata,
7342                 void *digest_mem, uint64_t digest_phys)
7343 {
7344         struct crypto_testsuite_params *ts_params = &testsuite_params;
7345         struct crypto_unittest_params *ut_params = &unittest_params;
7346
7347         const unsigned int auth_tag_len = tdata->auth_tag.len;
7348         const unsigned int iv_len = tdata->iv.len;
7349         const unsigned int aad_len = tdata->aad.len;
7350
7351         unsigned int iv_pad_len = 0;
7352
7353         /* Generate Crypto op data structure */
7354         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7355                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7356         TEST_ASSERT_NOT_NULL(ut_params->op,
7357                 "Failed to allocate symmetric crypto operation struct");
7358
7359         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7360
7361         sym_op->auth.digest.data = digest_mem;
7362
7363         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7364                         "no room to append digest");
7365
7366         sym_op->auth.digest.phys_addr = digest_phys;
7367         sym_op->auth.digest.length = auth_tag_len;
7368
7369         if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
7370                 rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data,
7371                                 auth_tag_len);
7372                 TEST_HEXDUMP(stdout, "digest:",
7373                                 sym_op->auth.digest.data,
7374                                 sym_op->auth.digest.length);
7375         }
7376
7377         iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
7378
7379         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
7380                         ut_params->ibuf, iv_pad_len);
7381
7382         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data,
7383                         "no room to prepend iv");
7384
7385         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
7386         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
7387         sym_op->cipher.iv.length = iv_len;
7388
7389         rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, iv_pad_len);
7390
7391         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
7392                         ut_params->ibuf, aad_len);
7393         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
7394                         "no room to prepend aad");
7395         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
7396                         ut_params->ibuf);
7397         sym_op->auth.aad.length = aad_len;
7398
7399         memset(sym_op->auth.aad.data, 0, aad_len);
7400         rte_memcpy(sym_op->auth.aad.data, tdata->aad.data, aad_len);
7401
7402         TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
7403         TEST_HEXDUMP(stdout, "aad:",
7404                         sym_op->auth.aad.data, aad_len);
7405
7406         sym_op->cipher.data.length = tdata->plaintext.len;
7407         sym_op->cipher.data.offset = aad_len + iv_pad_len;
7408
7409         sym_op->auth.data.offset = aad_len + iv_pad_len;
7410         sym_op->auth.data.length = tdata->plaintext.len;
7411
7412         return 0;
7413 }
7414
7415 #define SGL_MAX_NO      16
7416
7417 static int
7418 test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
7419                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
7420 {
7421         struct crypto_testsuite_params *ts_params = &testsuite_params;
7422         struct crypto_unittest_params *ut_params = &unittest_params;
7423         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
7424         int retval;
7425         int to_trn = 0;
7426         int to_trn_tbl[SGL_MAX_NO];
7427         int segs = 1;
7428         unsigned int trn_data = 0;
7429         uint8_t *plaintext, *ciphertext, *auth_tag;
7430
7431         if (fragsz > tdata->plaintext.len)
7432                 fragsz = tdata->plaintext.len;
7433
7434         uint16_t plaintext_len = fragsz;
7435         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
7436
7437         if (fragsz_oop > tdata->plaintext.len)
7438                 frag_size_oop = tdata->plaintext.len;
7439
7440         int ecx = 0;
7441         void *digest_mem = NULL;
7442
7443         uint32_t prepend_len = ALIGN_POW2_ROUNDUP(tdata->iv.len, 16)
7444                         + tdata->aad.len;
7445
7446         if (tdata->plaintext.len % fragsz != 0) {
7447                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
7448                         return 1;
7449         }       else {
7450                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
7451                         return 1;
7452         }
7453
7454         /*
7455          * For out-op-place we need to alloc another mbuf
7456          */
7457         if (oop) {
7458                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7459                 rte_pktmbuf_append(ut_params->obuf,
7460                                 frag_size_oop + prepend_len);
7461                 buf_oop = ut_params->obuf;
7462         }
7463
7464         /* Create GCM session */
7465         retval = create_gcm_session(ts_params->valid_devs[0],
7466                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7467                         tdata->key.data, tdata->key.len,
7468                         tdata->aad.len, tdata->auth_tag.len,
7469                         RTE_CRYPTO_AUTH_OP_GENERATE);
7470         if (retval < 0)
7471                 return retval;
7472
7473         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7474
7475         /* clear mbuf payload */
7476         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7477                         rte_pktmbuf_tailroom(ut_params->ibuf));
7478
7479         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7480                         plaintext_len);
7481
7482         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7483
7484         trn_data += plaintext_len;
7485
7486         buf = ut_params->ibuf;
7487
7488         /*
7489          * Loop until no more fragments
7490          */
7491
7492         while (trn_data < tdata->plaintext.len) {
7493                 ++segs;
7494                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
7495                                 (tdata->plaintext.len - trn_data) : fragsz;
7496
7497                 to_trn_tbl[ecx++] = to_trn;
7498
7499                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7500                 buf = buf->next;
7501
7502                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
7503                                 rte_pktmbuf_tailroom(buf));
7504
7505                 /* OOP */
7506                 if (oop && !fragsz_oop) {
7507                         buf_last_oop = buf_oop->next =
7508                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
7509                         buf_oop = buf_oop->next;
7510                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7511                                         0, rte_pktmbuf_tailroom(buf_oop));
7512                         rte_pktmbuf_append(buf_oop, to_trn);
7513                 }
7514
7515                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
7516                                 to_trn);
7517
7518                 memcpy(plaintext, tdata->plaintext.data + trn_data,
7519                                 to_trn);
7520                 trn_data += to_trn;
7521                 if (trn_data  == tdata->plaintext.len) {
7522                         if (oop) {
7523                                 if (!fragsz_oop)
7524                                         digest_mem = rte_pktmbuf_append(buf_oop,
7525                                                 tdata->auth_tag.len);
7526                         } else
7527                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
7528                                         tdata->auth_tag.len);
7529                 }
7530         }
7531
7532         uint64_t digest_phys = 0;
7533
7534         ut_params->ibuf->nb_segs = segs;
7535
7536         segs = 1;
7537         if (fragsz_oop && oop) {
7538                 to_trn = 0;
7539                 ecx = 0;
7540
7541                 if (frag_size_oop == tdata->plaintext.len) {
7542                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
7543                                 tdata->auth_tag.len);
7544
7545                         digest_phys = rte_pktmbuf_mtophys_offset(
7546                                         ut_params->obuf,
7547                                         tdata->plaintext.len + prepend_len);
7548                 }
7549
7550                 trn_data = frag_size_oop;
7551                 while (trn_data < tdata->plaintext.len) {
7552                         ++segs;
7553                         to_trn =
7554                                 (tdata->plaintext.len - trn_data <
7555                                                 frag_size_oop) ?
7556                                 (tdata->plaintext.len - trn_data) :
7557                                                 frag_size_oop;
7558
7559                         to_trn_tbl[ecx++] = to_trn;
7560
7561                         buf_last_oop = buf_oop->next =
7562                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
7563                         buf_oop = buf_oop->next;
7564                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7565                                         0, rte_pktmbuf_tailroom(buf_oop));
7566                         rte_pktmbuf_append(buf_oop, to_trn);
7567
7568                         trn_data += to_trn;
7569
7570                         if (trn_data  == tdata->plaintext.len) {
7571                                 digest_mem = rte_pktmbuf_append(buf_oop,
7572                                         tdata->auth_tag.len);
7573                         }
7574                 }
7575
7576                 ut_params->obuf->nb_segs = segs;
7577         }
7578
7579         /*
7580          * Place digest at the end of the last buffer
7581          */
7582         if (!digest_phys)
7583                 digest_phys = rte_pktmbuf_mtophys(buf) + to_trn;
7584         if (oop && buf_last_oop)
7585                 digest_phys = rte_pktmbuf_mtophys(buf_last_oop) + to_trn;
7586
7587         if (!digest_mem && !oop) {
7588                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7589                                 + tdata->auth_tag.len);
7590                 digest_phys = rte_pktmbuf_mtophys_offset(ut_params->ibuf,
7591                                 tdata->plaintext.len);
7592         }
7593
7594         /* Create GCM opertaion */
7595         retval = create_gcm_operation_SGL(RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7596                         tdata, digest_mem, digest_phys);
7597
7598         if (retval < 0)
7599                 return retval;
7600
7601         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7602
7603         ut_params->op->sym->m_src = ut_params->ibuf;
7604         if (oop)
7605                 ut_params->op->sym->m_dst = ut_params->obuf;
7606
7607         /* Process crypto operation */
7608         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7609                         ut_params->op), "failed to process sym crypto op");
7610
7611         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7612                         "crypto op processing failed");
7613
7614
7615         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7616                         uint8_t *, prepend_len);
7617         if (oop) {
7618                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7619                                 uint8_t *, prepend_len);
7620         }
7621
7622         if (fragsz_oop)
7623                 fragsz = fragsz_oop;
7624
7625         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7626                         ciphertext,
7627                         tdata->ciphertext.data,
7628                         fragsz,
7629                         "GCM Ciphertext data not as expected");
7630
7631         buf = ut_params->op->sym->m_src->next;
7632         if (oop)
7633                 buf = ut_params->op->sym->m_dst->next;
7634
7635         unsigned int off = fragsz;
7636
7637         ecx = 0;
7638         while (buf) {
7639                 ciphertext = rte_pktmbuf_mtod(buf,
7640                                 uint8_t *);
7641
7642                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7643                                 ciphertext,
7644                                 tdata->ciphertext.data + off,
7645                                 to_trn_tbl[ecx],
7646                                 "GCM Ciphertext data not as expected");
7647
7648                 off += to_trn_tbl[ecx++];
7649                 buf = buf->next;
7650         }
7651
7652         auth_tag = digest_mem;
7653         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7654                         auth_tag,
7655                         tdata->auth_tag.data,
7656                         tdata->auth_tag.len,
7657                         "GCM Generated auth tag not as expected");
7658
7659         return 0;
7660 }
7661
7662 #define IN_PLACE        0
7663 #define OUT_OF_PLACE    1
7664
7665 static int
7666 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
7667 {
7668         return test_AES_GCM_authenticated_encryption_SGL(
7669                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
7670 }
7671
7672 static int
7673 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
7674 {
7675         return test_AES_GCM_authenticated_encryption_SGL(
7676                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
7677 }
7678
7679 static int
7680 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
7681 {
7682         return test_AES_GCM_authenticated_encryption_SGL(
7683                         &gcm_test_case_8, OUT_OF_PLACE, 400,
7684                         gcm_test_case_8.plaintext.len);
7685 }
7686
7687 static int
7688 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
7689 {
7690
7691         return test_AES_GCM_authenticated_encryption_SGL(
7692                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
7693 }
7694
7695 static int
7696 test_authentication_verify_fail_when_data_corrupted(
7697                 struct crypto_testsuite_params *ts_params,
7698                 struct crypto_unittest_params *ut_params,
7699                 const struct test_crypto_vector *reference)
7700 {
7701         return test_authentication_verify_fail_when_data_corruption(
7702                         ts_params, ut_params, reference, 1);
7703 }
7704
7705 static int
7706 test_authentication_verify_fail_when_tag_corrupted(
7707                 struct crypto_testsuite_params *ts_params,
7708                 struct crypto_unittest_params *ut_params,
7709                 const struct test_crypto_vector *reference)
7710 {
7711         return test_authentication_verify_fail_when_data_corruption(
7712                         ts_params, ut_params, reference, 0);
7713 }
7714
7715 static int
7716 test_authentication_verify_GMAC_fail_when_data_corrupted(
7717                 struct crypto_testsuite_params *ts_params,
7718                 struct crypto_unittest_params *ut_params,
7719                 const struct test_crypto_vector *reference)
7720 {
7721         return test_authentication_verify_GMAC_fail_when_corruption(
7722                         ts_params, ut_params, reference, 1);
7723 }
7724
7725 static int
7726 test_authentication_verify_GMAC_fail_when_tag_corrupted(
7727                 struct crypto_testsuite_params *ts_params,
7728                 struct crypto_unittest_params *ut_params,
7729                 const struct test_crypto_vector *reference)
7730 {
7731         return test_authentication_verify_GMAC_fail_when_corruption(
7732                         ts_params, ut_params, reference, 0);
7733 }
7734
7735 static int
7736 test_authenticated_decryption_fail_when_data_corrupted(
7737                 struct crypto_testsuite_params *ts_params,
7738                 struct crypto_unittest_params *ut_params,
7739                 const struct test_crypto_vector *reference)
7740 {
7741         return test_authenticated_decryption_fail_when_corruption(
7742                         ts_params, ut_params, reference, 1);
7743 }
7744
7745 static int
7746 test_authenticated_decryption_fail_when_tag_corrupted(
7747                 struct crypto_testsuite_params *ts_params,
7748                 struct crypto_unittest_params *ut_params,
7749                 const struct test_crypto_vector *reference)
7750 {
7751         return test_authenticated_decryption_fail_when_corruption(
7752                         ts_params, ut_params, reference, 0);
7753 }
7754
7755 static int
7756 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
7757 {
7758         return test_authentication_verify_fail_when_data_corrupted(
7759                         &testsuite_params, &unittest_params,
7760                         &hmac_sha1_test_crypto_vector);
7761 }
7762
7763 static int
7764 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
7765 {
7766         return test_authentication_verify_fail_when_tag_corrupted(
7767                         &testsuite_params, &unittest_params,
7768                         &hmac_sha1_test_crypto_vector);
7769 }
7770
7771 static int
7772 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
7773 {
7774         return test_authentication_verify_GMAC_fail_when_data_corrupted(
7775                         &testsuite_params, &unittest_params,
7776                         &aes128_gmac_test_vector);
7777 }
7778
7779 static int
7780 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
7781 {
7782         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
7783                         &testsuite_params, &unittest_params,
7784                         &aes128_gmac_test_vector);
7785 }
7786
7787 static int
7788 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
7789 {
7790         return test_authenticated_decryption_fail_when_data_corrupted(
7791                         &testsuite_params,
7792                         &unittest_params,
7793                         &aes128cbc_hmac_sha1_test_vector);
7794 }
7795
7796 static int
7797 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
7798 {
7799         return test_authenticated_decryption_fail_when_tag_corrupted(
7800                         &testsuite_params,
7801                         &unittest_params,
7802                         &aes128cbc_hmac_sha1_test_vector);
7803 }
7804
7805 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
7806
7807 /* global AESNI slave IDs for the scheduler test */
7808 uint8_t aesni_ids[2];
7809
7810 static int
7811 test_scheduler_attach_slave_op(void)
7812 {
7813         struct crypto_testsuite_params *ts_params = &testsuite_params;
7814         uint8_t sched_id = ts_params->valid_devs[0];
7815         uint32_t nb_devs, i, nb_devs_attached = 0;
7816         int ret;
7817         char vdev_name[32];
7818
7819         /* create 2 AESNI_MB if necessary */
7820         nb_devs = rte_cryptodev_count_devtype(
7821                         RTE_CRYPTODEV_AESNI_MB_PMD);
7822         if (nb_devs < 2) {
7823                 for (i = nb_devs; i < 2; i++) {
7824                         snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
7825                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
7826                                         i);
7827                         ret = rte_vdev_init(vdev_name, NULL);
7828
7829                         TEST_ASSERT(ret == 0,
7830                                 "Failed to create instance %u of"
7831                                 " pmd : %s",
7832                                 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
7833                 }
7834         }
7835
7836         /* attach 2 AESNI_MB cdevs */
7837         for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
7838                         i++) {
7839                 struct rte_cryptodev_info info;
7840
7841                 rte_cryptodev_info_get(i, &info);
7842                 if (info.dev_type != RTE_CRYPTODEV_AESNI_MB_PMD)
7843                         continue;
7844
7845                 ret = rte_cryptodev_scheduler_slave_attach(sched_id,
7846                                 (uint8_t)i);
7847
7848                 TEST_ASSERT(ret == 0,
7849                         "Failed to attach device %u of pmd : %s", i,
7850                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
7851
7852                 aesni_ids[nb_devs_attached] = (uint8_t)i;
7853
7854                 nb_devs_attached++;
7855         }
7856
7857         return 0;
7858 }
7859
7860 static int
7861 test_scheduler_detach_slave_op(void)
7862 {
7863         struct crypto_testsuite_params *ts_params = &testsuite_params;
7864         uint8_t sched_id = ts_params->valid_devs[0];
7865         uint32_t i;
7866         int ret;
7867
7868         for (i = 0; i < 2; i++) {
7869                 ret = rte_cryptodev_scheduler_slave_detach(sched_id,
7870                                 aesni_ids[i]);
7871                 TEST_ASSERT(ret == 0,
7872                         "Failed to detach device %u", aesni_ids[i]);
7873         }
7874
7875         return 0;
7876 }
7877
7878 static int
7879 test_scheduler_mode_op(void)
7880 {
7881         struct crypto_testsuite_params *ts_params = &testsuite_params;
7882         uint8_t sched_id = ts_params->valid_devs[0];
7883         struct rte_cryptodev_scheduler_ops op = {0};
7884         struct rte_cryptodev_scheduler dummy_scheduler = {
7885                 .description = "dummy scheduler to test mode",
7886                 .name = "dummy scheduler",
7887                 .mode = CDEV_SCHED_MODE_USERDEFINED,
7888                 .ops = &op
7889         };
7890         int ret;
7891
7892         /* set user defined mode */
7893         ret = rte_cryptodev_scheduler_load_user_scheduler(sched_id,
7894                         &dummy_scheduler);
7895         TEST_ASSERT(ret == 0,
7896                 "Failed to set cdev %u to user defined mode", sched_id);
7897
7898         /* set round robin mode */
7899         ret = rte_cryptodev_scheduler_mode_set(sched_id,
7900                         CDEV_SCHED_MODE_ROUNDROBIN);
7901         TEST_ASSERT(ret == 0,
7902                 "Failed to set cdev %u to round-robin mode", sched_id);
7903         TEST_ASSERT(rte_cryptodev_scheduler_mode_get(sched_id) ==
7904                         CDEV_SCHED_MODE_ROUNDROBIN, "Scheduling Mode "
7905                                         "not match");
7906
7907         return 0;
7908 }
7909
7910 static struct unit_test_suite cryptodev_scheduler_testsuite  = {
7911         .suite_name = "Crypto Device Scheduler Unit Test Suite",
7912         .setup = testsuite_setup,
7913         .teardown = testsuite_teardown,
7914         .unit_test_cases = {
7915                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
7916                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_op),
7917                 TEST_CASE_ST(ut_setup, ut_teardown,
7918                                 test_AES_chain_scheduler_all),
7919                 TEST_CASE_ST(ut_setup, ut_teardown,
7920                                 test_AES_cipheronly_scheduler_all),
7921                 TEST_CASE_ST(ut_setup, ut_teardown,
7922                                 test_authonly_scheduler_all),
7923                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
7924                 TEST_CASES_END() /**< NULL terminate unit test array */
7925         }
7926 };
7927
7928 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
7929
7930 static struct unit_test_suite cryptodev_qat_testsuite  = {
7931         .suite_name = "Crypto QAT Unit Test Suite",
7932         .setup = testsuite_setup,
7933         .teardown = testsuite_teardown,
7934         .unit_test_cases = {
7935                 TEST_CASE_ST(ut_setup, ut_teardown,
7936                                 test_device_configure_invalid_dev_id),
7937                 TEST_CASE_ST(ut_setup, ut_teardown,
7938                                 test_device_configure_invalid_queue_pair_ids),
7939                 TEST_CASE_ST(ut_setup, ut_teardown,
7940                                 test_queue_pair_descriptor_setup),
7941                 TEST_CASE_ST(ut_setup, ut_teardown,
7942                                 test_multi_session),
7943
7944                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
7945                 TEST_CASE_ST(ut_setup, ut_teardown,
7946                                                 test_AES_cipheronly_qat_all),
7947                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
7948                 TEST_CASE_ST(ut_setup, ut_teardown,
7949                                                 test_3DES_cipheronly_qat_all),
7950                 TEST_CASE_ST(ut_setup, ut_teardown,
7951                                                 test_DES_cipheronly_qat_all),
7952                 TEST_CASE_ST(ut_setup, ut_teardown,
7953                                                 test_AES_docsis_qat_all),
7954                 TEST_CASE_ST(ut_setup, ut_teardown,
7955                                                 test_DES_docsis_qat_all),
7956                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
7957
7958                 /** AES GCM Authenticated Encryption */
7959                 TEST_CASE_ST(ut_setup, ut_teardown,
7960                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
7961                 TEST_CASE_ST(ut_setup, ut_teardown,
7962                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
7963                 TEST_CASE_ST(ut_setup, ut_teardown,
7964                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
7965                 TEST_CASE_ST(ut_setup, ut_teardown,
7966                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
7967                 TEST_CASE_ST(ut_setup, ut_teardown,
7968                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
7969                 TEST_CASE_ST(ut_setup, ut_teardown,
7970                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
7971                 TEST_CASE_ST(ut_setup, ut_teardown,
7972                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
7973                 TEST_CASE_ST(ut_setup, ut_teardown,
7974                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
7975                 TEST_CASE_ST(ut_setup, ut_teardown,
7976                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
7977                 TEST_CASE_ST(ut_setup, ut_teardown,
7978                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
7979
7980                 /** AES GCM Authenticated Decryption */
7981                 TEST_CASE_ST(ut_setup, ut_teardown,
7982                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
7983                 TEST_CASE_ST(ut_setup, ut_teardown,
7984                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
7985                 TEST_CASE_ST(ut_setup, ut_teardown,
7986                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
7987                 TEST_CASE_ST(ut_setup, ut_teardown,
7988                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
7989                 TEST_CASE_ST(ut_setup, ut_teardown,
7990                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
7991                 TEST_CASE_ST(ut_setup, ut_teardown,
7992                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
7993                 TEST_CASE_ST(ut_setup, ut_teardown,
7994                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
7995
7996                 /** AES GMAC Authentication */
7997                 TEST_CASE_ST(ut_setup, ut_teardown,
7998                         test_AES_GMAC_authentication_test_case_1),
7999                 TEST_CASE_ST(ut_setup, ut_teardown,
8000                         test_AES_GMAC_authentication_verify_test_case_1),
8001                 TEST_CASE_ST(ut_setup, ut_teardown,
8002                         test_AES_GMAC_authentication_test_case_2),
8003                 TEST_CASE_ST(ut_setup, ut_teardown,
8004                         test_AES_GMAC_authentication_verify_test_case_2),
8005                 TEST_CASE_ST(ut_setup, ut_teardown,
8006                         test_AES_GMAC_authentication_test_case_3),
8007                 TEST_CASE_ST(ut_setup, ut_teardown,
8008                         test_AES_GMAC_authentication_verify_test_case_3),
8009
8010                 /** SNOW 3G encrypt only (UEA2) */
8011                 TEST_CASE_ST(ut_setup, ut_teardown,
8012                         test_snow3g_encryption_test_case_1),
8013                 TEST_CASE_ST(ut_setup, ut_teardown,
8014                         test_snow3g_encryption_test_case_2),
8015                 TEST_CASE_ST(ut_setup, ut_teardown,
8016                         test_snow3g_encryption_test_case_3),
8017                 TEST_CASE_ST(ut_setup, ut_teardown,
8018                         test_snow3g_encryption_test_case_4),
8019                 TEST_CASE_ST(ut_setup, ut_teardown,
8020                         test_snow3g_encryption_test_case_5),
8021
8022                 TEST_CASE_ST(ut_setup, ut_teardown,
8023                         test_snow3g_encryption_test_case_1_oop),
8024                 TEST_CASE_ST(ut_setup, ut_teardown,
8025                         test_snow3g_decryption_test_case_1_oop),
8026
8027                 /** SNOW 3G decrypt only (UEA2) */
8028                 TEST_CASE_ST(ut_setup, ut_teardown,
8029                         test_snow3g_decryption_test_case_1),
8030                 TEST_CASE_ST(ut_setup, ut_teardown,
8031                         test_snow3g_decryption_test_case_2),
8032                 TEST_CASE_ST(ut_setup, ut_teardown,
8033                         test_snow3g_decryption_test_case_3),
8034                 TEST_CASE_ST(ut_setup, ut_teardown,
8035                         test_snow3g_decryption_test_case_4),
8036                 TEST_CASE_ST(ut_setup, ut_teardown,
8037                         test_snow3g_decryption_test_case_5),
8038                 TEST_CASE_ST(ut_setup, ut_teardown,
8039                         test_snow3g_hash_generate_test_case_1),
8040                 TEST_CASE_ST(ut_setup, ut_teardown,
8041                         test_snow3g_hash_generate_test_case_2),
8042                 TEST_CASE_ST(ut_setup, ut_teardown,
8043                         test_snow3g_hash_generate_test_case_3),
8044                 TEST_CASE_ST(ut_setup, ut_teardown,
8045                         test_snow3g_hash_verify_test_case_1),
8046                 TEST_CASE_ST(ut_setup, ut_teardown,
8047                         test_snow3g_hash_verify_test_case_2),
8048                 TEST_CASE_ST(ut_setup, ut_teardown,
8049                         test_snow3g_hash_verify_test_case_3),
8050                 TEST_CASE_ST(ut_setup, ut_teardown,
8051                         test_snow3g_cipher_auth_test_case_1),
8052                 TEST_CASE_ST(ut_setup, ut_teardown,
8053                         test_snow3g_auth_cipher_test_case_1),
8054
8055                 /** ZUC encrypt only (EEA3) */
8056                 TEST_CASE_ST(ut_setup, ut_teardown,
8057                         test_zuc_encryption_test_case_1),
8058                 TEST_CASE_ST(ut_setup, ut_teardown,
8059                         test_zuc_encryption_test_case_2),
8060                 TEST_CASE_ST(ut_setup, ut_teardown,
8061                         test_zuc_encryption_test_case_3),
8062                 TEST_CASE_ST(ut_setup, ut_teardown,
8063                         test_zuc_encryption_test_case_4),
8064                 TEST_CASE_ST(ut_setup, ut_teardown,
8065                         test_zuc_encryption_test_case_5),
8066
8067                 /** ZUC authenticate (EIA3) */
8068                 TEST_CASE_ST(ut_setup, ut_teardown,
8069                         test_zuc_hash_generate_test_case_6),
8070                 TEST_CASE_ST(ut_setup, ut_teardown,
8071                         test_zuc_hash_generate_test_case_7),
8072                 TEST_CASE_ST(ut_setup, ut_teardown,
8073                         test_zuc_hash_generate_test_case_8),
8074
8075                 /** ZUC alg-chain (EEA3/EIA3) */
8076                 TEST_CASE_ST(ut_setup, ut_teardown,
8077                         test_zuc_cipher_auth_test_case_1),
8078                 TEST_CASE_ST(ut_setup, ut_teardown,
8079                         test_zuc_cipher_auth_test_case_2),
8080
8081                 /** HMAC_MD5 Authentication */
8082                 TEST_CASE_ST(ut_setup, ut_teardown,
8083                         test_MD5_HMAC_generate_case_1),
8084                 TEST_CASE_ST(ut_setup, ut_teardown,
8085                         test_MD5_HMAC_verify_case_1),
8086                 TEST_CASE_ST(ut_setup, ut_teardown,
8087                         test_MD5_HMAC_generate_case_2),
8088                 TEST_CASE_ST(ut_setup, ut_teardown,
8089                         test_MD5_HMAC_verify_case_2),
8090
8091                 /** NULL tests */
8092                 TEST_CASE_ST(ut_setup, ut_teardown,
8093                         test_null_auth_only_operation),
8094                 TEST_CASE_ST(ut_setup, ut_teardown,
8095                         test_null_cipher_only_operation),
8096                 TEST_CASE_ST(ut_setup, ut_teardown,
8097                         test_null_cipher_auth_operation),
8098                 TEST_CASE_ST(ut_setup, ut_teardown,
8099                         test_null_auth_cipher_operation),
8100
8101                 TEST_CASE_ST(ut_setup, ut_teardown,
8102                         test_kasumi_hash_generate_test_case_6),
8103
8104                 /** KASUMI tests */
8105                 TEST_CASE_ST(ut_setup, ut_teardown,
8106                         test_kasumi_encryption_test_case_1),
8107                 TEST_CASE_ST(ut_setup, ut_teardown,
8108                         test_kasumi_encryption_test_case_3),
8109                 TEST_CASE_ST(ut_setup, ut_teardown,
8110                         test_kasumi_auth_cipher_test_case_1),
8111                 TEST_CASE_ST(ut_setup, ut_teardown,
8112                         test_kasumi_cipher_auth_test_case_1),
8113
8114                 /** Negative tests */
8115                 TEST_CASE_ST(ut_setup, ut_teardown,
8116                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
8117                 TEST_CASE_ST(ut_setup, ut_teardown,
8118                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
8119                 TEST_CASE_ST(ut_setup, ut_teardown,
8120                         authentication_verify_AES128_GMAC_fail_data_corrupt),
8121                 TEST_CASE_ST(ut_setup, ut_teardown,
8122                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
8123                 TEST_CASE_ST(ut_setup, ut_teardown,
8124                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8125                 TEST_CASE_ST(ut_setup, ut_teardown,
8126                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8127
8128                 TEST_CASES_END() /**< NULL terminate unit test array */
8129         }
8130 };
8131
8132 static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
8133         .suite_name = "Crypto Device AESNI MB Unit Test Suite",
8134         .setup = testsuite_setup,
8135         .teardown = testsuite_teardown,
8136         .unit_test_cases = {
8137                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
8138                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all),
8139                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all),
8140                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all),
8141
8142                 TEST_CASES_END() /**< NULL terminate unit test array */
8143         }
8144 };
8145
8146 static struct unit_test_suite cryptodev_openssl_testsuite  = {
8147         .suite_name = "Crypto Device OPENSSL Unit Test Suite",
8148         .setup = testsuite_setup,
8149         .teardown = testsuite_teardown,
8150         .unit_test_cases = {
8151                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
8152                 TEST_CASE_ST(ut_setup, ut_teardown,
8153                                 test_multi_session_random_usage),
8154                 TEST_CASE_ST(ut_setup, ut_teardown,
8155                                 test_AES_chain_openssl_all),
8156                 TEST_CASE_ST(ut_setup, ut_teardown,
8157                                 test_AES_cipheronly_openssl_all),
8158                 TEST_CASE_ST(ut_setup, ut_teardown,
8159                                 test_3DES_chain_openssl_all),
8160                 TEST_CASE_ST(ut_setup, ut_teardown,
8161                                 test_3DES_cipheronly_openssl_all),
8162                 TEST_CASE_ST(ut_setup, ut_teardown,
8163                                 test_DES_docsis_openssl_all),
8164                 TEST_CASE_ST(ut_setup, ut_teardown,
8165                                 test_authonly_openssl_all),
8166
8167                 /** AES GCM Authenticated Encryption */
8168                 TEST_CASE_ST(ut_setup, ut_teardown,
8169                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
8170                 TEST_CASE_ST(ut_setup, ut_teardown,
8171                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
8172                 TEST_CASE_ST(ut_setup, ut_teardown,
8173                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
8174                 TEST_CASE_ST(ut_setup, ut_teardown,
8175                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
8176                 TEST_CASE_ST(ut_setup, ut_teardown,
8177                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
8178                 TEST_CASE_ST(ut_setup, ut_teardown,
8179                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
8180                 TEST_CASE_ST(ut_setup, ut_teardown,
8181                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
8182
8183                 /** AES GCM Authenticated Decryption */
8184                 TEST_CASE_ST(ut_setup, ut_teardown,
8185                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
8186                 TEST_CASE_ST(ut_setup, ut_teardown,
8187                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
8188                 TEST_CASE_ST(ut_setup, ut_teardown,
8189                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
8190                 TEST_CASE_ST(ut_setup, ut_teardown,
8191                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
8192                 TEST_CASE_ST(ut_setup, ut_teardown,
8193                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
8194                 TEST_CASE_ST(ut_setup, ut_teardown,
8195                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
8196                 TEST_CASE_ST(ut_setup, ut_teardown,
8197                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
8198
8199                 /** AES GMAC Authentication */
8200                 TEST_CASE_ST(ut_setup, ut_teardown,
8201                         test_AES_GMAC_authentication_test_case_1),
8202                 TEST_CASE_ST(ut_setup, ut_teardown,
8203                         test_AES_GMAC_authentication_verify_test_case_1),
8204                 TEST_CASE_ST(ut_setup, ut_teardown,
8205                         test_AES_GMAC_authentication_test_case_2),
8206                 TEST_CASE_ST(ut_setup, ut_teardown,
8207                         test_AES_GMAC_authentication_verify_test_case_2),
8208                 TEST_CASE_ST(ut_setup, ut_teardown,
8209                         test_AES_GMAC_authentication_test_case_3),
8210                 TEST_CASE_ST(ut_setup, ut_teardown,
8211                         test_AES_GMAC_authentication_verify_test_case_3),
8212                 TEST_CASE_ST(ut_setup, ut_teardown,
8213                         test_AES_GMAC_authentication_test_case_4),
8214                 TEST_CASE_ST(ut_setup, ut_teardown,
8215                         test_AES_GMAC_authentication_verify_test_case_4),
8216
8217                 /** Scatter-Gather */
8218                 TEST_CASE_ST(ut_setup, ut_teardown,
8219                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
8220
8221                 /** Negative tests */
8222                 TEST_CASE_ST(ut_setup, ut_teardown,
8223                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
8224                 TEST_CASE_ST(ut_setup, ut_teardown,
8225                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
8226                 TEST_CASE_ST(ut_setup, ut_teardown,
8227                         authentication_verify_AES128_GMAC_fail_data_corrupt),
8228                 TEST_CASE_ST(ut_setup, ut_teardown,
8229                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
8230                 TEST_CASE_ST(ut_setup, ut_teardown,
8231                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8232                 TEST_CASE_ST(ut_setup, ut_teardown,
8233                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8234
8235                 TEST_CASES_END() /**< NULL terminate unit test array */
8236         }
8237 };
8238
8239 static struct unit_test_suite cryptodev_aesni_gcm_testsuite  = {
8240         .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
8241         .setup = testsuite_setup,
8242         .teardown = testsuite_teardown,
8243         .unit_test_cases = {
8244                 /** AES GCM Authenticated Encryption */
8245                 TEST_CASE_ST(ut_setup, ut_teardown,
8246                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
8247                 TEST_CASE_ST(ut_setup, ut_teardown,
8248                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
8249                 TEST_CASE_ST(ut_setup, ut_teardown,
8250                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
8251                 TEST_CASE_ST(ut_setup, ut_teardown,
8252                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
8253                 TEST_CASE_ST(ut_setup, ut_teardown,
8254                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
8255                 TEST_CASE_ST(ut_setup, ut_teardown,
8256                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
8257                 TEST_CASE_ST(ut_setup, ut_teardown,
8258                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
8259
8260                 /** AES GCM Authenticated Decryption */
8261                 TEST_CASE_ST(ut_setup, ut_teardown,
8262                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
8263                 TEST_CASE_ST(ut_setup, ut_teardown,
8264                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
8265                 TEST_CASE_ST(ut_setup, ut_teardown,
8266                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
8267                 TEST_CASE_ST(ut_setup, ut_teardown,
8268                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
8269                 TEST_CASE_ST(ut_setup, ut_teardown,
8270                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
8271                 TEST_CASE_ST(ut_setup, ut_teardown,
8272                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
8273                 TEST_CASE_ST(ut_setup, ut_teardown,
8274                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
8275
8276                 /** AES GCM Authenticated Encryption 256 bits key */
8277                 TEST_CASE_ST(ut_setup, ut_teardown,
8278                         test_mb_AES_GCM_auth_encryption_test_case_256_1),
8279                 TEST_CASE_ST(ut_setup, ut_teardown,
8280                         test_mb_AES_GCM_auth_encryption_test_case_256_2),
8281                 TEST_CASE_ST(ut_setup, ut_teardown,
8282                         test_mb_AES_GCM_auth_encryption_test_case_256_3),
8283                 TEST_CASE_ST(ut_setup, ut_teardown,
8284                         test_mb_AES_GCM_auth_encryption_test_case_256_4),
8285                 TEST_CASE_ST(ut_setup, ut_teardown,
8286                         test_mb_AES_GCM_auth_encryption_test_case_256_5),
8287                 TEST_CASE_ST(ut_setup, ut_teardown,
8288                         test_mb_AES_GCM_auth_encryption_test_case_256_6),
8289                 TEST_CASE_ST(ut_setup, ut_teardown,
8290                         test_mb_AES_GCM_auth_encryption_test_case_256_7),
8291
8292                 /** AES GCM Authenticated Decryption 256 bits key */
8293                 TEST_CASE_ST(ut_setup, ut_teardown,
8294                         test_mb_AES_GCM_auth_decryption_test_case_256_1),
8295                 TEST_CASE_ST(ut_setup, ut_teardown,
8296                         test_mb_AES_GCM_auth_decryption_test_case_256_2),
8297                 TEST_CASE_ST(ut_setup, ut_teardown,
8298                         test_mb_AES_GCM_auth_decryption_test_case_256_3),
8299                 TEST_CASE_ST(ut_setup, ut_teardown,
8300                         test_mb_AES_GCM_auth_decryption_test_case_256_4),
8301                 TEST_CASE_ST(ut_setup, ut_teardown,
8302                         test_mb_AES_GCM_auth_decryption_test_case_256_5),
8303                 TEST_CASE_ST(ut_setup, ut_teardown,
8304                         test_mb_AES_GCM_auth_decryption_test_case_256_6),
8305                 TEST_CASE_ST(ut_setup, ut_teardown,
8306                         test_mb_AES_GCM_auth_decryption_test_case_256_7),
8307
8308                 /** AES GCM Authenticated Encryption big aad size */
8309                 TEST_CASE_ST(ut_setup, ut_teardown,
8310                         test_mb_AES_GCM_auth_encryption_test_case_aad_1),
8311                 TEST_CASE_ST(ut_setup, ut_teardown,
8312                         test_mb_AES_GCM_auth_encryption_test_case_aad_2),
8313
8314                 /** AES GCM Authenticated Decryption big aad size */
8315                 TEST_CASE_ST(ut_setup, ut_teardown,
8316                         test_mb_AES_GCM_auth_decryption_test_case_aad_1),
8317                 TEST_CASE_ST(ut_setup, ut_teardown,
8318                         test_mb_AES_GCM_auth_decryption_test_case_aad_2),
8319
8320                 /** AES GMAC Authentication */
8321                 TEST_CASE_ST(ut_setup, ut_teardown,
8322                         test_AES_GMAC_authentication_test_case_1),
8323                 TEST_CASE_ST(ut_setup, ut_teardown,
8324                         test_AES_GMAC_authentication_verify_test_case_1),
8325                 TEST_CASE_ST(ut_setup, ut_teardown,
8326                         test_AES_GMAC_authentication_test_case_3),
8327                 TEST_CASE_ST(ut_setup, ut_teardown,
8328                         test_AES_GMAC_authentication_verify_test_case_3),
8329                 TEST_CASE_ST(ut_setup, ut_teardown,
8330                         test_AES_GMAC_authentication_test_case_4),
8331                 TEST_CASE_ST(ut_setup, ut_teardown,
8332                         test_AES_GMAC_authentication_verify_test_case_4),
8333
8334                 /** Negative tests */
8335                 TEST_CASE_ST(ut_setup, ut_teardown,
8336                         authentication_verify_AES128_GMAC_fail_data_corrupt),
8337                 TEST_CASE_ST(ut_setup, ut_teardown,
8338                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
8339
8340                 /** Out of place tests */
8341                 TEST_CASE_ST(ut_setup, ut_teardown,
8342                         test_mb_AES_GCM_authenticated_encryption_oop),
8343                 TEST_CASE_ST(ut_setup, ut_teardown,
8344                         test_mb_AES_GCM_authenticated_decryption_oop),
8345
8346                 /** Session-less tests */
8347                 TEST_CASE_ST(ut_setup, ut_teardown,
8348                         test_mb_AES_GCM_authenticated_encryption_sessionless),
8349                 TEST_CASE_ST(ut_setup, ut_teardown,
8350                         test_mb_AES_GCM_authenticated_decryption_sessionless),
8351
8352                 /** Scatter-Gather */
8353                 TEST_CASE_ST(ut_setup, ut_teardown,
8354                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
8355
8356                 TEST_CASES_END() /**< NULL terminate unit test array */
8357         }
8358 };
8359
8360 static struct unit_test_suite cryptodev_sw_kasumi_testsuite  = {
8361         .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
8362         .setup = testsuite_setup,
8363         .teardown = testsuite_teardown,
8364         .unit_test_cases = {
8365                 /** KASUMI encrypt only (UEA1) */
8366                 TEST_CASE_ST(ut_setup, ut_teardown,
8367                         test_kasumi_encryption_test_case_1),
8368                 TEST_CASE_ST(ut_setup, ut_teardown,
8369                         test_kasumi_encryption_test_case_1_sgl),
8370                 TEST_CASE_ST(ut_setup, ut_teardown,
8371                         test_kasumi_encryption_test_case_2),
8372                 TEST_CASE_ST(ut_setup, ut_teardown,
8373                         test_kasumi_encryption_test_case_3),
8374                 TEST_CASE_ST(ut_setup, ut_teardown,
8375                         test_kasumi_encryption_test_case_4),
8376                 TEST_CASE_ST(ut_setup, ut_teardown,
8377                         test_kasumi_encryption_test_case_5),
8378                 /** KASUMI decrypt only (UEA1) */
8379                 TEST_CASE_ST(ut_setup, ut_teardown,
8380                         test_kasumi_decryption_test_case_1),
8381                 TEST_CASE_ST(ut_setup, ut_teardown,
8382                         test_kasumi_decryption_test_case_2),
8383                 TEST_CASE_ST(ut_setup, ut_teardown,
8384                         test_kasumi_decryption_test_case_3),
8385                 TEST_CASE_ST(ut_setup, ut_teardown,
8386                         test_kasumi_decryption_test_case_4),
8387                 TEST_CASE_ST(ut_setup, ut_teardown,
8388                         test_kasumi_decryption_test_case_5),
8389
8390                 TEST_CASE_ST(ut_setup, ut_teardown,
8391                         test_kasumi_encryption_test_case_1_oop),
8392                 TEST_CASE_ST(ut_setup, ut_teardown,
8393                         test_kasumi_encryption_test_case_1_oop_sgl),
8394
8395
8396                 TEST_CASE_ST(ut_setup, ut_teardown,
8397                         test_kasumi_decryption_test_case_1_oop),
8398
8399                 /** KASUMI hash only (UIA1) */
8400                 TEST_CASE_ST(ut_setup, ut_teardown,
8401                         test_kasumi_hash_generate_test_case_1),
8402                 TEST_CASE_ST(ut_setup, ut_teardown,
8403                         test_kasumi_hash_generate_test_case_2),
8404                 TEST_CASE_ST(ut_setup, ut_teardown,
8405                         test_kasumi_hash_generate_test_case_3),
8406                 TEST_CASE_ST(ut_setup, ut_teardown,
8407                         test_kasumi_hash_generate_test_case_4),
8408                 TEST_CASE_ST(ut_setup, ut_teardown,
8409                         test_kasumi_hash_generate_test_case_5),
8410                 TEST_CASE_ST(ut_setup, ut_teardown,
8411                         test_kasumi_hash_generate_test_case_6),
8412                 TEST_CASE_ST(ut_setup, ut_teardown,
8413                         test_kasumi_hash_verify_test_case_1),
8414                 TEST_CASE_ST(ut_setup, ut_teardown,
8415                         test_kasumi_hash_verify_test_case_2),
8416                 TEST_CASE_ST(ut_setup, ut_teardown,
8417                         test_kasumi_hash_verify_test_case_3),
8418                 TEST_CASE_ST(ut_setup, ut_teardown,
8419                         test_kasumi_hash_verify_test_case_4),
8420                 TEST_CASE_ST(ut_setup, ut_teardown,
8421                         test_kasumi_hash_verify_test_case_5),
8422                 TEST_CASE_ST(ut_setup, ut_teardown,
8423                         test_kasumi_auth_cipher_test_case_1),
8424                 TEST_CASE_ST(ut_setup, ut_teardown,
8425                         test_kasumi_cipher_auth_test_case_1),
8426                 TEST_CASES_END() /**< NULL terminate unit test array */
8427         }
8428 };
8429 static struct unit_test_suite cryptodev_sw_snow3g_testsuite  = {
8430         .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
8431         .setup = testsuite_setup,
8432         .teardown = testsuite_teardown,
8433         .unit_test_cases = {
8434                 /** SNOW 3G encrypt only (UEA2) */
8435                 TEST_CASE_ST(ut_setup, ut_teardown,
8436                         test_snow3g_encryption_test_case_1),
8437                 TEST_CASE_ST(ut_setup, ut_teardown,
8438                         test_snow3g_encryption_test_case_2),
8439                 TEST_CASE_ST(ut_setup, ut_teardown,
8440                         test_snow3g_encryption_test_case_3),
8441                 TEST_CASE_ST(ut_setup, ut_teardown,
8442                         test_snow3g_encryption_test_case_4),
8443                 TEST_CASE_ST(ut_setup, ut_teardown,
8444                         test_snow3g_encryption_test_case_5),
8445
8446                 TEST_CASE_ST(ut_setup, ut_teardown,
8447                         test_snow3g_encryption_test_case_1_oop),
8448                 TEST_CASE_ST(ut_setup, ut_teardown,
8449                                 test_snow3g_encryption_test_case_1_oop_sgl),
8450                 TEST_CASE_ST(ut_setup, ut_teardown,
8451                         test_snow3g_decryption_test_case_1_oop),
8452
8453                 TEST_CASE_ST(ut_setup, ut_teardown,
8454                         test_snow3g_encryption_test_case_1_offset_oop),
8455
8456                 /** SNOW 3G decrypt only (UEA2) */
8457                 TEST_CASE_ST(ut_setup, ut_teardown,
8458                         test_snow3g_decryption_test_case_1),
8459                 TEST_CASE_ST(ut_setup, ut_teardown,
8460                         test_snow3g_decryption_test_case_2),
8461                 TEST_CASE_ST(ut_setup, ut_teardown,
8462                         test_snow3g_decryption_test_case_3),
8463                 TEST_CASE_ST(ut_setup, ut_teardown,
8464                         test_snow3g_decryption_test_case_4),
8465                 TEST_CASE_ST(ut_setup, ut_teardown,
8466                         test_snow3g_decryption_test_case_5),
8467                 TEST_CASE_ST(ut_setup, ut_teardown,
8468                         test_snow3g_hash_generate_test_case_1),
8469                 TEST_CASE_ST(ut_setup, ut_teardown,
8470                         test_snow3g_hash_generate_test_case_2),
8471                 TEST_CASE_ST(ut_setup, ut_teardown,
8472                         test_snow3g_hash_generate_test_case_3),
8473                 /* Tests with buffers which length is not byte-aligned */
8474                 TEST_CASE_ST(ut_setup, ut_teardown,
8475                         test_snow3g_hash_generate_test_case_4),
8476                 TEST_CASE_ST(ut_setup, ut_teardown,
8477                         test_snow3g_hash_generate_test_case_5),
8478                 TEST_CASE_ST(ut_setup, ut_teardown,
8479                         test_snow3g_hash_generate_test_case_6),
8480                 TEST_CASE_ST(ut_setup, ut_teardown,
8481                         test_snow3g_hash_verify_test_case_1),
8482                 TEST_CASE_ST(ut_setup, ut_teardown,
8483                         test_snow3g_hash_verify_test_case_2),
8484                 TEST_CASE_ST(ut_setup, ut_teardown,
8485                         test_snow3g_hash_verify_test_case_3),
8486                 /* Tests with buffers which length is not byte-aligned */
8487                 TEST_CASE_ST(ut_setup, ut_teardown,
8488                         test_snow3g_hash_verify_test_case_4),
8489                 TEST_CASE_ST(ut_setup, ut_teardown,
8490                         test_snow3g_hash_verify_test_case_5),
8491                 TEST_CASE_ST(ut_setup, ut_teardown,
8492                         test_snow3g_hash_verify_test_case_6),
8493                 TEST_CASE_ST(ut_setup, ut_teardown,
8494                         test_snow3g_cipher_auth_test_case_1),
8495                 TEST_CASE_ST(ut_setup, ut_teardown,
8496                         test_snow3g_auth_cipher_test_case_1),
8497
8498                 TEST_CASES_END() /**< NULL terminate unit test array */
8499         }
8500 };
8501
8502 static struct unit_test_suite cryptodev_sw_zuc_testsuite  = {
8503         .suite_name = "Crypto Device SW ZUC Unit Test Suite",
8504         .setup = testsuite_setup,
8505         .teardown = testsuite_teardown,
8506         .unit_test_cases = {
8507                 /** ZUC encrypt only (EEA3) */
8508                 TEST_CASE_ST(ut_setup, ut_teardown,
8509                         test_zuc_encryption_test_case_1),
8510                 TEST_CASE_ST(ut_setup, ut_teardown,
8511                         test_zuc_encryption_test_case_2),
8512                 TEST_CASE_ST(ut_setup, ut_teardown,
8513                         test_zuc_encryption_test_case_3),
8514                 TEST_CASE_ST(ut_setup, ut_teardown,
8515                         test_zuc_encryption_test_case_4),
8516                 TEST_CASE_ST(ut_setup, ut_teardown,
8517                         test_zuc_encryption_test_case_5),
8518                 TEST_CASE_ST(ut_setup, ut_teardown,
8519                         test_zuc_hash_generate_test_case_1),
8520                 TEST_CASE_ST(ut_setup, ut_teardown,
8521                         test_zuc_hash_generate_test_case_2),
8522                 TEST_CASE_ST(ut_setup, ut_teardown,
8523                         test_zuc_hash_generate_test_case_3),
8524                 TEST_CASE_ST(ut_setup, ut_teardown,
8525                         test_zuc_hash_generate_test_case_4),
8526                 TEST_CASE_ST(ut_setup, ut_teardown,
8527                         test_zuc_hash_generate_test_case_5),
8528                 TEST_CASE_ST(ut_setup, ut_teardown,
8529                         test_zuc_encryption_test_case_6_sgl),
8530                 TEST_CASES_END() /**< NULL terminate unit test array */
8531         }
8532 };
8533
8534 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite  = {
8535         .suite_name = "Crypto DPAA2_SEC Unit Test Suite",
8536         .setup = testsuite_setup,
8537         .teardown = testsuite_teardown,
8538         .unit_test_cases = {
8539                 TEST_CASE_ST(ut_setup, ut_teardown,
8540                              test_device_configure_invalid_dev_id),
8541                 TEST_CASE_ST(ut_setup, ut_teardown,
8542                              test_multi_session),
8543
8544                 TEST_CASE_ST(ut_setup, ut_teardown,
8545                              test_AES_chain_dpaa2_sec_all),
8546                 TEST_CASE_ST(ut_setup, ut_teardown,
8547                              test_3DES_chain_dpaa2_sec_all),
8548                 TEST_CASE_ST(ut_setup, ut_teardown,
8549                              test_AES_cipheronly_dpaa2_sec_all),
8550                 TEST_CASE_ST(ut_setup, ut_teardown,
8551                              test_3DES_cipheronly_dpaa2_sec_all),
8552
8553                 /** HMAC_MD5 Authentication */
8554                 TEST_CASE_ST(ut_setup, ut_teardown,
8555                              test_MD5_HMAC_generate_case_1),
8556                 TEST_CASE_ST(ut_setup, ut_teardown,
8557                              test_MD5_HMAC_verify_case_1),
8558                 TEST_CASE_ST(ut_setup, ut_teardown,
8559                              test_MD5_HMAC_generate_case_2),
8560                 TEST_CASE_ST(ut_setup, ut_teardown,
8561                              test_MD5_HMAC_verify_case_2),
8562
8563                 TEST_CASES_END() /**< NULL terminate unit test array */
8564         }
8565 };
8566
8567 static struct unit_test_suite cryptodev_null_testsuite  = {
8568         .suite_name = "Crypto Device NULL Unit Test Suite",
8569         .setup = testsuite_setup,
8570         .teardown = testsuite_teardown,
8571         .unit_test_cases = {
8572                 TEST_CASE_ST(ut_setup, ut_teardown,
8573                         test_null_auth_only_operation),
8574                 TEST_CASE_ST(ut_setup, ut_teardown,
8575                         test_null_cipher_only_operation),
8576                 TEST_CASE_ST(ut_setup, ut_teardown,
8577                         test_null_cipher_auth_operation),
8578                 TEST_CASE_ST(ut_setup, ut_teardown,
8579                         test_null_auth_cipher_operation),
8580                 TEST_CASE_ST(ut_setup, ut_teardown,
8581                         test_null_invalid_operation),
8582                 TEST_CASE_ST(ut_setup, ut_teardown,
8583                         test_null_burst_operation),
8584
8585                 TEST_CASES_END() /**< NULL terminate unit test array */
8586         }
8587 };
8588
8589 static struct unit_test_suite cryptodev_armv8_testsuite  = {
8590         .suite_name = "Crypto Device ARMv8 Unit Test Suite",
8591         .setup = testsuite_setup,
8592         .teardown = testsuite_teardown,
8593         .unit_test_cases = {
8594                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_armv8_all),
8595
8596                 /** Negative tests */
8597                 TEST_CASE_ST(ut_setup, ut_teardown,
8598                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8599                 TEST_CASE_ST(ut_setup, ut_teardown,
8600                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8601
8602                 TEST_CASES_END() /**< NULL terminate unit test array */
8603         }
8604 };
8605
8606 static int
8607 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
8608 {
8609         gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
8610         return unit_test_suite_runner(&cryptodev_qat_testsuite);
8611 }
8612
8613 static int
8614 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
8615 {
8616         gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
8617
8618         return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
8619 }
8620
8621 static int
8622 test_cryptodev_openssl(void)
8623 {
8624         gbl_cryptodev_type = RTE_CRYPTODEV_OPENSSL_PMD;
8625
8626         return unit_test_suite_runner(&cryptodev_openssl_testsuite);
8627 }
8628
8629 static int
8630 test_cryptodev_aesni_gcm(void)
8631 {
8632         gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD;
8633
8634         return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
8635 }
8636
8637 static int
8638 test_cryptodev_null(void)
8639 {
8640         gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD;
8641
8642         return unit_test_suite_runner(&cryptodev_null_testsuite);
8643 }
8644
8645 static int
8646 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
8647 {
8648         gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD;
8649
8650         return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
8651 }
8652
8653 static int
8654 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
8655 {
8656         gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD;
8657
8658         return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
8659 }
8660
8661 static int
8662 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
8663 {
8664         gbl_cryptodev_type = RTE_CRYPTODEV_ZUC_PMD;
8665
8666         return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
8667 }
8668
8669 static int
8670 test_cryptodev_armv8(void)
8671 {
8672         gbl_cryptodev_type = RTE_CRYPTODEV_ARMV8_PMD;
8673
8674         return unit_test_suite_runner(&cryptodev_armv8_testsuite);
8675 }
8676
8677 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
8678
8679 static int
8680 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
8681 {
8682         gbl_cryptodev_type = RTE_CRYPTODEV_SCHEDULER_PMD;
8683         return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
8684 }
8685
8686 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
8687
8688 #endif
8689
8690 static int
8691 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
8692 {
8693         gbl_cryptodev_type = RTE_CRYPTODEV_DPAA2_SEC_PMD;
8694         return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
8695 }
8696
8697 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
8698 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
8699 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
8700 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
8701 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
8702 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
8703 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
8704 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
8705 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
8706 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);