app/test/test_cryptodev.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2015-2016 Intel Corporation. All rights reserved.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *       * Redistributions of source code must retain the above copyright
  11  *         notice, this list of conditions and the following disclaimer.
  12  *       * Redistributions in binary form must reproduce the above copyright
  13  *         notice, this list of conditions and the following disclaimer in
  14  *         the documentation and/or other materials provided with the
  15  *         distribution.
  16  *       * Neither the name of Intel Corporation nor the names of its
  17  *         contributors may be used to endorse or promote products derived
  18  *         from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <rte_common.h>
  34 #include <rte_hexdump.h>
  35 #include <rte_mbuf.h>
  36 #include <rte_malloc.h>
  37 #include <rte_memcpy.h>
  38
  39 #include <rte_crypto.h>
  40 #include <rte_cryptodev.h>
  41 #include <rte_cryptodev_pmd.h>
  42
  43 #include "test.h"
  44 #include "test_cryptodev.h"
  45
  46 #include "test_cryptodev_blockcipher.h"
  47 #include "test_cryptodev_aes_test_vectors.h"
  48 #include "test_cryptodev_des_test_vectors.h"
  49 #include "test_cryptodev_hash_test_vectors.h"
  50 #include "test_cryptodev_kasumi_test_vectors.h"
  51 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  52 #include "test_cryptodev_snow3g_test_vectors.h"
  53 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  54 #include "test_cryptodev_zuc_test_vectors.h"
  55 #include "test_cryptodev_zuc_hash_test_vectors.h"
  56 #include "test_cryptodev_gcm_test_vectors.h"
  57 #include "test_cryptodev_hmac_test_vectors.h"
  58
  59 static enum rte_cryptodev_type gbl_cryptodev_type;
  60
  61 struct crypto_testsuite_params {
  62         struct rte_mempool *mbuf_pool;
  63         struct rte_mempool *large_mbuf_pool;
  64         struct rte_mempool *op_mpool;
  65         struct rte_cryptodev_config conf;
  66         struct rte_cryptodev_qp_conf qp_conf;
  67
  68         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  69         uint8_t valid_dev_count;
  70 };
  71
  72 struct crypto_unittest_params {
  73         struct rte_crypto_sym_xform cipher_xform;
  74         struct rte_crypto_sym_xform auth_xform;
  75
  76         struct rte_cryptodev_sym_session *sess;
  77
  78         struct rte_crypto_op *op;
  79
  80         struct rte_mbuf *obuf, *ibuf;
  81
  82         uint8_t *digest;
  83 };
  84
  85 #define ALIGN_POW2_ROUNDUP(num, align) \
  86         (((num) + (align) - 1) & ~((align) - 1))
  87
  88 /*
  89  * Forward declarations.
  90  */
  91 static int
  92 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
  93                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
  94                 uint8_t *hmac_key);
  95
  96 static int
  97 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
  98                 struct crypto_unittest_params *ut_params,
  99                 struct crypto_testsuite_params *ts_param,
 100                 const uint8_t *cipher,
 101                 const uint8_t *digest,
 102                 const uint8_t *iv);
 103
 104 static struct rte_mbuf *
 105 setup_test_string(struct rte_mempool *mpool,
 106                 const char *string, size_t len, uint8_t blocksize)
 107 {
 108         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 109         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 110
 111         memset(m->buf_addr, 0, m->buf_len);
 112         if (m) {
 113                 char *dst = rte_pktmbuf_append(m, t_len);
 114
 115                 if (!dst) {
 116                         rte_pktmbuf_free(m);
 117                         return NULL;
 118                 }
 119                 if (string != NULL)
 120                         rte_memcpy(dst, string, t_len);
 121                 else
 122                         memset(dst, 0, t_len);
 123         }
 124
 125         return m;
 126 }
 127
 128 /* Get number of bytes in X bits (rounding up) */
 129 static uint32_t
 130 ceil_byte_length(uint32_t num_bits)
 131 {
 132         if (num_bits % 8)
 133                 return ((num_bits >> 3) + 1);
 134         else
 135                 return (num_bits >> 3);
 136 }
 137
 138 static struct rte_crypto_op *
 139 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 140 {
 141         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 142                 printf("Error sending packet for encryption");
 143                 return NULL;
 144         }
 145
 146         op = NULL;
 147
 148         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 149                 rte_pause();
 150
 151         return op;
 152 }
 153
 154 static struct crypto_testsuite_params testsuite_params = { NULL };
 155 static struct crypto_unittest_params unittest_params;
 156
 157 static int
 158 testsuite_setup(void)
 159 {
 160         struct crypto_testsuite_params *ts_params = &testsuite_params;
 161         struct rte_cryptodev_info info;
 162         unsigned i, nb_devs, dev_id;
 163         int ret;
 164         uint16_t qp_id;
 165
 166         memset(ts_params, 0, sizeof(*ts_params));
 167
 168         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 169         if (ts_params->mbuf_pool == NULL) {
 170                 /* Not already created so create */
 171                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 172                                 "CRYPTO_MBUFPOOL",
 173                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 174                                 rte_socket_id());
 175                 if (ts_params->mbuf_pool == NULL) {
 176                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 177                         return TEST_FAILED;
 178                 }
 179         }
 180
 181         ts_params->large_mbuf_pool = rte_mempool_lookup(
 182                         "CRYPTO_LARGE_MBUFPOOL");
 183         if (ts_params->large_mbuf_pool == NULL) {
 184                 /* Not already created so create */
 185                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 186                                 "CRYPTO_LARGE_MBUFPOOL",
 187                                 1, 0, 0, UINT16_MAX,
 188                                 rte_socket_id());
 189                 if (ts_params->large_mbuf_pool == NULL) {
 190                         RTE_LOG(ERR, USER1,
 191                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 192                         return TEST_FAILED;
 193                 }
 194         }
 195
 196         ts_params->op_mpool = rte_crypto_op_pool_create(
 197                         "MBUF_CRYPTO_SYM_OP_POOL",
 198                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 199                         NUM_MBUFS, MBUF_CACHE_SIZE,
 200                         DEFAULT_NUM_XFORMS *
 201                         sizeof(struct rte_crypto_sym_xform),
 202                         rte_socket_id());
 203         if (ts_params->op_mpool == NULL) {
 204                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 205                 return TEST_FAILED;
 206         }
 207
 208         /* Create 2 AESNI MB devices if required */
 209         if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) {
 210 #ifndef RTE_LIBRTE_PMD_AESNI_MB
 211                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
 212                         " enabled in config file to run this testsuite.\n");
 213                 return TEST_FAILED;
 214 #endif
 215                 nb_devs = rte_cryptodev_count_devtype(
 216                                 RTE_CRYPTODEV_AESNI_MB_PMD);
 217                 if (nb_devs < 2) {
 218                         for (i = nb_devs; i < 2; i++) {
 219                                 ret = rte_eal_vdev_init(
 220                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
 221
 222                                 TEST_ASSERT(ret == 0,
 223                                         "Failed to create instance %u of"
 224                                         " pmd : %s",
 225                                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
 226                         }
 227                 }
 228         }
 229
 230         /* Create 2 AESNI GCM devices if required */
 231         if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) {
 232 #ifndef RTE_LIBRTE_PMD_AESNI_GCM
 233                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be"
 234                         " enabled in config file to run this testsuite.\n");
 235                 return TEST_FAILED;
 236 #endif
 237                 nb_devs = rte_cryptodev_count_devtype(
 238                                 RTE_CRYPTODEV_AESNI_GCM_PMD);
 239                 if (nb_devs < 2) {
 240                         for (i = nb_devs; i < 2; i++) {
 241                                 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
 242                                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
 243                                         "Failed to create instance %u of"
 244                                         " pmd : %s",
 245                                         i, RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
 246                         }
 247                 }
 248         }
 249
 250         /* Create 2 SNOW 3G devices 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 < 2) {
 259                         for (i = nb_devs; i < 2; i++) {
 260                                 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
 261                                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
 262                                         "Failed to create instance %u of"
 263                                         " pmd : %s",
 264                                         i, RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
 265                         }
 266                 }
 267         }
 268
 269         /* Create 2 KASUMI devices if required */
 270         if (gbl_cryptodev_type == RTE_CRYPTODEV_KASUMI_PMD) {
 271 #ifndef RTE_LIBRTE_PMD_KASUMI
 272                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_KASUMI must be"
 273                         " enabled in config file to run this testsuite.\n");
 274                 return TEST_FAILED;
 275 #endif
 276                 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD);
 277                 if (nb_devs < 2) {
 278                         for (i = nb_devs; i < 2; i++) {
 279                                 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
 280                                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
 281                                         "Failed to create instance %u of"
 282                                         " pmd : %s",
 283                                         i, RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
 284                         }
 285                 }
 286         }
 287
 288         /* Create 2 ZUC devices if required */
 289         if (gbl_cryptodev_type == RTE_CRYPTODEV_ZUC_PMD) {
 290 #ifndef RTE_LIBRTE_PMD_ZUC
 291                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ZUC must be"
 292                         " enabled in config file to run this testsuite.\n");
 293                 return TEST_FAILED;
 294 #endif
 295                 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_ZUC_PMD);
 296                 if (nb_devs < 2) {
 297                         for (i = nb_devs; i < 2; i++) {
 298                                 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
 299                                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
 300                                         "Failed to create instance %u of"
 301                                         " pmd : %s",
 302                                         i, RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
 303                         }
 304                 }
 305         }
 306
 307         /* Create 2 NULL devices if required */
 308         if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) {
 309 #ifndef RTE_LIBRTE_PMD_NULL_CRYPTO
 310                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_NULL_CRYPTO must be"
 311                         " enabled in config file to run this testsuite.\n");
 312                 return TEST_FAILED;
 313 #endif
 314                 nb_devs = rte_cryptodev_count_devtype(
 315                                 RTE_CRYPTODEV_NULL_PMD);
 316                 if (nb_devs < 2) {
 317                         for (i = nb_devs; i < 2; i++) {
 318                                 int dev_id = rte_eal_vdev_init(
 319                                         RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
 320
 321                                 TEST_ASSERT(dev_id >= 0,
 322                                         "Failed to create instance %u of"
 323                                         " pmd : %s",
 324                                         i, RTE_STR(CRYPTODEV_NAME_NULL_PMD));
 325                         }
 326                 }
 327         }
 328
 329         /* Create 2 OPENSSL devices if required */
 330         if (gbl_cryptodev_type == RTE_CRYPTODEV_OPENSSL_PMD) {
 331 #ifndef RTE_LIBRTE_PMD_OPENSSL
 332                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be"
 333                         " enabled in config file to run this testsuite.\n");
 334                 return TEST_FAILED;
 335 #endif
 336                 nb_devs = rte_cryptodev_count_devtype(
 337                                 RTE_CRYPTODEV_OPENSSL_PMD);
 338                 if (nb_devs < 2) {
 339                         for (i = nb_devs; i < 2; i++) {
 340                                 ret = rte_eal_vdev_init(
 341                                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
 342                                         NULL);
 343
 344                                 TEST_ASSERT(ret == 0, "Failed to create "
 345                                         "instance %u of pmd : %s", i,
 346                                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
 347                         }
 348                 }
 349         }
 350
 351 #ifndef RTE_LIBRTE_PMD_QAT
 352         if (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) {
 353                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
 354                                 "in config file to run this testsuite.\n");
 355                 return TEST_FAILED;
 356         }
 357 #endif
 358
 359         nb_devs = rte_cryptodev_count();
 360         if (nb_devs < 1) {
 361                 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
 362                 return TEST_FAILED;
 363         }
 364
 365         /* Create list of valid crypto devs */
 366         for (i = 0; i < nb_devs; i++) {
 367                 rte_cryptodev_info_get(i, &info);
 368                 if (info.dev_type == gbl_cryptodev_type)
 369                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 370         }
 371
 372         if (ts_params->valid_dev_count < 1)
 373                 return TEST_FAILED;
 374
 375         /* Set up all the qps on the first of the valid devices found */
 376
 377         dev_id = ts_params->valid_devs[0];
 378
 379         rte_cryptodev_info_get(dev_id, &info);
 380
 381         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 382         ts_params->conf.socket_id = SOCKET_ID_ANY;
 383         ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
 384
 385         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 386                         &ts_params->conf),
 387                         "Failed to configure cryptodev %u with %u qps",
 388                         dev_id, ts_params->conf.nb_queue_pairs);
 389
 390         ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 391
 392         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 393                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 394                         dev_id, qp_id, &ts_params->qp_conf,
 395                         rte_cryptodev_socket_id(dev_id)),
 396                         "Failed to setup queue pair %u on cryptodev %u",
 397                         qp_id, dev_id);
 398         }
 399
 400         return TEST_SUCCESS;
 401 }
 402
 403 static void
 404 testsuite_teardown(void)
 405 {
 406         struct crypto_testsuite_params *ts_params = &testsuite_params;
 407
 408         if (ts_params->mbuf_pool != NULL) {
 409                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 410                 rte_mempool_avail_count(ts_params->mbuf_pool));
 411         }
 412
 413         if (ts_params->op_mpool != NULL) {
 414                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 415                 rte_mempool_avail_count(ts_params->op_mpool));
 416         }
 417
 418 }
 419
 420 static int
 421 ut_setup(void)
 422 {
 423         struct crypto_testsuite_params *ts_params = &testsuite_params;
 424         struct crypto_unittest_params *ut_params = &unittest_params;
 425
 426         uint16_t qp_id;
 427
 428         /* Clear unit test parameters before running test */
 429         memset(ut_params, 0, sizeof(*ut_params));
 430
 431         /* Reconfigure device to default parameters */
 432         ts_params->conf.socket_id = SOCKET_ID_ANY;
 433         ts_params->conf.session_mp.nb_objs = DEFAULT_NUM_OPS_INFLIGHT;
 434
 435         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 436                         &ts_params->conf),
 437                         "Failed to configure cryptodev %u",
 438                         ts_params->valid_devs[0]);
 439
 440         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 441                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 442                         ts_params->valid_devs[0], qp_id,
 443                         &ts_params->qp_conf,
 444                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 445                         "Failed to setup queue pair %u on cryptodev %u",
 446                         qp_id, ts_params->valid_devs[0]);
 447         }
 448
 449
 450         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 451
 452         /* Start the device */
 453         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
 454                         "Failed to start cryptodev %u",
 455                         ts_params->valid_devs[0]);
 456
 457         return TEST_SUCCESS;
 458 }
 459
 460 static void
 461 ut_teardown(void)
 462 {
 463         struct crypto_testsuite_params *ts_params = &testsuite_params;
 464         struct crypto_unittest_params *ut_params = &unittest_params;
 465         struct rte_cryptodev_stats stats;
 466
 467         /* free crypto session structure */
 468         if (ut_params->sess) {
 469                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
 470                                 ut_params->sess);
 471                 ut_params->sess = NULL;
 472         }
 473
 474         /* free crypto operation structure */
 475         if (ut_params->op)
 476                 rte_crypto_op_free(ut_params->op);
 477
 478         /*
 479          * free mbuf - both obuf and ibuf are usually the same,
 480          * so check if they point at the same address is necessary,
 481          * to avoid freeing the mbuf twice.
 482          */
 483         if (ut_params->obuf) {
 484                 rte_pktmbuf_free(ut_params->obuf);
 485                 if (ut_params->ibuf == ut_params->obuf)
 486                         ut_params->ibuf = 0;
 487                 ut_params->obuf = 0;
 488         }
 489         if (ut_params->ibuf) {
 490                 rte_pktmbuf_free(ut_params->ibuf);
 491                 ut_params->ibuf = 0;
 492         }
 493
 494         if (ts_params->mbuf_pool != NULL)
 495                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 496                         rte_mempool_avail_count(ts_params->mbuf_pool));
 497
 498         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
 499
 500         /* Stop the device */
 501         rte_cryptodev_stop(ts_params->valid_devs[0]);
 502 }
 503
 504 static int
 505 test_device_configure_invalid_dev_id(void)
 506 {
 507         struct crypto_testsuite_params *ts_params = &testsuite_params;
 508         uint16_t dev_id, num_devs = 0;
 509
 510         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
 511                         "Need at least %d devices for test", 1);
 512
 513         /* valid dev_id values */
 514         dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
 515
 516         /* Stop the device in case it's started so it can be configured */
 517         rte_cryptodev_stop(ts_params->valid_devs[dev_id]);
 518
 519         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
 520                         "Failed test for rte_cryptodev_configure: "
 521                         "invalid dev_num %u", dev_id);
 522
 523         /* invalid dev_id values */
 524         dev_id = num_devs;
 525
 526         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 527                         "Failed test for rte_cryptodev_configure: "
 528                         "invalid dev_num %u", dev_id);
 529
 530         dev_id = 0xff;
 531
 532         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 533                         "Failed test for rte_cryptodev_configure:"
 534                         "invalid dev_num %u", dev_id);
 535
 536         return TEST_SUCCESS;
 537 }
 538
 539 static int
 540 test_device_configure_invalid_queue_pair_ids(void)
 541 {
 542         struct crypto_testsuite_params *ts_params = &testsuite_params;
 543         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
 544
 545         /* Stop the device in case it's started so it can be configured */
 546         rte_cryptodev_stop(ts_params->valid_devs[0]);
 547
 548         /* valid - one queue pairs */
 549         ts_params->conf.nb_queue_pairs = 1;
 550
 551         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 552                         &ts_params->conf),
 553                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 554                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 555
 556
 557         /* valid - max value queue pairs */
 558         ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
 559
 560         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 561                         &ts_params->conf),
 562                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 563                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 564
 565
 566         /* invalid - zero queue pairs */
 567         ts_params->conf.nb_queue_pairs = 0;
 568
 569         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 570                         &ts_params->conf),
 571                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 572                         " invalid qps: %u",
 573                         ts_params->valid_devs[0],
 574                         ts_params->conf.nb_queue_pairs);
 575
 576
 577         /* invalid - max value supported by field queue pairs */
 578         ts_params->conf.nb_queue_pairs = UINT16_MAX;
 579
 580         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 581                         &ts_params->conf),
 582                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 583                         " invalid qps: %u",
 584                         ts_params->valid_devs[0],
 585                         ts_params->conf.nb_queue_pairs);
 586
 587
 588         /* invalid - max value + 1 queue pairs */
 589         ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
 590
 591         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 592                         &ts_params->conf),
 593                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 594                         " invalid qps: %u",
 595                         ts_params->valid_devs[0],
 596                         ts_params->conf.nb_queue_pairs);
 597
 598         /* revert to original testsuite value */
 599         ts_params->conf.nb_queue_pairs = orig_nb_qps;
 600
 601         return TEST_SUCCESS;
 602 }
 603
 604 static int
 605 test_queue_pair_descriptor_setup(void)
 606 {
 607         struct crypto_testsuite_params *ts_params = &testsuite_params;
 608         struct rte_cryptodev_info dev_info;
 609         struct rte_cryptodev_qp_conf qp_conf = {
 610                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
 611         };
 612
 613         uint16_t qp_id;
 614
 615         /* Stop the device in case it's started so it can be configured */
 616         rte_cryptodev_stop(ts_params->valid_devs[0]);
 617
 618
 619         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 620
 621         ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions;
 622
 623         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 624                         &ts_params->conf), "Failed to configure cryptodev %u",
 625                         ts_params->valid_devs[0]);
 626
 627
 628         /*
 629          * Test various ring sizes on this device. memzones can't be
 630          * freed so are re-used if ring is released and re-created.
 631          */
 632         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
 633
 634         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 635                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 636                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 637                                 rte_cryptodev_socket_id(
 638                                                 ts_params->valid_devs[0])),
 639                                 "Failed test for "
 640                                 "rte_cryptodev_queue_pair_setup: num_inflights "
 641                                 "%u on qp %u on cryptodev %u",
 642                                 qp_conf.nb_descriptors, qp_id,
 643                                 ts_params->valid_devs[0]);
 644         }
 645
 646         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
 647
 648         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 649                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 650                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 651                                 rte_cryptodev_socket_id(
 652                                                 ts_params->valid_devs[0])),
 653                                 "Failed test for"
 654                                 " rte_cryptodev_queue_pair_setup: num_inflights"
 655                                 " %u on qp %u on cryptodev %u",
 656                                 qp_conf.nb_descriptors, qp_id,
 657                                 ts_params->valid_devs[0]);
 658         }
 659
 660         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
 661
 662         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 663                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 664                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 665                                 rte_cryptodev_socket_id(
 666                                                 ts_params->valid_devs[0])),
 667                                 "Failed test for "
 668                                 "rte_cryptodev_queue_pair_setup: num_inflights"
 669                                 " %u on qp %u on cryptodev %u",
 670                                 qp_conf.nb_descriptors, qp_id,
 671                                 ts_params->valid_devs[0]);
 672         }
 673
 674         /* invalid number of descriptors - max supported + 2 */
 675         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
 676
 677         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 678                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 679                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 680                                 rte_cryptodev_socket_id(
 681                                                 ts_params->valid_devs[0])),
 682                                 "Unexpectedly passed test for "
 683                                 "rte_cryptodev_queue_pair_setup:"
 684                                 "num_inflights %u on qp %u on cryptodev %u",
 685                                 qp_conf.nb_descriptors, qp_id,
 686                                 ts_params->valid_devs[0]);
 687         }
 688
 689         /* invalid number of descriptors - max value of parameter */
 690         qp_conf.nb_descriptors = UINT32_MAX-1;
 691
 692         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 693                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 694                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 695                                 rte_cryptodev_socket_id(
 696                                                 ts_params->valid_devs[0])),
 697                                 "Unexpectedly passed test for "
 698                                 "rte_cryptodev_queue_pair_setup:"
 699                                 "num_inflights %u on qp %u on cryptodev %u",
 700                                 qp_conf.nb_descriptors, qp_id,
 701                                 ts_params->valid_devs[0]);
 702         }
 703
 704         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 705
 706         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 707                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 708                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 709                                 rte_cryptodev_socket_id(
 710                                                 ts_params->valid_devs[0])),
 711                                 "Failed test for"
 712                                 " rte_cryptodev_queue_pair_setup:"
 713                                 "num_inflights %u on qp %u on cryptodev %u",
 714                                 qp_conf.nb_descriptors, qp_id,
 715                                 ts_params->valid_devs[0]);
 716         }
 717
 718         /* invalid number of descriptors - max supported + 1 */
 719         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
 720
 721         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 722                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 723                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 724                                 rte_cryptodev_socket_id(
 725                                                 ts_params->valid_devs[0])),
 726                                 "Unexpectedly passed test for "
 727                                 "rte_cryptodev_queue_pair_setup:"
 728                                 "num_inflights %u on qp %u on cryptodev %u",
 729                                 qp_conf.nb_descriptors, qp_id,
 730                                 ts_params->valid_devs[0]);
 731         }
 732
 733         /* test invalid queue pair id */
 734         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
 735
 736         qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE;         /*invalid */
 737
 738         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 739                         ts_params->valid_devs[0],
 740                         qp_id, &qp_conf,
 741                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 742                         "Failed test for rte_cryptodev_queue_pair_setup:"
 743                         "invalid qp %u on cryptodev %u",
 744                         qp_id, ts_params->valid_devs[0]);
 745
 746         qp_id = 0xffff; /*invalid*/
 747
 748         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 749                         ts_params->valid_devs[0],
 750                         qp_id, &qp_conf,
 751                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 752                         "Failed test for rte_cryptodev_queue_pair_setup:"
 753                         "invalid qp %u on cryptodev %u",
 754                         qp_id, ts_params->valid_devs[0]);
 755
 756         return TEST_SUCCESS;
 757 }
 758
 759 /* ***** Plaintext data for tests ***** */
 760
 761 const char catch_22_quote_1[] =
 762                 "There was only one catch and that was Catch-22, which "
 763                 "specified that a concern for one's safety in the face of "
 764                 "dangers that were real and immediate was the process of a "
 765                 "rational mind. Orr was crazy and could be grounded. All he "
 766                 "had to do was ask; and as soon as he did, he would no longer "
 767                 "be crazy and would have to fly more missions. Orr would be "
 768                 "crazy to fly more missions and sane if he didn't, but if he "
 769                 "was sane he had to fly them. If he flew them he was crazy "
 770                 "and didn't have to; but if he didn't want to he was sane and "
 771                 "had to. Yossarian was moved very deeply by the absolute "
 772                 "simplicity of this clause of Catch-22 and let out a "
 773                 "respectful whistle. \"That's some catch, that Catch-22\", he "
 774                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
 775
 776 const char catch_22_quote[] =
 777                 "What a lousy earth! He wondered how many people were "
 778                 "destitute that same night even in his own prosperous country, "
 779                 "how many homes were shanties, how many husbands were drunk "
 780                 "and wives socked, and how many children were bullied, abused, "
 781                 "or abandoned. How many families hungered for food they could "
 782                 "not afford to buy? How many hearts were broken? How many "
 783                 "suicides would take place that same night, how many people "
 784                 "would go insane? How many cockroaches and landlords would "
 785                 "triumph? How many winners were losers, successes failures, "
 786                 "and rich men poor men? How many wise guys were stupid? How "
 787                 "many happy endings were unhappy endings? How many honest men "
 788                 "were liars, brave men cowards, loyal men traitors, how many "
 789                 "sainted men were corrupt, how many people in positions of "
 790                 "trust had sold their souls to bodyguards, how many had never "
 791                 "had souls? How many straight-and-narrow paths were crooked "
 792                 "paths? How many best families were worst families and how "
 793                 "many good people were bad people? When you added them all up "
 794                 "and then subtracted, you might be left with only the children, "
 795                 "and perhaps with Albert Einstein and an old violinist or "
 796                 "sculptor somewhere.";
 797
 798 #define QUOTE_480_BYTES         (480)
 799 #define QUOTE_512_BYTES         (512)
 800 #define QUOTE_768_BYTES         (768)
 801 #define QUOTE_1024_BYTES        (1024)
 802
 803
 804
 805 /* ***** SHA1 Hash Tests ***** */
 806
 807 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
 808
 809 static uint8_t hmac_sha1_key[] = {
 810         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 811         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 812         0xDE, 0xF4, 0xDE, 0xAD };
 813
 814 /* ***** SHA224 Hash Tests ***** */
 815
 816 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
 817
 818
 819 /* ***** AES-CBC Cipher Tests ***** */
 820
 821 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
 822 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
 823
 824 static uint8_t aes_cbc_key[] = {
 825         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 826         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
 827
 828 static uint8_t aes_cbc_iv[] = {
 829         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 830         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
 831
 832
 833 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
 834
 835 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
 836         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
 837         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
 838         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
 839         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
 840         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
 841         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
 842         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
 843         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
 844         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
 845         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
 846         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
 847         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
 848         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
 849         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
 850         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
 851         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
 852         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
 853         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
 854         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
 855         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
 856         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
 857         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
 858         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 859         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
 860         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
 861         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
 862         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
 863         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
 864         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
 865         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
 866         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
 867         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
 868         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
 869         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
 870         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
 871         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
 872         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
 873         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
 874         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
 875         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
 876         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
 877         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
 878         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
 879         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
 880         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
 881         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
 882         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
 883         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
 884         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
 885         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
 886         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
 887         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
 888         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
 889         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
 890         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
 891         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
 892         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
 893         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
 894         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
 895         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
 896         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
 897         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
 898         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
 899         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
 900 };
 901
 902 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
 903         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
 904         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
 905         0x18, 0x8c, 0x1d, 0x32
 906 };
 907
 908
 909 /* Multisession Vector context Test */
 910 /*Begin Session 0 */
 911 static uint8_t ms_aes_cbc_key0[] = {
 912         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 913         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 914 };
 915
 916 static uint8_t ms_aes_cbc_iv0[] = {
 917         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 918         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 919 };
 920
 921 static const uint8_t ms_aes_cbc_cipher0[] = {
 922                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
 923                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
 924                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
 925                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
 926                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
 927                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
 928                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
 929                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
 930                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
 931                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
 932                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
 933                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
 934                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
 935                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
 936                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
 937                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
 938                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
 939                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
 940                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
 941                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
 942                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
 943                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
 944                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
 945                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
 946                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
 947                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
 948                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
 949                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
 950                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
 951                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
 952                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
 953                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
 954                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
 955                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
 956                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
 957                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
 958                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
 959                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
 960                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
 961                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
 962                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
 963                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
 964                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
 965                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
 966                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
 967                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
 968                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
 969                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
 970                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
 971                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
 972                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
 973                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
 974                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
 975                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
 976                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
 977                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
 978                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
 979                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
 980                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
 981                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
 982                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
 983                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
 984                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
 985                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
 986 };
 987
 988
 989 static  uint8_t ms_hmac_key0[] = {
 990                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
 991                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 992                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
 993                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
 994                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
 995                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
 996                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
 997                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
 998 };
 999
1000 static const uint8_t ms_hmac_digest0[] = {
1001                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1002                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1003                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1004                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1005                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1006                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1007                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1008                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1009                 };
1010
1011 /* End Session 0 */
1012 /* Begin session 1 */
1013
1014 static  uint8_t ms_aes_cbc_key1[] = {
1015                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1016                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1017 };
1018
1019 static  uint8_t ms_aes_cbc_iv1[] = {
1020         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1021         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1022 };
1023
1024 static const uint8_t ms_aes_cbc_cipher1[] = {
1025                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1026                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1027                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1028                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1029                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1030                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1031                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1032                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1033                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1034                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1035                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1036                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1037                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1038                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1039                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1040                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1041                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1042                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1043                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1044                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1045                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1046                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1047                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1048                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1049                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1050                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1051                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1052                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1053                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1054                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1055                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1056                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1057                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1058                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1059                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1060                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1061                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1062                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1063                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1064                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1065                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1066                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1067                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1068                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1069                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1070                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1071                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1072                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1073                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1074                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1075                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1076                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1077                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1078                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1079                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1080                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1081                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1082                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1083                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1084                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1085                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1086                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1087                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1088                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1089
1090 };
1091
1092 static uint8_t ms_hmac_key1[] = {
1093                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1094                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1095                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1096                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1097                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1098                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1099                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1100                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1101 };
1102
1103 static const uint8_t ms_hmac_digest1[] = {
1104                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1105                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1106                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1107                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1108                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1109                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1110                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1111                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1112 };
1113 /* End Session 1  */
1114 /* Begin Session 2 */
1115 static  uint8_t ms_aes_cbc_key2[] = {
1116                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1117                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1118 };
1119
1120 static  uint8_t ms_aes_cbc_iv2[] = {
1121                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1122                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1123 };
1124
1125 static const uint8_t ms_aes_cbc_cipher2[] = {
1126                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1127                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1128                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1129                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1130                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1131                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1132                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1133                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1134                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1135                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1136                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1137                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1138                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1139                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1140                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1141                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1142                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1143                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1144                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1145                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1146                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1147                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1148                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1149                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1150                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1151                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1152                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1153                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1154                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1155                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1156                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1157                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1158                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1159                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1160                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1161                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1162                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1163                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1164                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1165                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1166                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1167                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1168                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1169                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1170                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1171                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1172                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1173                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1174                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1175                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1176                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1177                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1178                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1179                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1180                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1181                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1182                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1183                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1184                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1185                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1186                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1187                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1188                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1189                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1190 };
1191
1192 static  uint8_t ms_hmac_key2[] = {
1193                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1194                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1195                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1196                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1197                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1198                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1199                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1200                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1201 };
1202
1203 static const uint8_t ms_hmac_digest2[] = {
1204                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1205                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1206                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1207                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1208                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1209                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1210                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1211                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1212 };
1213
1214 /* End Session 2 */
1215
1216
1217 static int
1218 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1219 {
1220         struct crypto_testsuite_params *ts_params = &testsuite_params;
1221         struct crypto_unittest_params *ut_params = &unittest_params;
1222
1223         /* Generate test mbuf data and space for digest */
1224         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1225                         catch_22_quote, QUOTE_512_BYTES, 0);
1226
1227         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1228                         DIGEST_BYTE_LENGTH_SHA1);
1229         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1230
1231         /* Setup Cipher Parameters */
1232         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1233         ut_params->cipher_xform.next = &ut_params->auth_xform;
1234
1235         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1236         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1237         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1238         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1239
1240         /* Setup HMAC Parameters */
1241         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1242
1243         ut_params->auth_xform.next = NULL;
1244
1245         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1246         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1247         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1248         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1249         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1250
1251         /* Create crypto session*/
1252         ut_params->sess = rte_cryptodev_sym_session_create(
1253                         ts_params->valid_devs[0],
1254                         &ut_params->cipher_xform);
1255         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1256
1257         /* Generate crypto op data structure */
1258         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1259                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1260         TEST_ASSERT_NOT_NULL(ut_params->op,
1261                         "Failed to allocate symmetric crypto operation struct");
1262
1263         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1264
1265         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1266
1267         /* set crypto operation source mbuf */
1268         sym_op->m_src = ut_params->ibuf;
1269
1270         /* Set crypto operation authentication parameters */
1271         sym_op->auth.digest.data = ut_params->digest;
1272         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1273                         ut_params->ibuf, QUOTE_512_BYTES);
1274         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
1275
1276         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1277         sym_op->auth.data.length = QUOTE_512_BYTES;
1278
1279         /* Set crypto operation cipher parameters */
1280         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1281                         CIPHER_IV_LENGTH_AES_CBC);
1282         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1283         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1284
1285         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1286                         CIPHER_IV_LENGTH_AES_CBC);
1287
1288         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1289         sym_op->cipher.data.length = QUOTE_512_BYTES;
1290
1291         /* Process crypto operation */
1292         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1293                         ut_params->op), "failed to process sym crypto op");
1294
1295         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1296                         "crypto op processing failed");
1297
1298         /* Validate obuf */
1299         uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
1300                         uint8_t *, CIPHER_IV_LENGTH_AES_CBC);
1301
1302         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1303                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1304                         QUOTE_512_BYTES,
1305                         "ciphertext data not as expected");
1306
1307         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1308
1309         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1310                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1311                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1312                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1313                                         DIGEST_BYTE_LENGTH_SHA1,
1314                         "Generated digest data not as expected");
1315
1316         return TEST_SUCCESS;
1317 }
1318
1319 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1320
1321 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
1322
1323 static uint8_t hmac_sha512_key[] = {
1324         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1325         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1326         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1327         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1328         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1329         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1330         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1331         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1332
1333 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1334         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1335         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1336         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1337         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1338         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1339         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1340         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1341         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1342
1343
1344
1345 static int
1346 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1347                 struct crypto_unittest_params *ut_params,
1348                 uint8_t *cipher_key,
1349                 uint8_t *hmac_key);
1350
1351 static int
1352 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1353                 struct crypto_unittest_params *ut_params,
1354                 struct crypto_testsuite_params *ts_params,
1355                 const uint8_t *cipher,
1356                 const uint8_t *digest,
1357                 const uint8_t *iv);
1358
1359
1360 static int
1361 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1362                 struct crypto_unittest_params *ut_params,
1363                 uint8_t *cipher_key,
1364                 uint8_t *hmac_key)
1365 {
1366
1367         /* Setup Cipher Parameters */
1368         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1369         ut_params->cipher_xform.next = NULL;
1370
1371         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1372         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1373         ut_params->cipher_xform.cipher.key.data = cipher_key;
1374         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1375
1376         /* Setup HMAC Parameters */
1377         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1378         ut_params->auth_xform.next = &ut_params->cipher_xform;
1379
1380         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1381         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1382         ut_params->auth_xform.auth.key.data = hmac_key;
1383         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1384         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1385
1386         return TEST_SUCCESS;
1387 }
1388
1389
1390 static int
1391 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1392                 struct crypto_unittest_params *ut_params,
1393                 struct crypto_testsuite_params *ts_params,
1394                 const uint8_t *cipher,
1395                 const uint8_t *digest,
1396                 const uint8_t *iv)
1397 {
1398         /* Generate test mbuf data and digest */
1399         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1400                         (const char *)
1401                         cipher,
1402                         QUOTE_512_BYTES, 0);
1403
1404         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1405                         DIGEST_BYTE_LENGTH_SHA512);
1406         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1407
1408         rte_memcpy(ut_params->digest,
1409                         digest,
1410                         DIGEST_BYTE_LENGTH_SHA512);
1411
1412         /* Generate Crypto op data structure */
1413         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1414                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1415         TEST_ASSERT_NOT_NULL(ut_params->op,
1416                         "Failed to allocate symmetric crypto operation struct");
1417
1418         rte_crypto_op_attach_sym_session(ut_params->op, sess);
1419
1420         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1421
1422         /* set crypto operation source mbuf */
1423         sym_op->m_src = ut_params->ibuf;
1424
1425         sym_op->auth.digest.data = ut_params->digest;
1426         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1427                         ut_params->ibuf, QUOTE_512_BYTES);
1428         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
1429
1430         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1431         sym_op->auth.data.length = QUOTE_512_BYTES;
1432
1433         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1434                         ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1435         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
1436                         ut_params->ibuf, 0);
1437         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1438
1439         rte_memcpy(sym_op->cipher.iv.data, iv,
1440                         CIPHER_IV_LENGTH_AES_CBC);
1441
1442         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1443         sym_op->cipher.data.length = QUOTE_512_BYTES;
1444
1445         /* Process crypto operation */
1446         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1447                         ut_params->op), "failed to process sym crypto op");
1448
1449         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1450                         "crypto op processing failed");
1451
1452         ut_params->obuf = ut_params->op->sym->m_src;
1453
1454         /* Validate obuf */
1455         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1456                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1457                         CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1458                         QUOTE_512_BYTES,
1459                         "Plaintext data not as expected");
1460
1461         /* Validate obuf */
1462         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1463                         "Digest verification failed");
1464
1465         return TEST_SUCCESS;
1466 }
1467
1468 static int
1469 test_AES_chain_mb_all(void)
1470 {
1471         struct crypto_testsuite_params *ts_params = &testsuite_params;
1472         int status;
1473
1474         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1475                 ts_params->op_mpool, ts_params->valid_devs[0],
1476                 RTE_CRYPTODEV_AESNI_MB_PMD,
1477                 BLKCIPHER_AES_CHAIN_TYPE);
1478
1479         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1480
1481         return TEST_SUCCESS;
1482 }
1483
1484 static int
1485 test_AES_chain_openssl_all(void)
1486 {
1487         struct crypto_testsuite_params *ts_params = &testsuite_params;
1488         int status;
1489
1490         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1491                 ts_params->op_mpool, ts_params->valid_devs[0],
1492                 RTE_CRYPTODEV_OPENSSL_PMD,
1493                 BLKCIPHER_AES_CHAIN_TYPE);
1494
1495         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1496
1497         return TEST_SUCCESS;
1498 }
1499
1500 static int
1501 test_AES_cipheronly_openssl_all(void)
1502 {
1503         struct crypto_testsuite_params *ts_params = &testsuite_params;
1504         int status;
1505
1506         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1507                 ts_params->op_mpool, ts_params->valid_devs[0],
1508                 RTE_CRYPTODEV_OPENSSL_PMD,
1509                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1510
1511         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1512
1513         return TEST_SUCCESS;
1514 }
1515
1516 static int
1517 test_AES_chain_qat_all(void)
1518 {
1519         struct crypto_testsuite_params *ts_params = &testsuite_params;
1520         int status;
1521
1522         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1523                 ts_params->op_mpool, ts_params->valid_devs[0],
1524                 RTE_CRYPTODEV_QAT_SYM_PMD,
1525                 BLKCIPHER_AES_CHAIN_TYPE);
1526
1527         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1528
1529         return TEST_SUCCESS;
1530 }
1531
1532 static int
1533 test_AES_cipheronly_qat_all(void)
1534 {
1535         struct crypto_testsuite_params *ts_params = &testsuite_params;
1536         int status;
1537
1538         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1539                 ts_params->op_mpool, ts_params->valid_devs[0],
1540                 RTE_CRYPTODEV_QAT_SYM_PMD,
1541                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1542
1543         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1544
1545         return TEST_SUCCESS;
1546 }
1547
1548 static int
1549 test_authonly_openssl_all(void)
1550 {
1551         struct crypto_testsuite_params *ts_params = &testsuite_params;
1552         int status;
1553
1554         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1555                 ts_params->op_mpool, ts_params->valid_devs[0],
1556                 RTE_CRYPTODEV_OPENSSL_PMD,
1557                 BLKCIPHER_AUTHONLY_TYPE);
1558
1559         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1560
1561         return TEST_SUCCESS;
1562 }
1563
1564 /* ***** SNOW 3G Tests ***** */
1565 static int
1566 create_wireless_algo_hash_session(uint8_t dev_id,
1567         const uint8_t *key, const uint8_t key_len,
1568         const uint8_t aad_len, const uint8_t auth_len,
1569         enum rte_crypto_auth_operation op,
1570         enum rte_crypto_auth_algorithm algo)
1571 {
1572         uint8_t hash_key[key_len];
1573
1574         struct crypto_unittest_params *ut_params = &unittest_params;
1575
1576         memcpy(hash_key, key, key_len);
1577
1578         TEST_HEXDUMP(stdout, "key:", key, key_len);
1579
1580         /* Setup Authentication Parameters */
1581         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1582         ut_params->auth_xform.next = NULL;
1583
1584         ut_params->auth_xform.auth.op = op;
1585         ut_params->auth_xform.auth.algo = algo;
1586         ut_params->auth_xform.auth.key.length = key_len;
1587         ut_params->auth_xform.auth.key.data = hash_key;
1588         ut_params->auth_xform.auth.digest_length = auth_len;
1589         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1590         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1591                                 &ut_params->auth_xform);
1592         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1593         return 0;
1594 }
1595
1596 static int
1597 create_wireless_algo_cipher_session(uint8_t dev_id,
1598                         enum rte_crypto_cipher_operation op,
1599                         enum rte_crypto_cipher_algorithm algo,
1600                         const uint8_t *key, const uint8_t key_len)
1601 {
1602         uint8_t cipher_key[key_len];
1603
1604         struct crypto_unittest_params *ut_params = &unittest_params;
1605
1606         memcpy(cipher_key, key, key_len);
1607
1608         /* Setup Cipher Parameters */
1609         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1610         ut_params->cipher_xform.next = NULL;
1611
1612         ut_params->cipher_xform.cipher.algo = algo;
1613         ut_params->cipher_xform.cipher.op = op;
1614         ut_params->cipher_xform.cipher.key.data = cipher_key;
1615         ut_params->cipher_xform.cipher.key.length = key_len;
1616
1617         TEST_HEXDUMP(stdout, "key:", key, key_len);
1618
1619         /* Create Crypto session */
1620         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1621                                                 &ut_params->
1622                                                 cipher_xform);
1623         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1624         return 0;
1625 }
1626
1627 static int
1628 create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len,
1629                         const unsigned cipher_len,
1630                         const unsigned cipher_offset,
1631                         enum rte_crypto_cipher_algorithm algo)
1632 {
1633         struct crypto_testsuite_params *ts_params = &testsuite_params;
1634         struct crypto_unittest_params *ut_params = &unittest_params;
1635         unsigned iv_pad_len = 0;
1636
1637         /* Generate Crypto op data structure */
1638         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1639                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1640         TEST_ASSERT_NOT_NULL(ut_params->op,
1641                                 "Failed to allocate pktmbuf offload");
1642
1643         /* Set crypto operation data parameters */
1644         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1645
1646         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1647
1648         /* set crypto operation source mbuf */
1649         sym_op->m_src = ut_params->ibuf;
1650
1651         /* iv */
1652         if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1653                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1654         else
1655                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1656
1657         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf
1658                         , iv_pad_len);
1659
1660         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1661
1662         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1663         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1664         sym_op->cipher.iv.length = iv_pad_len;
1665
1666         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1667         sym_op->cipher.data.length = cipher_len;
1668         sym_op->cipher.data.offset = cipher_offset;
1669         return 0;
1670 }
1671
1672 static int
1673 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
1674                         const unsigned cipher_len,
1675                         const unsigned cipher_offset,
1676                         enum rte_crypto_cipher_algorithm algo)
1677 {
1678         struct crypto_testsuite_params *ts_params = &testsuite_params;
1679         struct crypto_unittest_params *ut_params = &unittest_params;
1680         unsigned iv_pad_len = 0;
1681
1682         /* Generate Crypto op data structure */
1683         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1684                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1685         TEST_ASSERT_NOT_NULL(ut_params->op,
1686                                 "Failed to allocate pktmbuf offload");
1687
1688         /* Set crypto operation data parameters */
1689         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1690
1691         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1692
1693         /* set crypto operation source mbuf */
1694         sym_op->m_src = ut_params->ibuf;
1695         sym_op->m_dst = ut_params->obuf;
1696
1697         /* iv */
1698         if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1699                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1700         else
1701                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1702         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1703                                         iv_pad_len);
1704
1705         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1706
1707         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1708         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1709         sym_op->cipher.iv.length = iv_pad_len;
1710
1711         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1712         sym_op->cipher.data.length = cipher_len;
1713         sym_op->cipher.data.offset = cipher_offset;
1714         return 0;
1715 }
1716
1717 static int
1718 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
1719                 enum rte_crypto_cipher_operation cipher_op,
1720                 enum rte_crypto_auth_operation auth_op,
1721                 enum rte_crypto_auth_algorithm auth_algo,
1722                 enum rte_crypto_cipher_algorithm cipher_algo,
1723                 const uint8_t *key, const uint8_t key_len,
1724                 const uint8_t aad_len, const uint8_t auth_len)
1725
1726 {
1727         uint8_t cipher_auth_key[key_len];
1728
1729         struct crypto_unittest_params *ut_params = &unittest_params;
1730
1731         memcpy(cipher_auth_key, key, key_len);
1732
1733         /* Setup Authentication Parameters */
1734         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1735         ut_params->auth_xform.next = NULL;
1736
1737         ut_params->auth_xform.auth.op = auth_op;
1738         ut_params->auth_xform.auth.algo = auth_algo;
1739         ut_params->auth_xform.auth.key.length = key_len;
1740         /* Hash key = cipher key */
1741         ut_params->auth_xform.auth.key.data = cipher_auth_key;
1742         ut_params->auth_xform.auth.digest_length = auth_len;
1743         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1744
1745         /* Setup Cipher Parameters */
1746         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1747         ut_params->cipher_xform.next = &ut_params->auth_xform;
1748
1749         ut_params->cipher_xform.cipher.algo = cipher_algo;
1750         ut_params->cipher_xform.cipher.op = cipher_op;
1751         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
1752         ut_params->cipher_xform.cipher.key.length = key_len;
1753
1754         TEST_HEXDUMP(stdout, "key:", key, key_len);
1755
1756         /* Create Crypto session*/
1757         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1758                                 &ut_params->cipher_xform);
1759
1760         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1761         return 0;
1762 }
1763
1764 static int
1765 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
1766                 enum rte_crypto_cipher_operation cipher_op,
1767                 enum rte_crypto_auth_operation auth_op,
1768                 enum rte_crypto_auth_algorithm auth_algo,
1769                 enum rte_crypto_cipher_algorithm cipher_algo,
1770                 const uint8_t *key, const uint8_t key_len,
1771                 const uint8_t aad_len, const uint8_t auth_len)
1772 {
1773         uint8_t auth_cipher_key[key_len];
1774
1775         struct crypto_unittest_params *ut_params = &unittest_params;
1776
1777         memcpy(auth_cipher_key, key, key_len);
1778
1779         /* Setup Authentication Parameters */
1780         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1781         ut_params->auth_xform.auth.op = auth_op;
1782         ut_params->auth_xform.next = &ut_params->cipher_xform;
1783         ut_params->auth_xform.auth.algo = auth_algo;
1784         ut_params->auth_xform.auth.key.length = key_len;
1785         ut_params->auth_xform.auth.key.data = auth_cipher_key;
1786         ut_params->auth_xform.auth.digest_length = auth_len;
1787         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1788
1789         /* Setup Cipher Parameters */
1790         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1791         ut_params->cipher_xform.next = NULL;
1792         ut_params->cipher_xform.cipher.algo = cipher_algo;
1793         ut_params->cipher_xform.cipher.op = cipher_op;
1794         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
1795         ut_params->cipher_xform.cipher.key.length = key_len;
1796
1797         TEST_HEXDUMP(stdout, "key:", key, key_len);
1798
1799         /* Create Crypto session*/
1800         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1801                                 &ut_params->auth_xform);
1802
1803         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1804
1805         return 0;
1806 }
1807
1808 static int
1809 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
1810                 const unsigned auth_tag_len,
1811                 const uint8_t *aad, const unsigned aad_len,
1812                 unsigned data_pad_len,
1813                 enum rte_crypto_auth_operation op,
1814                 enum rte_crypto_auth_algorithm algo,
1815                 const unsigned auth_len, const unsigned auth_offset)
1816 {
1817         struct crypto_testsuite_params *ts_params = &testsuite_params;
1818
1819         struct crypto_unittest_params *ut_params = &unittest_params;
1820
1821         unsigned aad_buffer_len;
1822
1823         /* Generate Crypto op data structure */
1824         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1825                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1826         TEST_ASSERT_NOT_NULL(ut_params->op,
1827                 "Failed to allocate pktmbuf offload");
1828
1829         /* Set crypto operation data parameters */
1830         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1831
1832         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1833
1834         /* set crypto operation source mbuf */
1835         sym_op->m_src = ut_params->ibuf;
1836
1837         /* aad */
1838         /*
1839         * Always allocate the aad up to the block size.
1840         * The cryptodev API calls out -
1841         *  - the array must be big enough to hold the AAD, plus any
1842         *   space to round this up to the nearest multiple of the
1843         *   block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
1844         */
1845         if (algo == RTE_CRYPTO_AUTH_KASUMI_F9)
1846                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
1847         else
1848                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
1849         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
1850                         ut_params->ibuf, aad_buffer_len);
1851         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
1852                                         "no room to prepend aad");
1853         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
1854                         ut_params->ibuf);
1855         sym_op->auth.aad.length = aad_len;
1856
1857         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
1858         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
1859
1860         TEST_HEXDUMP(stdout, "aad:",
1861                         sym_op->auth.aad.data, aad_len);
1862
1863         /* digest */
1864         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1865                                         ut_params->ibuf, auth_tag_len);
1866
1867         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
1868                                 "no room to append auth tag");
1869         ut_params->digest = sym_op->auth.digest.data;
1870         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1871                         ut_params->ibuf, data_pad_len + aad_len);
1872         sym_op->auth.digest.length = auth_tag_len;
1873         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
1874                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
1875         else
1876                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
1877
1878         TEST_HEXDUMP(stdout, "digest:",
1879                 sym_op->auth.digest.data,
1880                 sym_op->auth.digest.length);
1881
1882         sym_op->auth.data.length = auth_len;
1883         sym_op->auth.data.offset = auth_offset;
1884
1885         return 0;
1886 }
1887
1888 static int
1889 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
1890                 const unsigned auth_tag_len,
1891                 const uint8_t *aad, const uint8_t aad_len,
1892                 unsigned data_pad_len,
1893                 enum rte_crypto_auth_operation op,
1894                 enum rte_crypto_auth_algorithm auth_algo,
1895                 enum rte_crypto_cipher_algorithm cipher_algo,
1896                 const uint8_t *iv, const uint8_t iv_len,
1897                 const unsigned cipher_len, const unsigned cipher_offset,
1898                 const unsigned auth_len, const unsigned auth_offset)
1899 {
1900         struct crypto_testsuite_params *ts_params = &testsuite_params;
1901         struct crypto_unittest_params *ut_params = &unittest_params;
1902
1903         unsigned iv_pad_len = 0;
1904         unsigned aad_buffer_len;
1905
1906         /* Generate Crypto op data structure */
1907         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1908                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1909         TEST_ASSERT_NOT_NULL(ut_params->op,
1910                         "Failed to allocate pktmbuf offload");
1911         /* Set crypto operation data parameters */
1912         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1913
1914         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1915
1916         /* set crypto operation source mbuf */
1917         sym_op->m_src = ut_params->ibuf;
1918
1919         /* digest */
1920         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
1921                         ut_params->ibuf, auth_tag_len);
1922
1923         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
1924                         "no room to append auth tag");
1925         ut_params->digest = sym_op->auth.digest.data;
1926         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1927                         ut_params->ibuf, data_pad_len);
1928         sym_op->auth.digest.length = auth_tag_len;
1929         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
1930                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
1931         else
1932                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
1933
1934         TEST_HEXDUMP(stdout, "digest:",
1935                 sym_op->auth.digest.data,
1936                 sym_op->auth.digest.length);
1937
1938         /* aad */
1939         /*
1940         * Always allocate the aad up to the block size.
1941         * The cryptodev API calls out -
1942         *  - the array must be big enough to hold the AAD, plus any
1943         *   space to round this up to the nearest multiple of the
1944         *   block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
1945         */
1946         if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
1947                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
1948         else
1949                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
1950         sym_op->auth.aad.data =
1951                 (uint8_t *)rte_pktmbuf_prepend(
1952                         ut_params->ibuf, aad_buffer_len);
1953         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
1954                         "no room to prepend aad");
1955         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
1956                         ut_params->ibuf);
1957         sym_op->auth.aad.length = aad_len;
1958         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
1959         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
1960         TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
1961
1962         /* iv */
1963         if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1964                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1965         else
1966                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1967         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1968                 ut_params->ibuf, iv_pad_len);
1969
1970         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1971         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1972         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1973         sym_op->cipher.iv.length = iv_pad_len;
1974         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1975         sym_op->cipher.data.length = cipher_len;
1976         sym_op->cipher.data.offset = cipher_offset + auth_offset;
1977         sym_op->auth.data.length = auth_len;
1978         sym_op->auth.data.offset = auth_offset + cipher_offset;
1979
1980         return 0;
1981 }
1982
1983 static int
1984 create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len,
1985                 const uint8_t *iv, const uint8_t iv_len,
1986                 const uint8_t *aad, const uint8_t aad_len,
1987                 unsigned data_pad_len,
1988                 const unsigned cipher_len, const unsigned cipher_offset,
1989                 const unsigned auth_len, const unsigned auth_offset,
1990                 enum rte_crypto_auth_algorithm auth_algo,
1991                 enum rte_crypto_cipher_algorithm cipher_algo)
1992 {
1993         struct crypto_testsuite_params *ts_params = &testsuite_params;
1994         struct crypto_unittest_params *ut_params = &unittest_params;
1995
1996         unsigned iv_pad_len = 0;
1997         unsigned aad_buffer_len = 0;
1998
1999         /* Generate Crypto op data structure */
2000         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2001                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2002         TEST_ASSERT_NOT_NULL(ut_params->op,
2003                         "Failed to allocate pktmbuf offload");
2004
2005         /* Set crypto operation data parameters */
2006         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2007
2008         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2009
2010         /* set crypto operation source mbuf */
2011         sym_op->m_src = ut_params->ibuf;
2012
2013         /* digest */
2014         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2015                         ut_params->ibuf, auth_tag_len);
2016
2017         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2018                         "no room to append auth tag");
2019
2020         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2021                         ut_params->ibuf, data_pad_len);
2022         sym_op->auth.digest.length = auth_tag_len;
2023
2024         memset(sym_op->auth.digest.data, 0, auth_tag_len);
2025
2026         TEST_HEXDUMP(stdout, "digest:",
2027                         sym_op->auth.digest.data,
2028                         sym_op->auth.digest.length);
2029
2030         /* aad */
2031         /*
2032         * Always allocate the aad up to the block size.
2033         * The cryptodev API calls out -
2034         *  - the array must be big enough to hold the AAD, plus any
2035         *   space to round this up to the nearest multiple of the
2036         *   block size (8 bytes for KASUMI 16 bytes).
2037         */
2038         if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2039                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2040         else
2041                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2042         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
2043         ut_params->ibuf, aad_buffer_len);
2044         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2045                                 "no room to prepend aad");
2046         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2047                                 ut_params->ibuf);
2048         sym_op->auth.aad.length = aad_len;
2049         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2050         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2051         TEST_HEXDUMP(stdout, "aad:",
2052                         sym_op->auth.aad.data, aad_len);
2053
2054         /* iv */
2055         if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
2056                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
2057         else
2058                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2059
2060         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2061                 ut_params->ibuf, iv_pad_len);
2062         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2063
2064         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2065         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2066         sym_op->cipher.iv.length = iv_pad_len;
2067
2068         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2069
2070         sym_op->cipher.data.length = cipher_len;
2071         sym_op->cipher.data.offset = auth_offset + cipher_offset;
2072
2073         sym_op->auth.data.length = auth_len;
2074         sym_op->auth.data.offset = auth_offset + cipher_offset;
2075
2076         return 0;
2077 }
2078
2079 static int
2080 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2081 {
2082         struct crypto_testsuite_params *ts_params = &testsuite_params;
2083         struct crypto_unittest_params *ut_params = &unittest_params;
2084
2085         int retval;
2086         unsigned plaintext_pad_len;
2087         unsigned plaintext_len;
2088         uint8_t *plaintext;
2089
2090         /* Create SNOW 3G session */
2091         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2092                         tdata->key.data, tdata->key.len,
2093                         tdata->aad.len, tdata->digest.len,
2094                         RTE_CRYPTO_AUTH_OP_GENERATE,
2095                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2096         if (retval < 0)
2097                 return retval;
2098
2099         /* alloc mbuf and set payload */
2100         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2101
2102         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2103         rte_pktmbuf_tailroom(ut_params->ibuf));
2104
2105         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2106         /* Append data which is padded to a multiple of */
2107         /* the algorithms block size */
2108         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2109         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2110                                 plaintext_pad_len);
2111         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2112
2113         /* Create SNOW 3G operation */
2114         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2115                         tdata->aad.data, tdata->aad.len,
2116                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2117                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2118                         tdata->validAuthLenInBits.len,
2119                         tdata->validAuthOffsetLenInBits.len);
2120         if (retval < 0)
2121                 return retval;
2122
2123         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2124                                 ut_params->op);
2125         ut_params->obuf = ut_params->op->sym->m_src;
2126         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2127         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2128                         + plaintext_pad_len + tdata->aad.len;
2129
2130         /* Validate obuf */
2131         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2132         ut_params->digest,
2133         tdata->digest.data,
2134         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2135         "SNOW 3G Generated auth tag not as expected");
2136
2137         return 0;
2138 }
2139
2140 static int
2141 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2142 {
2143         struct crypto_testsuite_params *ts_params = &testsuite_params;
2144         struct crypto_unittest_params *ut_params = &unittest_params;
2145
2146         int retval;
2147         unsigned plaintext_pad_len;
2148         unsigned plaintext_len;
2149         uint8_t *plaintext;
2150
2151         /* Create SNOW 3G session */
2152         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2153                                 tdata->key.data, tdata->key.len,
2154                                 tdata->aad.len, tdata->digest.len,
2155                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2156                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2157         if (retval < 0)
2158                 return retval;
2159         /* alloc mbuf and set payload */
2160         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2161
2162         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2163         rte_pktmbuf_tailroom(ut_params->ibuf));
2164
2165         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2166         /* Append data which is padded to a multiple of */
2167         /* the algorithms block size */
2168         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2169         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2170                                 plaintext_pad_len);
2171         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2172
2173         /* Create SNOW 3G operation */
2174         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2175                         tdata->digest.len,
2176                         tdata->aad.data, tdata->aad.len,
2177                         plaintext_pad_len,
2178                         RTE_CRYPTO_AUTH_OP_VERIFY,
2179                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2180                         tdata->validAuthLenInBits.len,
2181                         tdata->validAuthOffsetLenInBits.len);
2182         if (retval < 0)
2183                 return retval;
2184
2185         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2186                                 ut_params->op);
2187         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2188         ut_params->obuf = ut_params->op->sym->m_src;
2189         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2190                                 + plaintext_pad_len + tdata->aad.len;
2191
2192         /* Validate obuf */
2193         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2194                 return 0;
2195         else
2196                 return -1;
2197
2198         return 0;
2199 }
2200
2201 static int
2202 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2203 {
2204         struct crypto_testsuite_params *ts_params = &testsuite_params;
2205         struct crypto_unittest_params *ut_params = &unittest_params;
2206
2207         int retval;
2208         unsigned plaintext_pad_len;
2209         unsigned plaintext_len;
2210         uint8_t *plaintext;
2211
2212         /* Create KASUMI session */
2213         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2214                         tdata->key.data, tdata->key.len,
2215                         tdata->aad.len, tdata->digest.len,
2216                         RTE_CRYPTO_AUTH_OP_GENERATE,
2217                         RTE_CRYPTO_AUTH_KASUMI_F9);
2218         if (retval < 0)
2219                 return retval;
2220
2221         /* alloc mbuf and set payload */
2222         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2223
2224         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2225         rte_pktmbuf_tailroom(ut_params->ibuf));
2226
2227         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2228         /* Append data which is padded to a multiple of */
2229         /* the algorithms block size */
2230         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2231         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2232                                 plaintext_pad_len);
2233         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2234
2235         /* Create KASUMI operation */
2236         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2237                         tdata->aad.data, tdata->aad.len,
2238                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2239                         RTE_CRYPTO_AUTH_KASUMI_F9,
2240                         tdata->validAuthLenInBits.len,
2241                         tdata->validAuthOffsetLenInBits.len);
2242         if (retval < 0)
2243                 return retval;
2244
2245         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2246                                 ut_params->op);
2247         ut_params->obuf = ut_params->op->sym->m_src;
2248         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2249         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2250                         + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
2251
2252         /* Validate obuf */
2253         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2254         ut_params->digest,
2255         tdata->digest.data,
2256         DIGEST_BYTE_LENGTH_KASUMI_F9,
2257         "KASUMI Generated auth tag not as expected");
2258
2259         return 0;
2260 }
2261
2262 static int
2263 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
2264 {
2265         struct crypto_testsuite_params *ts_params = &testsuite_params;
2266         struct crypto_unittest_params *ut_params = &unittest_params;
2267
2268         int retval;
2269         unsigned plaintext_pad_len;
2270         unsigned plaintext_len;
2271         uint8_t *plaintext;
2272
2273         /* Create KASUMI session */
2274         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2275                                 tdata->key.data, tdata->key.len,
2276                                 tdata->aad.len, tdata->digest.len,
2277                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2278                                 RTE_CRYPTO_AUTH_KASUMI_F9);
2279         if (retval < 0)
2280                 return retval;
2281         /* alloc mbuf and set payload */
2282         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2283
2284         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2285         rte_pktmbuf_tailroom(ut_params->ibuf));
2286
2287         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2288         /* Append data which is padded to a multiple */
2289         /* of the algorithms block size */
2290         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2291         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2292                                 plaintext_pad_len);
2293         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2294
2295         /* Create KASUMI operation */
2296         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2297                         tdata->digest.len,
2298                         tdata->aad.data, tdata->aad.len,
2299                         plaintext_pad_len,
2300                         RTE_CRYPTO_AUTH_OP_VERIFY,
2301                         RTE_CRYPTO_AUTH_KASUMI_F9,
2302                         tdata->validAuthLenInBits.len,
2303                         tdata->validAuthOffsetLenInBits.len);
2304         if (retval < 0)
2305                 return retval;
2306
2307         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2308                                 ut_params->op);
2309         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2310         ut_params->obuf = ut_params->op->sym->m_src;
2311         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2312                                 + plaintext_pad_len + tdata->aad.len;
2313
2314         /* Validate obuf */
2315         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2316                 return 0;
2317         else
2318                 return -1;
2319
2320         return 0;
2321 }
2322
2323 static int
2324 test_snow3g_hash_generate_test_case_1(void)
2325 {
2326         return test_snow3g_authentication(&snow3g_hash_test_case_1);
2327 }
2328
2329 static int
2330 test_snow3g_hash_generate_test_case_2(void)
2331 {
2332         return test_snow3g_authentication(&snow3g_hash_test_case_2);
2333 }
2334
2335 static int
2336 test_snow3g_hash_generate_test_case_3(void)
2337 {
2338         return test_snow3g_authentication(&snow3g_hash_test_case_3);
2339 }
2340
2341 static int
2342 test_snow3g_hash_generate_test_case_4(void)
2343 {
2344         return test_snow3g_authentication(&snow3g_hash_test_case_4);
2345 }
2346
2347 static int
2348 test_snow3g_hash_generate_test_case_5(void)
2349 {
2350         return test_snow3g_authentication(&snow3g_hash_test_case_5);
2351 }
2352
2353 static int
2354 test_snow3g_hash_generate_test_case_6(void)
2355 {
2356         return test_snow3g_authentication(&snow3g_hash_test_case_6);
2357 }
2358
2359 static int
2360 test_snow3g_hash_verify_test_case_1(void)
2361 {
2362         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
2363
2364 }
2365
2366 static int
2367 test_snow3g_hash_verify_test_case_2(void)
2368 {
2369         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
2370 }
2371
2372 static int
2373 test_snow3g_hash_verify_test_case_3(void)
2374 {
2375         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
2376 }
2377
2378 static int
2379 test_snow3g_hash_verify_test_case_4(void)
2380 {
2381         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
2382 }
2383
2384 static int
2385 test_snow3g_hash_verify_test_case_5(void)
2386 {
2387         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
2388 }
2389
2390 static int
2391 test_snow3g_hash_verify_test_case_6(void)
2392 {
2393         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
2394 }
2395
2396 static int
2397 test_kasumi_hash_generate_test_case_1(void)
2398 {
2399         return test_kasumi_authentication(&kasumi_hash_test_case_1);
2400 }
2401
2402 static int
2403 test_kasumi_hash_generate_test_case_2(void)
2404 {
2405         return test_kasumi_authentication(&kasumi_hash_test_case_2);
2406 }
2407
2408 static int
2409 test_kasumi_hash_generate_test_case_3(void)
2410 {
2411         return test_kasumi_authentication(&kasumi_hash_test_case_3);
2412 }
2413
2414 static int
2415 test_kasumi_hash_generate_test_case_4(void)
2416 {
2417         return test_kasumi_authentication(&kasumi_hash_test_case_4);
2418 }
2419
2420 static int
2421 test_kasumi_hash_generate_test_case_5(void)
2422 {
2423         return test_kasumi_authentication(&kasumi_hash_test_case_5);
2424 }
2425
2426 static int
2427 test_kasumi_hash_generate_test_case_6(void)
2428 {
2429         return test_kasumi_authentication(&kasumi_hash_test_case_6);
2430 }
2431
2432 static int
2433 test_kasumi_hash_verify_test_case_1(void)
2434 {
2435         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
2436 }
2437
2438 static int
2439 test_kasumi_hash_verify_test_case_2(void)
2440 {
2441         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
2442 }
2443
2444 static int
2445 test_kasumi_hash_verify_test_case_3(void)
2446 {
2447         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
2448 }
2449
2450 static int
2451 test_kasumi_hash_verify_test_case_4(void)
2452 {
2453         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
2454 }
2455
2456 static int
2457 test_kasumi_hash_verify_test_case_5(void)
2458 {
2459         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
2460 }
2461
2462 static int
2463 test_kasumi_encryption(const struct kasumi_test_data *tdata)
2464 {
2465         struct crypto_testsuite_params *ts_params = &testsuite_params;
2466         struct crypto_unittest_params *ut_params = &unittest_params;
2467
2468         int retval;
2469         uint8_t *plaintext, *ciphertext;
2470         unsigned plaintext_pad_len;
2471         unsigned plaintext_len;
2472
2473         /* Create KASUMI session */
2474         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2475                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2476                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2477                                         tdata->key.data, tdata->key.len);
2478         if (retval < 0)
2479                 return retval;
2480
2481         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2482
2483         /* Clear mbuf payload */
2484         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2485                rte_pktmbuf_tailroom(ut_params->ibuf));
2486
2487         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2488         /* Append data which is padded to a multiple */
2489         /* of the algorithms block size */
2490         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2491         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2492                                 plaintext_pad_len);
2493         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2494
2495         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2496
2497         /* Create KASUMI operation */
2498         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
2499                                         tdata->plaintext.len,
2500                                         tdata->validCipherOffsetLenInBits.len,
2501                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2502         if (retval < 0)
2503                 return retval;
2504
2505         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2506                                                 ut_params->op);
2507         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2508
2509         ut_params->obuf = ut_params->op->sym->m_dst;
2510         if (ut_params->obuf)
2511                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2512                                 + tdata->iv.len;
2513         else
2514                 ciphertext = plaintext;
2515
2516         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2517
2518         /* Validate obuf */
2519         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2520                 ciphertext,
2521                 tdata->ciphertext.data,
2522                 tdata->validCipherLenInBits.len,
2523                 "KASUMI Ciphertext data not as expected");
2524         return 0;
2525 }
2526
2527 static int
2528 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
2529 {
2530         struct crypto_testsuite_params *ts_params = &testsuite_params;
2531         struct crypto_unittest_params *ut_params = &unittest_params;
2532
2533         int retval;
2534         uint8_t *plaintext, *ciphertext;
2535         unsigned plaintext_pad_len;
2536         unsigned plaintext_len;
2537
2538         /* Create KASUMI session */
2539         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2540                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2541                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2542                                         tdata->key.data, tdata->key.len);
2543         if (retval < 0)
2544                 return retval;
2545
2546         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2547         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2548
2549         /* Clear mbuf payload */
2550         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2551                rte_pktmbuf_tailroom(ut_params->ibuf));
2552
2553         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2554         /* Append data which is padded to a multiple */
2555         /* of the algorithms block size */
2556         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2557         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2558                                 plaintext_pad_len);
2559         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2560         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2561
2562         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2563
2564         /* Create KASUMI operation */
2565         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
2566                                         tdata->iv.len,
2567                                         tdata->plaintext.len,
2568                                         tdata->validCipherOffsetLenInBits.len,
2569                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2570         if (retval < 0)
2571                 return retval;
2572
2573         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2574                                                 ut_params->op);
2575         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2576
2577         ut_params->obuf = ut_params->op->sym->m_dst;
2578         if (ut_params->obuf)
2579                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2580                                 + tdata->iv.len;
2581         else
2582                 ciphertext = plaintext;
2583
2584         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2585
2586         /* Validate obuf */
2587         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2588                 ciphertext,
2589                 tdata->ciphertext.data,
2590                 tdata->validCipherLenInBits.len,
2591                 "KASUMI Ciphertext data not as expected");
2592         return 0;
2593 }
2594
2595 static int
2596 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
2597 {
2598         struct crypto_testsuite_params *ts_params = &testsuite_params;
2599         struct crypto_unittest_params *ut_params = &unittest_params;
2600
2601         int retval;
2602         uint8_t *ciphertext, *plaintext;
2603         unsigned ciphertext_pad_len;
2604         unsigned ciphertext_len;
2605
2606         /* Create KASUMI session */
2607         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2608                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
2609                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2610                                         tdata->key.data, tdata->key.len);
2611         if (retval < 0)
2612                 return retval;
2613
2614         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2615         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2616
2617         /* Clear mbuf payload */
2618         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2619                rte_pktmbuf_tailroom(ut_params->ibuf));
2620
2621         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2622         /* Append data which is padded to a multiple */
2623         /* of the algorithms block size */
2624         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
2625         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2626                                 ciphertext_pad_len);
2627         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
2628         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2629
2630         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
2631
2632         /* Create KASUMI operation */
2633         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
2634                                         tdata->iv.len,
2635                                         tdata->ciphertext.len,
2636                                         tdata->validCipherOffsetLenInBits.len,
2637                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2638         if (retval < 0)
2639                 return retval;
2640
2641         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2642                                                 ut_params->op);
2643         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2644
2645         ut_params->obuf = ut_params->op->sym->m_dst;
2646         if (ut_params->obuf)
2647                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2648                                 + tdata->iv.len;
2649         else
2650                 plaintext = ciphertext;
2651
2652         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
2653
2654         /* Validate obuf */
2655         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2656                 plaintext,
2657                 tdata->plaintext.data,
2658                 tdata->validCipherLenInBits.len,
2659                 "KASUMI Plaintext data not as expected");
2660         return 0;
2661 }
2662
2663 static int
2664 test_kasumi_decryption(const struct kasumi_test_data *tdata)
2665 {
2666         struct crypto_testsuite_params *ts_params = &testsuite_params;
2667         struct crypto_unittest_params *ut_params = &unittest_params;
2668
2669         int retval;
2670         uint8_t *ciphertext, *plaintext;
2671         unsigned ciphertext_pad_len;
2672         unsigned ciphertext_len;
2673
2674         /* Create KASUMI session */
2675         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2676                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
2677                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2678                                         tdata->key.data, tdata->key.len);
2679         if (retval < 0)
2680                 return retval;
2681
2682         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2683
2684         /* Clear mbuf payload */
2685         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2686                rte_pktmbuf_tailroom(ut_params->ibuf));
2687
2688         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2689         /* Append data which is padded to a multiple */
2690         /* of the algorithms block size */
2691         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
2692         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2693                                 ciphertext_pad_len);
2694         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2695
2696         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
2697
2698         /* Create KASUMI operation */
2699         retval = create_wireless_algo_cipher_operation(tdata->iv.data,
2700                                         tdata->iv.len,
2701                                         tdata->ciphertext.len,
2702                                         tdata->validCipherOffsetLenInBits.len,
2703                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2704         if (retval < 0)
2705                 return retval;
2706
2707         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2708                                                 ut_params->op);
2709         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2710
2711         ut_params->obuf = ut_params->op->sym->m_dst;
2712         if (ut_params->obuf)
2713                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2714                                 + tdata->iv.len;
2715         else
2716                 plaintext = ciphertext;
2717
2718         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
2719
2720         /* Validate obuf */
2721         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2722                 plaintext,
2723                 tdata->plaintext.data,
2724                 tdata->validCipherLenInBits.len,
2725                 "KASUMI Plaintext data not as expected");
2726         return 0;
2727 }
2728
2729 static int
2730 test_snow3g_encryption(const struct snow3g_test_data *tdata)
2731 {
2732         struct crypto_testsuite_params *ts_params = &testsuite_params;
2733         struct crypto_unittest_params *ut_params = &unittest_params;
2734
2735         int retval;
2736         uint8_t *plaintext, *ciphertext;
2737         unsigned plaintext_pad_len;
2738         unsigned plaintext_len;
2739
2740         /* Create SNOW 3G session */
2741         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2742                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2743                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2744                                         tdata->key.data, tdata->key.len);
2745         if (retval < 0)
2746                 return retval;
2747
2748         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2749
2750         /* Clear mbuf payload */
2751         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2752                rte_pktmbuf_tailroom(ut_params->ibuf));
2753
2754         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2755         /* Append data which is padded to a multiple of */
2756         /* the algorithms block size */
2757         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2758         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2759                                 plaintext_pad_len);
2760         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2761
2762         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2763
2764         /* Create SNOW 3G operation */
2765         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
2766                                         tdata->validCipherLenInBits.len,
2767                                         tdata->validCipherOffsetLenInBits.len,
2768                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2769         if (retval < 0)
2770                 return retval;
2771
2772         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2773                                                 ut_params->op);
2774         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2775
2776         ut_params->obuf = ut_params->op->sym->m_dst;
2777         if (ut_params->obuf)
2778                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2779                                 + tdata->iv.len;
2780         else
2781                 ciphertext = plaintext;
2782
2783         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2784
2785         /* Validate obuf */
2786         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2787                 ciphertext,
2788                 tdata->ciphertext.data,
2789                 tdata->validDataLenInBits.len,
2790                 "SNOW 3G Ciphertext data not as expected");
2791         return 0;
2792 }
2793
2794
2795 static int
2796 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
2797 {
2798         struct crypto_testsuite_params *ts_params = &testsuite_params;
2799         struct crypto_unittest_params *ut_params = &unittest_params;
2800         uint8_t *plaintext, *ciphertext;
2801
2802         int retval;
2803         unsigned plaintext_pad_len;
2804         unsigned plaintext_len;
2805
2806         /* Create SNOW 3G session */
2807         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2808                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2809                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2810                                         tdata->key.data, tdata->key.len);
2811         if (retval < 0)
2812                 return retval;
2813
2814         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2815         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2816
2817         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2818                         "Failed to allocate input buffer in mempool");
2819         TEST_ASSERT_NOT_NULL(ut_params->obuf,
2820                         "Failed to allocate output buffer in mempool");
2821
2822         /* Clear mbuf payload */
2823         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2824                rte_pktmbuf_tailroom(ut_params->ibuf));
2825
2826         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2827         /* Append data which is padded to a multiple of */
2828         /* the algorithms block size */
2829         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2830         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2831                                 plaintext_pad_len);
2832         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2833         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2834
2835         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2836
2837         /* Create SNOW 3G operation */
2838         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
2839                                         tdata->iv.len,
2840                                         tdata->validCipherLenInBits.len,
2841                                         tdata->validCipherOffsetLenInBits.len,
2842                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2843         if (retval < 0)
2844                 return retval;
2845
2846         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2847                                                 ut_params->op);
2848         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2849
2850         ut_params->obuf = ut_params->op->sym->m_dst;
2851         if (ut_params->obuf)
2852                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2853                                 + tdata->iv.len;
2854         else
2855                 ciphertext = plaintext;
2856
2857         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2858
2859         /* Validate obuf */
2860         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2861                 ciphertext,
2862                 tdata->ciphertext.data,
2863                 tdata->validDataLenInBits.len,
2864                 "SNOW 3G Ciphertext data not as expected");
2865         return 0;
2866 }
2867
2868 /* Shift right a buffer by "offset" bits, "offset" < 8 */
2869 static void
2870 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
2871 {
2872         uint8_t curr_byte, prev_byte;
2873         uint32_t length_in_bytes = ceil_byte_length(length + offset);
2874         uint8_t lower_byte_mask = (1 << offset) - 1;
2875         unsigned i;
2876
2877         prev_byte = buffer[0];
2878         buffer[0] >>= offset;
2879
2880         for (i = 1; i < length_in_bytes; i++) {
2881                 curr_byte = buffer[i];
2882                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
2883                                 (curr_byte >> offset);
2884                 prev_byte = curr_byte;
2885         }
2886 }
2887
2888 static int
2889 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
2890 {
2891         struct crypto_testsuite_params *ts_params = &testsuite_params;
2892         struct crypto_unittest_params *ut_params = &unittest_params;
2893         uint8_t *plaintext, *ciphertext;
2894         int retval;
2895         uint32_t plaintext_len;
2896         uint32_t plaintext_pad_len;
2897         uint8_t extra_offset = 4;
2898         uint8_t *expected_ciphertext_shifted;
2899
2900         /* Create SNOW 3G session */
2901         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2902                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2903                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2904                                         tdata->key.data, tdata->key.len);
2905         if (retval < 0)
2906                 return retval;
2907
2908         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2909         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2910
2911         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
2912                         "Failed to allocate input buffer in mempool");
2913         TEST_ASSERT_NOT_NULL(ut_params->obuf,
2914                         "Failed to allocate output buffer in mempool");
2915
2916         /* Clear mbuf payload */
2917         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2918                rte_pktmbuf_tailroom(ut_params->ibuf));
2919
2920         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
2921         /*
2922          * Append data which is padded to a
2923          * multiple of the algorithms block size
2924          */
2925         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2926
2927         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
2928                                                 plaintext_pad_len);
2929
2930         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2931
2932         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
2933         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
2934
2935 #ifdef RTE_APP_TEST_DEBUG
2936         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
2937 #endif
2938         /* Create SNOW 3G operation */
2939         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
2940                                         tdata->iv.len,
2941                                         tdata->validCipherLenInBits.len,
2942                                         tdata->validCipherOffsetLenInBits.len +
2943                                         extra_offset,
2944                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
2945         if (retval < 0)
2946                 return retval;
2947
2948         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2949                                                 ut_params->op);
2950         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2951
2952         ut_params->obuf = ut_params->op->sym->m_dst;
2953         if (ut_params->obuf)
2954                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2955                                 + tdata->iv.len;
2956         else
2957                 ciphertext = plaintext;
2958
2959 #ifdef RTE_APP_TEST_DEBUG
2960         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
2961 #endif
2962
2963         expected_ciphertext_shifted = rte_malloc(NULL,
2964                         ceil_byte_length(plaintext_len + extra_offset), 0);
2965
2966         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
2967                         "failed to reserve memory for ciphertext shifted\n");
2968
2969         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
2970                         ceil_byte_length(tdata->ciphertext.len));
2971         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
2972                         extra_offset);
2973         /* Validate obuf */
2974         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
2975                 ciphertext,
2976                 expected_ciphertext_shifted,
2977                 tdata->validDataLenInBits.len,
2978                 extra_offset,
2979                 "SNOW 3G Ciphertext data not as expected");
2980         return 0;
2981 }
2982
2983 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
2984 {
2985         struct crypto_testsuite_params *ts_params = &testsuite_params;
2986         struct crypto_unittest_params *ut_params = &unittest_params;
2987
2988         int retval;
2989
2990         uint8_t *plaintext, *ciphertext;
2991         unsigned ciphertext_pad_len;
2992         unsigned ciphertext_len;
2993
2994         /* Create SNOW 3G session */
2995         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2996                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
2997                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2998                                         tdata->key.data, tdata->key.len);
2999         if (retval < 0)
3000                 return retval;
3001
3002         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3003
3004         /* Clear mbuf payload */
3005         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3006                rte_pktmbuf_tailroom(ut_params->ibuf));
3007
3008         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3009         /* Append data which is padded to a multiple of */
3010         /* the algorithms block size */
3011         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3012         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3013                                 ciphertext_pad_len);
3014         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3015
3016         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3017
3018         /* Create SNOW 3G operation */
3019         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3020                                         tdata->validCipherLenInBits.len,
3021                                         tdata->validCipherOffsetLenInBits.len,
3022                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3023         if (retval < 0)
3024                 return retval;
3025
3026         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3027                                                 ut_params->op);
3028         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3029         ut_params->obuf = ut_params->op->sym->m_dst;
3030         if (ut_params->obuf)
3031                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3032                                 + tdata->iv.len;
3033         else
3034                 plaintext = ciphertext;
3035
3036         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3037
3038         /* Validate obuf */
3039         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3040                                 tdata->plaintext.data,
3041                                 tdata->validDataLenInBits.len,
3042                                 "SNOW 3G Plaintext data not as expected");
3043         return 0;
3044 }
3045
3046 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
3047 {
3048         struct crypto_testsuite_params *ts_params = &testsuite_params;
3049         struct crypto_unittest_params *ut_params = &unittest_params;
3050
3051         int retval;
3052
3053         uint8_t *plaintext, *ciphertext;
3054         unsigned ciphertext_pad_len;
3055         unsigned ciphertext_len;
3056
3057         /* Create SNOW 3G session */
3058         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3059                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3060                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3061                                         tdata->key.data, tdata->key.len);
3062         if (retval < 0)
3063                 return retval;
3064
3065         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3066         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3067
3068         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3069                         "Failed to allocate input buffer");
3070         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3071                         "Failed to allocate output buffer");
3072
3073         /* Clear mbuf payload */
3074         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3075                rte_pktmbuf_tailroom(ut_params->ibuf));
3076
3077         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
3078                        rte_pktmbuf_tailroom(ut_params->obuf));
3079
3080         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3081         /* Append data which is padded to a multiple of */
3082         /* the algorithms block size */
3083         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3084         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3085                                 ciphertext_pad_len);
3086         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3087         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3088
3089         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3090
3091         /* Create SNOW 3G operation */
3092         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3093                                         tdata->iv.len,
3094                                         tdata->validCipherLenInBits.len,
3095                                         tdata->validCipherOffsetLenInBits.len,
3096                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3097         if (retval < 0)
3098                 return retval;
3099
3100         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3101                                                 ut_params->op);
3102         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3103         ut_params->obuf = ut_params->op->sym->m_dst;
3104         if (ut_params->obuf)
3105                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3106                                 + tdata->iv.len;
3107         else
3108                 plaintext = ciphertext;
3109
3110         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3111
3112         /* Validate obuf */
3113         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3114                                 tdata->plaintext.data,
3115                                 tdata->validDataLenInBits.len,
3116                                 "SNOW 3G Plaintext data not as expected");
3117         return 0;
3118 }
3119
3120 static int
3121 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
3122 {
3123         struct crypto_testsuite_params *ts_params = &testsuite_params;
3124         struct crypto_unittest_params *ut_params = &unittest_params;
3125
3126         int retval;
3127
3128         uint8_t *plaintext, *ciphertext;
3129         unsigned plaintext_pad_len;
3130         unsigned plaintext_len;
3131
3132         /* Create SNOW 3G session */
3133         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
3134                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3135                         RTE_CRYPTO_AUTH_OP_GENERATE,
3136                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3137                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3138                         tdata->key.data, tdata->key.len,
3139                         tdata->aad.len, tdata->digest.len);
3140         if (retval < 0)
3141                 return retval;
3142         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3143
3144         /* clear mbuf payload */
3145         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3146                         rte_pktmbuf_tailroom(ut_params->ibuf));
3147
3148         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3149         /* Append data which is padded to a multiple of */
3150         /* the algorithms block size */
3151         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3152         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3153                                 plaintext_pad_len);
3154         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3155
3156         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3157
3158         /* Create SNOW 3G operation */
3159         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3160                         tdata->digest.len, tdata->aad.data,
3161                         tdata->aad.len, /*tdata->plaintext.len,*/
3162                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3163                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3164                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3165                         tdata->iv.data, tdata->iv.len,
3166                         tdata->validCipherLenInBits.len,
3167                         tdata->validCipherOffsetLenInBits.len,
3168                         tdata->validAuthLenInBits.len,
3169                         tdata->validAuthOffsetLenInBits.len
3170                         );
3171         if (retval < 0)
3172                 return retval;
3173
3174         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3175                         ut_params->op);
3176         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3177         ut_params->obuf = ut_params->op->sym->m_src;
3178         if (ut_params->obuf)
3179                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3180                                 + tdata->iv.len + tdata->aad.len;
3181         else
3182                 ciphertext = plaintext;
3183
3184         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3185         /* Validate obuf */
3186         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3187                         ciphertext,
3188                         tdata->ciphertext.data,
3189                         tdata->validDataLenInBits.len,
3190                         "SNOW 3G Ciphertext data not as expected");
3191
3192         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3193             + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3194
3195         /* Validate obuf */
3196         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3197                         ut_params->digest,
3198                         tdata->digest.data,
3199                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3200                         "SNOW 3G Generated auth tag not as expected");
3201         return 0;
3202 }
3203 static int
3204 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
3205 {
3206         struct crypto_testsuite_params *ts_params = &testsuite_params;
3207         struct crypto_unittest_params *ut_params = &unittest_params;
3208
3209         int retval;
3210
3211         uint8_t *plaintext, *ciphertext;
3212         unsigned plaintext_pad_len;
3213         unsigned plaintext_len;
3214
3215         /* Create SNOW 3G session */
3216         retval = create_wireless_algo_auth_cipher_session(ts_params->valid_devs[0],
3217                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3218                         RTE_CRYPTO_AUTH_OP_GENERATE,
3219                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3220                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3221                         tdata->key.data, tdata->key.len,
3222                         tdata->aad.len, tdata->digest.len);
3223         if (retval < 0)
3224                 return retval;
3225
3226         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3227
3228         /* clear mbuf payload */
3229         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3230                         rte_pktmbuf_tailroom(ut_params->ibuf));
3231
3232         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3233         /* Append data which is padded to a multiple of */
3234         /* the algorithms block size */
3235         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3236         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3237                                 plaintext_pad_len);
3238         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3239
3240         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3241
3242         /* Create SNOW 3G operation */
3243         retval = create_wireless_algo_auth_cipher_operation(
3244                 tdata->digest.len,
3245                 tdata->iv.data, tdata->iv.len,
3246                 tdata->aad.data, tdata->aad.len,
3247                 plaintext_pad_len,
3248                 tdata->validCipherLenInBits.len,
3249                 tdata->validCipherOffsetLenInBits.len,
3250                 tdata->validAuthLenInBits.len,
3251                 tdata->validAuthOffsetLenInBits.len,
3252                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3253                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
3254         );
3255
3256         if (retval < 0)
3257                 return retval;
3258
3259         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3260                         ut_params->op);
3261         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3262         ut_params->obuf = ut_params->op->sym->m_src;
3263         if (ut_params->obuf)
3264                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3265                                 + tdata->aad.len + tdata->iv.len;
3266         else
3267                 ciphertext = plaintext;
3268
3269         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3270                         + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3271         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3272
3273         /* Validate obuf */
3274         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3275                 ciphertext,
3276                 tdata->ciphertext.data,
3277                 tdata->validDataLenInBits.len,
3278                 "SNOW 3G Ciphertext data not as expected");
3279
3280         /* Validate obuf */
3281         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3282                 ut_params->digest,
3283                 tdata->digest.data,
3284                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3285                 "SNOW 3G Generated auth tag not as expected");
3286         return 0;
3287 }
3288
3289 static int
3290 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
3291 {
3292         struct crypto_testsuite_params *ts_params = &testsuite_params;
3293         struct crypto_unittest_params *ut_params = &unittest_params;
3294
3295         int retval;
3296
3297         uint8_t *plaintext, *ciphertext;
3298         unsigned plaintext_pad_len;
3299         unsigned plaintext_len;
3300
3301         /* Create KASUMI session */
3302         retval = create_wireless_algo_auth_cipher_session(
3303                         ts_params->valid_devs[0],
3304                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3305                         RTE_CRYPTO_AUTH_OP_GENERATE,
3306                         RTE_CRYPTO_AUTH_KASUMI_F9,
3307                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3308                         tdata->key.data, tdata->key.len,
3309                         tdata->aad.len, tdata->digest.len);
3310         if (retval < 0)
3311                 return retval;
3312         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3313
3314         /* clear mbuf payload */
3315         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3316                         rte_pktmbuf_tailroom(ut_params->ibuf));
3317
3318         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3319         /* Append data which is padded to a multiple of */
3320         /* the algorithms block size */
3321         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3322         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3323                                 plaintext_pad_len);
3324         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3325
3326         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3327
3328         /* Create KASUMI operation */
3329         retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len,
3330                                 tdata->iv.data, tdata->iv.len,
3331                                 tdata->aad.data, tdata->aad.len,
3332                                 plaintext_pad_len,
3333                                 tdata->validCipherLenInBits.len,
3334                                 tdata->validCipherOffsetLenInBits.len,
3335                                 tdata->validAuthLenInBits.len,
3336                                 tdata->validAuthOffsetLenInBits.len,
3337                                 RTE_CRYPTO_AUTH_KASUMI_F9,
3338                                 RTE_CRYPTO_CIPHER_KASUMI_F8
3339                                 );
3340
3341         if (retval < 0)
3342                 return retval;
3343
3344         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3345                         ut_params->op);
3346         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3347         ut_params->obuf = ut_params->op->sym->m_src;
3348         if (ut_params->obuf)
3349                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3350                                 + tdata->iv.len + tdata->aad.len;
3351         else
3352                 ciphertext = plaintext;
3353
3354         /* Validate obuf */
3355         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3356                         ciphertext,
3357                         tdata->ciphertext.data,
3358                         tdata->validCipherLenInBits.len,
3359                         "KASUMI Ciphertext data not as expected");
3360         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3361             + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3362
3363         /* Validate obuf */
3364         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3365                         ut_params->digest,
3366                         tdata->digest.data,
3367                         DIGEST_BYTE_LENGTH_KASUMI_F9,
3368                         "KASUMI Generated auth tag not as expected");
3369         return 0;
3370 }
3371
3372 static int
3373 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
3374 {
3375         struct crypto_testsuite_params *ts_params = &testsuite_params;
3376         struct crypto_unittest_params *ut_params = &unittest_params;
3377
3378         int retval;
3379
3380         uint8_t *plaintext, *ciphertext;
3381         unsigned plaintext_pad_len;
3382         unsigned plaintext_len;
3383
3384         /* Create KASUMI session */
3385         retval = create_wireless_algo_cipher_auth_session(
3386                         ts_params->valid_devs[0],
3387                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3388                         RTE_CRYPTO_AUTH_OP_GENERATE,
3389                         RTE_CRYPTO_AUTH_KASUMI_F9,
3390                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3391                         tdata->key.data, tdata->key.len,
3392                         tdata->aad.len, tdata->digest.len);
3393         if (retval < 0)
3394                 return retval;
3395
3396         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3397
3398         /* clear mbuf payload */
3399         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3400                         rte_pktmbuf_tailroom(ut_params->ibuf));
3401
3402         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3403         /* Append data which is padded to a multiple of */
3404         /* the algorithms block size */
3405         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3406         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3407                                 plaintext_pad_len);
3408         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3409
3410         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3411
3412         /* Create KASUMI operation */
3413         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3414                                 tdata->digest.len, tdata->aad.data,
3415                                 tdata->aad.len,
3416                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3417                                 RTE_CRYPTO_AUTH_KASUMI_F9,
3418                                 RTE_CRYPTO_CIPHER_KASUMI_F8,
3419                                 tdata->iv.data, tdata->iv.len,
3420                                 tdata->validCipherLenInBits.len,
3421                                 tdata->validCipherOffsetLenInBits.len,
3422                                 tdata->validAuthLenInBits.len,
3423                                 tdata->validAuthOffsetLenInBits.len
3424                                 );
3425         if (retval < 0)
3426                 return retval;
3427
3428         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3429                         ut_params->op);
3430         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3431         ut_params->obuf = ut_params->op->sym->m_src;
3432         if (ut_params->obuf)
3433                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3434                                 + tdata->aad.len + tdata->iv.len;
3435         else
3436                 ciphertext = plaintext;
3437
3438         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3439                         + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3440
3441         /* Validate obuf */
3442         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3443                 ciphertext,
3444                 tdata->ciphertext.data,
3445                 tdata->validCipherLenInBits.len,
3446                 "KASUMI Ciphertext data not as expected");
3447
3448         /* Validate obuf */
3449         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3450                 ut_params->digest,
3451                 tdata->digest.data,
3452                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3453                 "KASUMI Generated auth tag not as expected");
3454         return 0;
3455 }
3456
3457 static int
3458 test_zuc_encryption(const struct zuc_test_data *tdata)
3459 {
3460         struct crypto_testsuite_params *ts_params = &testsuite_params;
3461         struct crypto_unittest_params *ut_params = &unittest_params;
3462
3463         int retval;
3464         uint8_t *plaintext, *ciphertext;
3465         unsigned plaintext_pad_len;
3466         unsigned plaintext_len;
3467
3468         /* Create ZUC session */
3469         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3470                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3471                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
3472                                         tdata->key.data, tdata->key.len);
3473         if (retval < 0)
3474                 return retval;
3475
3476         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3477
3478         /* Clear mbuf payload */
3479         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3480                rte_pktmbuf_tailroom(ut_params->ibuf));
3481
3482         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3483         /* Append data which is padded to a multiple */
3484         /* of the algorithms block size */
3485         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3486         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3487                                 plaintext_pad_len);
3488         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3489
3490         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3491
3492         /* Create ZUC operation */
3493         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3494                                         tdata->plaintext.len,
3495                                         tdata->validCipherOffsetLenInBits.len,
3496                                         RTE_CRYPTO_CIPHER_ZUC_EEA3);
3497         if (retval < 0)
3498                 return retval;
3499
3500         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3501                                                 ut_params->op);
3502         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3503
3504         ut_params->obuf = ut_params->op->sym->m_dst;
3505         if (ut_params->obuf)
3506                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3507                                 + tdata->iv.len;
3508         else
3509                 ciphertext = plaintext;
3510
3511         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3512
3513         /* Validate obuf */
3514         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3515                 ciphertext,
3516                 tdata->ciphertext.data,
3517                 tdata->validCipherLenInBits.len,
3518                 "ZUC Ciphertext data not as expected");
3519         return 0;
3520 }
3521
3522 static int
3523 test_zuc_authentication(const struct zuc_hash_test_data *tdata)
3524 {
3525         struct crypto_testsuite_params *ts_params = &testsuite_params;
3526         struct crypto_unittest_params *ut_params = &unittest_params;
3527
3528         int retval;
3529         unsigned plaintext_pad_len;
3530         unsigned plaintext_len;
3531         uint8_t *plaintext;
3532
3533         /* Create ZUC session */
3534         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3535                         tdata->key.data, tdata->key.len,
3536                         tdata->aad.len, tdata->digest.len,
3537                         RTE_CRYPTO_AUTH_OP_GENERATE,
3538                         RTE_CRYPTO_AUTH_ZUC_EIA3);
3539         if (retval < 0)
3540                 return retval;
3541
3542         /* alloc mbuf and set payload */
3543         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3544
3545         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3546         rte_pktmbuf_tailroom(ut_params->ibuf));
3547
3548         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3549         /* Append data which is padded to a multiple of */
3550         /* the algorithms block size */
3551         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3552         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3553                                 plaintext_pad_len);
3554         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3555
3556         /* Create ZUC operation */
3557         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3558                         tdata->aad.data, tdata->aad.len,
3559                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3560                         RTE_CRYPTO_AUTH_ZUC_EIA3,
3561                         tdata->validAuthLenInBits.len,
3562                         tdata->validAuthOffsetLenInBits.len);
3563         if (retval < 0)
3564                 return retval;
3565
3566         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3567                                 ut_params->op);
3568         ut_params->obuf = ut_params->op->sym->m_src;
3569         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3570         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3571                         + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
3572
3573         /* Validate obuf */
3574         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3575         ut_params->digest,
3576         tdata->digest.data,
3577         DIGEST_BYTE_LENGTH_KASUMI_F9,
3578         "ZUC Generated auth tag not as expected");
3579
3580         return 0;
3581 }
3582
3583 static int
3584 test_kasumi_encryption_test_case_1(void)
3585 {
3586         return test_kasumi_encryption(&kasumi_test_case_1);
3587 }
3588
3589 static int
3590 test_kasumi_encryption_test_case_1_oop(void)
3591 {
3592         return test_kasumi_encryption_oop(&kasumi_test_case_1);
3593 }
3594
3595 static int
3596 test_kasumi_encryption_test_case_2(void)
3597 {
3598         return test_kasumi_encryption(&kasumi_test_case_2);
3599 }
3600
3601 static int
3602 test_kasumi_encryption_test_case_3(void)
3603 {
3604         return test_kasumi_encryption(&kasumi_test_case_3);
3605 }
3606
3607 static int
3608 test_kasumi_encryption_test_case_4(void)
3609 {
3610         return test_kasumi_encryption(&kasumi_test_case_4);
3611 }
3612
3613 static int
3614 test_kasumi_encryption_test_case_5(void)
3615 {
3616         return test_kasumi_encryption(&kasumi_test_case_5);
3617 }
3618
3619 static int
3620 test_kasumi_decryption_test_case_1(void)
3621 {
3622         return test_kasumi_decryption(&kasumi_test_case_1);
3623 }
3624
3625 static int
3626 test_kasumi_decryption_test_case_1_oop(void)
3627 {
3628         return test_kasumi_decryption_oop(&kasumi_test_case_1);
3629 }
3630
3631 static int
3632 test_kasumi_decryption_test_case_2(void)
3633 {
3634         return test_kasumi_decryption(&kasumi_test_case_2);
3635 }
3636
3637 static int
3638 test_kasumi_decryption_test_case_3(void)
3639 {
3640         return test_kasumi_decryption(&kasumi_test_case_3);
3641 }
3642
3643 static int
3644 test_kasumi_decryption_test_case_4(void)
3645 {
3646         return test_kasumi_decryption(&kasumi_test_case_4);
3647 }
3648
3649 static int
3650 test_kasumi_decryption_test_case_5(void)
3651 {
3652         return test_kasumi_decryption(&kasumi_test_case_5);
3653 }
3654 static int
3655 test_snow3g_encryption_test_case_1(void)
3656 {
3657         return test_snow3g_encryption(&snow3g_test_case_1);
3658 }
3659
3660 static int
3661 test_snow3g_encryption_test_case_1_oop(void)
3662 {
3663         return test_snow3g_encryption_oop(&snow3g_test_case_1);
3664 }
3665
3666 static int
3667 test_snow3g_encryption_test_case_1_offset_oop(void)
3668 {
3669         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
3670 }
3671
3672 static int
3673 test_snow3g_encryption_test_case_2(void)
3674 {
3675         return test_snow3g_encryption(&snow3g_test_case_2);
3676 }
3677
3678 static int
3679 test_snow3g_encryption_test_case_3(void)
3680 {
3681         return test_snow3g_encryption(&snow3g_test_case_3);
3682 }
3683
3684 static int
3685 test_snow3g_encryption_test_case_4(void)
3686 {
3687         return test_snow3g_encryption(&snow3g_test_case_4);
3688 }
3689
3690 static int
3691 test_snow3g_encryption_test_case_5(void)
3692 {
3693         return test_snow3g_encryption(&snow3g_test_case_5);
3694 }
3695
3696 static int
3697 test_snow3g_decryption_test_case_1(void)
3698 {
3699         return test_snow3g_decryption(&snow3g_test_case_1);
3700 }
3701
3702 static int
3703 test_snow3g_decryption_test_case_1_oop(void)
3704 {
3705         return test_snow3g_decryption_oop(&snow3g_test_case_1);
3706 }
3707
3708 static int
3709 test_snow3g_decryption_test_case_2(void)
3710 {
3711         return test_snow3g_decryption(&snow3g_test_case_2);
3712 }
3713
3714 static int
3715 test_snow3g_decryption_test_case_3(void)
3716 {
3717         return test_snow3g_decryption(&snow3g_test_case_3);
3718 }
3719
3720 static int
3721 test_snow3g_decryption_test_case_4(void)
3722 {
3723         return test_snow3g_decryption(&snow3g_test_case_4);
3724 }
3725
3726 static int
3727 test_snow3g_decryption_test_case_5(void)
3728 {
3729         return test_snow3g_decryption(&snow3g_test_case_5);
3730 }
3731 static int
3732 test_snow3g_cipher_auth_test_case_1(void)
3733 {
3734         return test_snow3g_cipher_auth(&snow3g_test_case_3);
3735 }
3736
3737 static int
3738 test_snow3g_auth_cipher_test_case_1(void)
3739 {
3740         return test_snow3g_auth_cipher(&snow3g_test_case_6);
3741 }
3742
3743 static int
3744 test_kasumi_auth_cipher_test_case_1(void)
3745 {
3746         return test_kasumi_auth_cipher(&kasumi_test_case_3);
3747 }
3748
3749 static int
3750 test_kasumi_cipher_auth_test_case_1(void)
3751 {
3752         return test_kasumi_cipher_auth(&kasumi_test_case_6);
3753 }
3754
3755 static int
3756 test_zuc_encryption_test_case_1(void)
3757 {
3758         return test_zuc_encryption(&zuc_test_case_1);
3759 }
3760
3761 static int
3762 test_zuc_encryption_test_case_2(void)
3763 {
3764         return test_zuc_encryption(&zuc_test_case_2);
3765 }
3766
3767 static int
3768 test_zuc_encryption_test_case_3(void)
3769 {
3770         return test_zuc_encryption(&zuc_test_case_3);
3771 }
3772
3773 static int
3774 test_zuc_encryption_test_case_4(void)
3775 {
3776         return test_zuc_encryption(&zuc_test_case_4);
3777 }
3778
3779 static int
3780 test_zuc_encryption_test_case_5(void)
3781 {
3782         return test_zuc_encryption(&zuc_test_case_5);
3783 }
3784
3785 static int
3786 test_zuc_hash_generate_test_case_1(void)
3787 {
3788         return test_zuc_authentication(&zuc_hash_test_case_1);
3789 }
3790
3791 static int
3792 test_zuc_hash_generate_test_case_2(void)
3793 {
3794         return test_zuc_authentication(&zuc_hash_test_case_2);
3795 }
3796
3797 static int
3798 test_zuc_hash_generate_test_case_3(void)
3799 {
3800         return test_zuc_authentication(&zuc_hash_test_case_3);
3801 }
3802
3803 static int
3804 test_zuc_hash_generate_test_case_4(void)
3805 {
3806         return test_zuc_authentication(&zuc_hash_test_case_4);
3807 }
3808
3809 static int
3810 test_zuc_hash_generate_test_case_5(void)
3811 {
3812         return test_zuc_authentication(&zuc_hash_test_case_5);
3813 }
3814
3815 static int
3816 test_3DES_chain_qat_all(void)
3817 {
3818         struct crypto_testsuite_params *ts_params = &testsuite_params;
3819         int status;
3820
3821         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3822                 ts_params->op_mpool, ts_params->valid_devs[0],
3823                 RTE_CRYPTODEV_QAT_SYM_PMD,
3824                 BLKCIPHER_3DES_CHAIN_TYPE);
3825
3826         TEST_ASSERT_EQUAL(status, 0, "Test failed");
3827
3828         return TEST_SUCCESS;
3829 }
3830
3831 static int
3832 test_DES_cipheronly_qat_all(void)
3833 {
3834         struct crypto_testsuite_params *ts_params = &testsuite_params;
3835         int status;
3836
3837         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3838                 ts_params->op_mpool, ts_params->valid_devs[0],
3839                 RTE_CRYPTODEV_QAT_SYM_PMD,
3840                 BLKCIPHER_DES_CIPHERONLY_TYPE);
3841
3842         TEST_ASSERT_EQUAL(status, 0, "Test failed");
3843
3844         return TEST_SUCCESS;
3845 }
3846
3847 static int
3848 test_3DES_cipheronly_qat_all(void)
3849 {
3850         struct crypto_testsuite_params *ts_params = &testsuite_params;
3851         int status;
3852
3853         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3854                 ts_params->op_mpool, ts_params->valid_devs[0],
3855                 RTE_CRYPTODEV_QAT_SYM_PMD,
3856                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
3857
3858         TEST_ASSERT_EQUAL(status, 0, "Test failed");
3859
3860         return TEST_SUCCESS;
3861 }
3862
3863 static int
3864 test_3DES_chain_openssl_all(void)
3865 {
3866         struct crypto_testsuite_params *ts_params = &testsuite_params;
3867         int status;
3868
3869         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3870                 ts_params->op_mpool, ts_params->valid_devs[0],
3871                 RTE_CRYPTODEV_OPENSSL_PMD,
3872                 BLKCIPHER_3DES_CHAIN_TYPE);
3873
3874         TEST_ASSERT_EQUAL(status, 0, "Test failed");
3875
3876         return TEST_SUCCESS;
3877 }
3878
3879 static int
3880 test_3DES_cipheronly_openssl_all(void)
3881 {
3882         struct crypto_testsuite_params *ts_params = &testsuite_params;
3883         int status;
3884
3885         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
3886                 ts_params->op_mpool, ts_params->valid_devs[0],
3887                 RTE_CRYPTODEV_OPENSSL_PMD,
3888                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
3889
3890         TEST_ASSERT_EQUAL(status, 0, "Test failed");
3891
3892         return TEST_SUCCESS;
3893 }
3894
3895 /* ***** AES-GCM Tests ***** */
3896
3897 static int
3898 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
3899                 const uint8_t *key, const uint8_t key_len,
3900                 const uint8_t aad_len, const uint8_t auth_len,
3901                 enum rte_crypto_auth_operation auth_op)
3902 {
3903         uint8_t cipher_key[key_len];
3904
3905         struct crypto_unittest_params *ut_params = &unittest_params;
3906
3907         memcpy(cipher_key, key, key_len);
3908
3909         /* Setup Cipher Parameters */
3910         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3911         ut_params->cipher_xform.next = NULL;
3912
3913         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
3914         ut_params->auth_xform.auth.op = auth_op;
3915         ut_params->cipher_xform.cipher.op = op;
3916         ut_params->cipher_xform.cipher.key.data = cipher_key;
3917         ut_params->cipher_xform.cipher.key.length = key_len;
3918
3919         TEST_HEXDUMP(stdout, "key:", key, key_len);
3920
3921         /* Setup Authentication Parameters */
3922         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3923         ut_params->auth_xform.next = NULL;
3924
3925         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
3926
3927         ut_params->auth_xform.auth.digest_length = auth_len;
3928         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
3929         ut_params->auth_xform.auth.key.length = 0;
3930         ut_params->auth_xform.auth.key.data = NULL;
3931
3932         if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
3933                 ut_params->cipher_xform.next = &ut_params->auth_xform;
3934
3935                 /* Create Crypto session*/
3936                 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3937                                 &ut_params->cipher_xform);
3938         } else {/* Create Crypto session*/
3939                 ut_params->auth_xform.next = &ut_params->cipher_xform;
3940                 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
3941                                 &ut_params->auth_xform);
3942         }
3943
3944         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
3945
3946         return 0;
3947 }
3948
3949 static int
3950 create_gcm_operation(enum rte_crypto_cipher_operation op,
3951                 const uint8_t *auth_tag, const unsigned auth_tag_len,
3952                 const uint8_t *iv, const unsigned iv_len,
3953                 const uint8_t *aad, const unsigned aad_len,
3954                 const unsigned data_len, unsigned data_pad_len)
3955 {
3956         struct crypto_testsuite_params *ts_params = &testsuite_params;
3957         struct crypto_unittest_params *ut_params = &unittest_params;
3958
3959         unsigned iv_pad_len = 0, aad_buffer_len;
3960
3961         /* Generate Crypto op data structure */
3962         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3963                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3964         TEST_ASSERT_NOT_NULL(ut_params->op,
3965                         "Failed to allocate symmetric crypto operation struct");
3966
3967         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3968
3969         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
3970                         ut_params->ibuf, auth_tag_len);
3971         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
3972                         "no room to append digest");
3973         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
3974                         ut_params->ibuf, data_pad_len);
3975         sym_op->auth.digest.length = auth_tag_len;
3976
3977         if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
3978                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3979                 TEST_HEXDUMP(stdout, "digest:",
3980                                 sym_op->auth.digest.data,
3981                                 sym_op->auth.digest.length);
3982         }
3983
3984         /* iv */
3985         iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
3986
3987         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
3988                         ut_params->ibuf, iv_pad_len);
3989         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
3990
3991         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
3992         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
3993         sym_op->cipher.iv.length = iv_len;
3994
3995         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
3996
3997         /*
3998          * Always allocate the aad up to the block size.
3999          * The cryptodev API calls out -
4000          *  - the array must be big enough to hold the AAD, plus any
4001          *   space to round this up to the nearest multiple of the
4002          *   block size (16 bytes).
4003          */
4004         aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
4005
4006         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
4007                         ut_params->ibuf, aad_buffer_len);
4008         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
4009                         "no room to prepend aad");
4010         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
4011                         ut_params->ibuf);
4012         sym_op->auth.aad.length = aad_len;
4013
4014         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
4015         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
4016
4017         TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
4018         TEST_HEXDUMP(stdout, "aad:",
4019                         sym_op->auth.aad.data, aad_len);
4020
4021         sym_op->cipher.data.length = data_len;
4022         sym_op->cipher.data.offset = aad_buffer_len + iv_pad_len;
4023
4024         sym_op->auth.data.offset = aad_buffer_len + iv_pad_len;
4025         sym_op->auth.data.length = data_len;
4026
4027         return 0;
4028 }
4029
4030 static int
4031 test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
4032 {
4033         struct crypto_testsuite_params *ts_params = &testsuite_params;
4034         struct crypto_unittest_params *ut_params = &unittest_params;
4035
4036         int retval;
4037
4038         uint8_t *plaintext, *ciphertext, *auth_tag;
4039         uint16_t plaintext_pad_len;
4040
4041         /* Create GCM session */
4042         retval = create_gcm_session(ts_params->valid_devs[0],
4043                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4044                         tdata->key.data, tdata->key.len,
4045                         tdata->aad.len, tdata->auth_tag.len,
4046                         RTE_CRYPTO_AUTH_OP_GENERATE);
4047         if (retval < 0)
4048                 return retval;
4049
4050
4051         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4052
4053         /* clear mbuf payload */
4054         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4055                         rte_pktmbuf_tailroom(ut_params->ibuf));
4056
4057         /*
4058          * Append data which is padded to a multiple
4059          * of the algorithms block size
4060          */
4061         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
4062
4063         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4064                         plaintext_pad_len);
4065         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
4066
4067         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4068
4069         /* Create GCM opertaion */
4070         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4071                         tdata->auth_tag.data, tdata->auth_tag.len,
4072                         tdata->iv.data, tdata->iv.len,
4073                         tdata->aad.data, tdata->aad.len,
4074                         tdata->plaintext.len, plaintext_pad_len);
4075         if (retval < 0)
4076                 return retval;
4077
4078         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4079
4080         ut_params->op->sym->m_src = ut_params->ibuf;
4081
4082         /* Process crypto operation */
4083         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4084                         ut_params->op), "failed to process sym crypto op");
4085
4086         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4087                         "crypto op processing failed");
4088
4089         if (ut_params->op->sym->m_dst) {
4090                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
4091                                 uint8_t *);
4092                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
4093                                 uint8_t *, plaintext_pad_len);
4094         } else {
4095                 ciphertext = plaintext;
4096                 auth_tag = plaintext + plaintext_pad_len;
4097         }
4098
4099         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
4100         TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
4101
4102         /* Validate obuf */
4103         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4104                         ciphertext,
4105                         tdata->ciphertext.data,
4106                         tdata->ciphertext.len,
4107                         "GCM Ciphertext data not as expected");
4108
4109         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4110                         auth_tag,
4111                         tdata->auth_tag.data,
4112                         tdata->auth_tag.len,
4113                         "GCM Generated auth tag not as expected");
4114
4115         return 0;
4116
4117 }
4118
4119 static int
4120 test_mb_AES_GCM_authenticated_encryption_test_case_1(void)
4121 {
4122         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1);
4123 }
4124
4125 static int
4126 test_mb_AES_GCM_authenticated_encryption_test_case_2(void)
4127 {
4128         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2);
4129 }
4130
4131 static int
4132 test_mb_AES_GCM_authenticated_encryption_test_case_3(void)
4133 {
4134         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3);
4135 }
4136
4137 static int
4138 test_mb_AES_GCM_authenticated_encryption_test_case_4(void)
4139 {
4140         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4);
4141 }
4142
4143 static int
4144 test_mb_AES_GCM_authenticated_encryption_test_case_5(void)
4145 {
4146         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5);
4147 }
4148
4149 static int
4150 test_mb_AES_GCM_authenticated_encryption_test_case_6(void)
4151 {
4152         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6);
4153 }
4154
4155 static int
4156 test_mb_AES_GCM_authenticated_encryption_test_case_7(void)
4157 {
4158         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7);
4159 }
4160
4161 static int
4162 test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
4163 {
4164         struct crypto_testsuite_params *ts_params = &testsuite_params;
4165         struct crypto_unittest_params *ut_params = &unittest_params;
4166
4167         int retval;
4168
4169         uint8_t *plaintext, *ciphertext;
4170         uint16_t ciphertext_pad_len;
4171
4172         /* Create GCM session */
4173         retval = create_gcm_session(ts_params->valid_devs[0],
4174                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4175                         tdata->key.data, tdata->key.len,
4176                         tdata->aad.len, tdata->auth_tag.len,
4177                         RTE_CRYPTO_AUTH_OP_VERIFY);
4178         if (retval < 0)
4179                 return retval;
4180
4181
4182         /* alloc mbuf and set payload */
4183         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4184
4185         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4186                         rte_pktmbuf_tailroom(ut_params->ibuf));
4187
4188         ciphertext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
4189
4190         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4191                         ciphertext_pad_len);
4192         memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len);
4193
4194         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
4195
4196         /* Create GCM opertaion */
4197         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT,
4198                         tdata->auth_tag.data, tdata->auth_tag.len,
4199                         tdata->iv.data, tdata->iv.len,
4200                         tdata->aad.data, tdata->aad.len,
4201                         tdata->ciphertext.len, ciphertext_pad_len);
4202         if (retval < 0)
4203                 return retval;
4204
4205
4206         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4207
4208         ut_params->op->sym->m_src = ut_params->ibuf;
4209
4210         /* Process crypto operation */
4211         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4212                         ut_params->op), "failed to process sym crypto op");
4213
4214         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4215                         "crypto op processing failed");
4216
4217         if (ut_params->op->sym->m_dst)
4218                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
4219                                 uint8_t *);
4220         else
4221                 plaintext = ciphertext;
4222
4223         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
4224
4225         /* Validate obuf */
4226         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4227                         plaintext,
4228                         tdata->plaintext.data,
4229                         tdata->plaintext.len,
4230                         "GCM plaintext data not as expected");
4231
4232         TEST_ASSERT_EQUAL(ut_params->op->status,
4233                         RTE_CRYPTO_OP_STATUS_SUCCESS,
4234                         "GCM authentication failed");
4235         return 0;
4236 }
4237
4238 static int
4239 test_mb_AES_GCM_authenticated_decryption_test_case_1(void)
4240 {
4241         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1);
4242 }
4243
4244 static int
4245 test_mb_AES_GCM_authenticated_decryption_test_case_2(void)
4246 {
4247         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2);
4248 }
4249
4250 static int
4251 test_mb_AES_GCM_authenticated_decryption_test_case_3(void)
4252 {
4253         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3);
4254 }
4255
4256 static int
4257 test_mb_AES_GCM_authenticated_decryption_test_case_4(void)
4258 {
4259         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4);
4260 }
4261
4262 static int
4263 test_mb_AES_GCM_authenticated_decryption_test_case_5(void)
4264 {
4265         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5);
4266 }
4267
4268 static int
4269 test_mb_AES_GCM_authenticated_decryption_test_case_6(void)
4270 {
4271         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6);
4272 }
4273
4274 static int
4275 test_mb_AES_GCM_authenticated_decryption_test_case_7(void)
4276 {
4277         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7);
4278 }
4279
4280 static int
4281 test_stats(void)
4282 {
4283         struct crypto_testsuite_params *ts_params = &testsuite_params;
4284         struct rte_cryptodev_stats stats;
4285         struct rte_cryptodev *dev;
4286         cryptodev_stats_get_t temp_pfn;
4287
4288         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
4289         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
4290                         &stats) == -ENODEV),
4291                 "rte_cryptodev_stats_get invalid dev failed");
4292         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
4293                 "rte_cryptodev_stats_get invalid Param failed");
4294         dev = &rte_cryptodevs[ts_params->valid_devs[0]];
4295         temp_pfn = dev->dev_ops->stats_get;
4296         dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
4297         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
4298                         == -ENOTSUP),
4299                 "rte_cryptodev_stats_get invalid Param failed");
4300         dev->dev_ops->stats_get = temp_pfn;
4301
4302         /* Test expected values */
4303         ut_setup();
4304         test_AES_CBC_HMAC_SHA1_encrypt_digest();
4305         ut_teardown();
4306         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
4307                         &stats),
4308                 "rte_cryptodev_stats_get failed");
4309         TEST_ASSERT((stats.enqueued_count == 1),
4310                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4311         TEST_ASSERT((stats.dequeued_count == 1),
4312                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4313         TEST_ASSERT((stats.enqueue_err_count == 0),
4314                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4315         TEST_ASSERT((stats.dequeue_err_count == 0),
4316                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4317
4318         /* invalid device but should ignore and not reset device stats*/
4319         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
4320         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
4321                         &stats),
4322                 "rte_cryptodev_stats_get failed");
4323         TEST_ASSERT((stats.enqueued_count == 1),
4324                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4325
4326         /* check that a valid reset clears stats */
4327         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
4328         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
4329                         &stats),
4330                                           "rte_cryptodev_stats_get failed");
4331         TEST_ASSERT((stats.enqueued_count == 0),
4332                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4333         TEST_ASSERT((stats.dequeued_count == 0),
4334                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
4335
4336         return TEST_SUCCESS;
4337 }
4338
4339 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
4340                                    struct crypto_unittest_params *ut_params,
4341                                    enum rte_crypto_auth_operation op,
4342                                    const struct HMAC_MD5_vector *test_case)
4343 {
4344         uint8_t key[64];
4345
4346         memcpy(key, test_case->key.data, test_case->key.len);
4347
4348         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4349         ut_params->auth_xform.next = NULL;
4350         ut_params->auth_xform.auth.op = op;
4351
4352         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
4353
4354         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
4355         ut_params->auth_xform.auth.add_auth_data_length = 0;
4356         ut_params->auth_xform.auth.key.length = test_case->key.len;
4357         ut_params->auth_xform.auth.key.data = key;
4358
4359         ut_params->sess = rte_cryptodev_sym_session_create(
4360                 ts_params->valid_devs[0], &ut_params->auth_xform);
4361
4362         if (ut_params->sess == NULL)
4363                 return TEST_FAILED;
4364
4365         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4366
4367         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4368                         rte_pktmbuf_tailroom(ut_params->ibuf));
4369
4370         return 0;
4371 }
4372
4373 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
4374                               const struct HMAC_MD5_vector *test_case,
4375                               uint8_t **plaintext)
4376 {
4377         uint16_t plaintext_pad_len;
4378
4379         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4380
4381         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
4382                                 16);
4383
4384         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4385                         plaintext_pad_len);
4386         memcpy(*plaintext, test_case->plaintext.data,
4387                         test_case->plaintext.len);
4388
4389         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
4390                         ut_params->ibuf, MD5_DIGEST_LEN);
4391         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
4392                         "no room to append digest");
4393         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4394                         ut_params->ibuf, plaintext_pad_len);
4395         sym_op->auth.digest.length = MD5_DIGEST_LEN;
4396
4397         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
4398                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
4399                            test_case->auth_tag.len);
4400         }
4401
4402         sym_op->auth.data.offset = 0;
4403         sym_op->auth.data.length = test_case->plaintext.len;
4404
4405         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4406         ut_params->op->sym->m_src = ut_params->ibuf;
4407
4408         return 0;
4409 }
4410
4411 static int
4412 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
4413 {
4414         uint16_t plaintext_pad_len;
4415         uint8_t *plaintext, *auth_tag;
4416
4417         struct crypto_testsuite_params *ts_params = &testsuite_params;
4418         struct crypto_unittest_params *ut_params = &unittest_params;
4419
4420         if (MD5_HMAC_create_session(ts_params, ut_params,
4421                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
4422                 return TEST_FAILED;
4423
4424         /* Generate Crypto op data structure */
4425         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4426                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4427         TEST_ASSERT_NOT_NULL(ut_params->op,
4428                         "Failed to allocate symmetric crypto operation struct");
4429
4430         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
4431                                 16);
4432
4433         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
4434                 return TEST_FAILED;
4435
4436         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4437                         ut_params->op), "failed to process sym crypto op");
4438
4439         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4440                         "crypto op processing failed");
4441
4442         if (ut_params->op->sym->m_dst) {
4443                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
4444                                 uint8_t *, plaintext_pad_len);
4445         } else {
4446                 auth_tag = plaintext + plaintext_pad_len;
4447         }
4448
4449         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4450                         auth_tag,
4451                         test_case->auth_tag.data,
4452                         test_case->auth_tag.len,
4453                         "HMAC_MD5 generated tag not as expected");
4454
4455         return TEST_SUCCESS;
4456 }
4457
4458 static int
4459 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
4460 {
4461         uint8_t *plaintext;
4462
4463         struct crypto_testsuite_params *ts_params = &testsuite_params;
4464         struct crypto_unittest_params *ut_params = &unittest_params;
4465
4466         if (MD5_HMAC_create_session(ts_params, ut_params,
4467                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
4468                 return TEST_FAILED;
4469         }
4470
4471         /* Generate Crypto op data structure */
4472         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4473                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4474         TEST_ASSERT_NOT_NULL(ut_params->op,
4475                         "Failed to allocate symmetric crypto operation struct");
4476
4477         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
4478                 return TEST_FAILED;
4479
4480         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4481                         ut_params->op), "failed to process sym crypto op");
4482
4483         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4484                         "HMAC_MD5 crypto op processing failed");
4485
4486         return TEST_SUCCESS;
4487 }
4488
4489 static int
4490 test_MD5_HMAC_generate_case_1(void)
4491 {
4492         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
4493 }
4494
4495 static int
4496 test_MD5_HMAC_verify_case_1(void)
4497 {
4498         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
4499 }
4500
4501 static int
4502 test_MD5_HMAC_generate_case_2(void)
4503 {
4504         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
4505 }
4506
4507 static int
4508 test_MD5_HMAC_verify_case_2(void)
4509 {
4510         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
4511 }
4512
4513 static int
4514 test_multi_session(void)
4515 {
4516         struct crypto_testsuite_params *ts_params = &testsuite_params;
4517         struct crypto_unittest_params *ut_params = &unittest_params;
4518
4519         struct rte_cryptodev_info dev_info;
4520         struct rte_cryptodev_sym_session **sessions;
4521
4522         uint16_t i;
4523
4524         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
4525                         aes_cbc_key, hmac_sha512_key);
4526
4527
4528         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4529
4530         sessions = rte_malloc(NULL,
4531                         (sizeof(struct rte_cryptodev_sym_session *) *
4532                         dev_info.sym.max_nb_sessions) + 1, 0);
4533
4534         /* Create multiple crypto sessions*/
4535         for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
4536                 sessions[i] = rte_cryptodev_sym_session_create(
4537                                 ts_params->valid_devs[0],
4538                         &ut_params->auth_xform);
4539                 TEST_ASSERT_NOT_NULL(sessions[i],
4540                                 "Session creation failed at session number %u",
4541                                 i);
4542
4543                 /* Attempt to send a request on each session */
4544                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
4545                         sessions[i],
4546                         ut_params,
4547                         ts_params,
4548                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
4549                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
4550                         aes_cbc_iv),
4551                         "Failed to perform decrypt on request number %u.", i);
4552                 /* free crypto operation structure */
4553                 if (ut_params->op)
4554                         rte_crypto_op_free(ut_params->op);
4555
4556                 /*
4557                  * free mbuf - both obuf and ibuf are usually the same,
4558                  * so check if they point at the same address is necessary,
4559                  * to avoid freeing the mbuf twice.
4560                  */
4561                 if (ut_params->obuf) {
4562                         rte_pktmbuf_free(ut_params->obuf);
4563                         if (ut_params->ibuf == ut_params->obuf)
4564                                 ut_params->ibuf = 0;
4565                         ut_params->obuf = 0;
4566                 }
4567                 if (ut_params->ibuf) {
4568                         rte_pktmbuf_free(ut_params->ibuf);
4569                         ut_params->ibuf = 0;
4570                 }
4571         }
4572
4573         /* Next session create should fail */
4574         sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
4575                         &ut_params->auth_xform);
4576         TEST_ASSERT_NULL(sessions[i],
4577                         "Session creation succeeded unexpectedly!");
4578
4579         for (i = 0; i < dev_info.sym.max_nb_sessions; i++)
4580                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
4581                                 sessions[i]);
4582
4583         rte_free(sessions);
4584
4585         return TEST_SUCCESS;
4586 }
4587
4588 struct multi_session_params {
4589         struct crypto_unittest_params ut_params;
4590         uint8_t *cipher_key;
4591         uint8_t *hmac_key;
4592         const uint8_t *cipher;
4593         const uint8_t *digest;
4594         uint8_t *iv;
4595 };
4596
4597 #define MB_SESSION_NUMBER 3
4598
4599 static int
4600 test_multi_session_random_usage(void)
4601 {
4602         struct crypto_testsuite_params *ts_params = &testsuite_params;
4603         struct rte_cryptodev_info dev_info;
4604         struct rte_cryptodev_sym_session **sessions;
4605         uint32_t i, j;
4606         struct multi_session_params ut_paramz[] = {
4607
4608                 {
4609                         .cipher_key = ms_aes_cbc_key0,
4610                         .hmac_key = ms_hmac_key0,
4611                         .cipher = ms_aes_cbc_cipher0,
4612                         .digest = ms_hmac_digest0,
4613                         .iv = ms_aes_cbc_iv0
4614                 },
4615                 {
4616                         .cipher_key = ms_aes_cbc_key1,
4617                         .hmac_key = ms_hmac_key1,
4618                         .cipher = ms_aes_cbc_cipher1,
4619                         .digest = ms_hmac_digest1,
4620                         .iv = ms_aes_cbc_iv1
4621                 },
4622                 {
4623                         .cipher_key = ms_aes_cbc_key2,
4624                         .hmac_key = ms_hmac_key2,
4625                         .cipher = ms_aes_cbc_cipher2,
4626                         .digest = ms_hmac_digest2,
4627                         .iv = ms_aes_cbc_iv2
4628                 },
4629
4630         };
4631
4632         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4633
4634         sessions = rte_malloc(NULL,
4635                         (sizeof(struct rte_cryptodev_sym_session *)
4636                                         * dev_info.sym.max_nb_sessions) + 1, 0);
4637
4638         for (i = 0; i < MB_SESSION_NUMBER; i++) {
4639                 rte_memcpy(&ut_paramz[i].ut_params, &testsuite_params,
4640                                 sizeof(struct crypto_unittest_params));
4641
4642                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
4643                                 &ut_paramz[i].ut_params,
4644                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
4645
4646                 /* Create multiple crypto sessions*/
4647                 sessions[i] = rte_cryptodev_sym_session_create(
4648                                 ts_params->valid_devs[0],
4649                                 &ut_paramz[i].ut_params.auth_xform);
4650
4651                 TEST_ASSERT_NOT_NULL(sessions[i],
4652                                 "Session creation failed at session number %u",
4653                                 i);
4654
4655         }
4656
4657         srand(time(NULL));
4658         for (i = 0; i < 40000; i++) {
4659
4660                 j = rand() % MB_SESSION_NUMBER;
4661
4662                 TEST_ASSERT_SUCCESS(
4663                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
4664                                         sessions[j],
4665                                         &ut_paramz[j].ut_params,
4666                                         ts_params, ut_paramz[j].cipher,
4667                                         ut_paramz[j].digest,
4668                                         ut_paramz[j].iv),
4669                         "Failed to perform decrypt on request number %u.", i);
4670
4671                 if (ut_paramz[j].ut_params.op)
4672                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
4673
4674                 /*
4675                  * free mbuf - both obuf and ibuf are usually the same,
4676                  * so check if they point at the same address is necessary,
4677                  * to avoid freeing the mbuf twice.
4678                  */
4679                 if (ut_paramz[j].ut_params.obuf) {
4680                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
4681                         if (ut_paramz[j].ut_params.ibuf
4682                                         == ut_paramz[j].ut_params.obuf)
4683                                 ut_paramz[j].ut_params.ibuf = 0;
4684                         ut_paramz[j].ut_params.obuf = 0;
4685                 }
4686                 if (ut_paramz[j].ut_params.ibuf) {
4687                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
4688                         ut_paramz[j].ut_params.ibuf = 0;
4689                 }
4690         }
4691
4692         for (i = 0; i < MB_SESSION_NUMBER; i++)
4693                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
4694                                 sessions[i]);
4695
4696         rte_free(sessions);
4697
4698         return TEST_SUCCESS;
4699 }
4700
4701 static int
4702 test_null_cipher_only_operation(void)
4703 {
4704         struct crypto_testsuite_params *ts_params = &testsuite_params;
4705         struct crypto_unittest_params *ut_params = &unittest_params;
4706
4707         /* Generate test mbuf data and space for digest */
4708         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4709                         catch_22_quote, QUOTE_512_BYTES, 0);
4710
4711         /* Setup Cipher Parameters */
4712         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4713         ut_params->cipher_xform.next = NULL;
4714
4715         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4716         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4717
4718         /* Create Crypto session*/
4719         ut_params->sess = rte_cryptodev_sym_session_create(
4720                         ts_params->valid_devs[0], &ut_params->cipher_xform);
4721         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4722
4723         /* Generate Crypto op data structure */
4724         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4725                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4726         TEST_ASSERT_NOT_NULL(ut_params->op,
4727                         "Failed to allocate symmetric crypto operation struct");
4728
4729         /* Set crypto operation data parameters */
4730         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4731
4732         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4733
4734         /* set crypto operation source mbuf */
4735         sym_op->m_src = ut_params->ibuf;
4736
4737         sym_op->cipher.data.offset = 0;
4738         sym_op->cipher.data.length = QUOTE_512_BYTES;
4739
4740         /* Process crypto operation */
4741         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4742                         ut_params->op);
4743         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4744
4745         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4746                         "crypto operation processing failed");
4747
4748         /* Validate obuf */
4749         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4750                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4751                         catch_22_quote,
4752                         QUOTE_512_BYTES,
4753                         "Ciphertext data not as expected");
4754
4755         return TEST_SUCCESS;
4756 }
4757
4758 static int
4759 test_null_auth_only_operation(void)
4760 {
4761         struct crypto_testsuite_params *ts_params = &testsuite_params;
4762         struct crypto_unittest_params *ut_params = &unittest_params;
4763
4764         /* Generate test mbuf data and space for digest */
4765         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4766                         catch_22_quote, QUOTE_512_BYTES, 0);
4767
4768         /* Setup HMAC Parameters */
4769         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4770         ut_params->auth_xform.next = NULL;
4771
4772         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4773         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4774
4775         /* Create Crypto session*/
4776         ut_params->sess = rte_cryptodev_sym_session_create(
4777                         ts_params->valid_devs[0], &ut_params->auth_xform);
4778         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4779
4780         /* Generate Crypto op data structure */
4781         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4782                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4783         TEST_ASSERT_NOT_NULL(ut_params->op,
4784                         "Failed to allocate symmetric crypto operation struct");
4785
4786         /* Set crypto operation data parameters */
4787         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4788
4789         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4790
4791         sym_op->m_src = ut_params->ibuf;
4792
4793         sym_op->auth.data.offset = 0;
4794         sym_op->auth.data.length = QUOTE_512_BYTES;
4795
4796         /* Process crypto operation */
4797         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4798                         ut_params->op);
4799         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4800
4801         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4802                         "crypto operation processing failed");
4803
4804         return TEST_SUCCESS;
4805 }
4806
4807 static int
4808 test_null_cipher_auth_operation(void)
4809 {
4810         struct crypto_testsuite_params *ts_params = &testsuite_params;
4811         struct crypto_unittest_params *ut_params = &unittest_params;
4812
4813         /* Generate test mbuf data and space for digest */
4814         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4815                         catch_22_quote, QUOTE_512_BYTES, 0);
4816
4817         /* Setup Cipher Parameters */
4818         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4819         ut_params->cipher_xform.next = &ut_params->auth_xform;
4820
4821         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4822         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4823
4824         /* Setup HMAC Parameters */
4825         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4826         ut_params->auth_xform.next = NULL;
4827
4828         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4829         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4830
4831         /* Create Crypto session*/
4832         ut_params->sess = rte_cryptodev_sym_session_create(
4833                         ts_params->valid_devs[0], &ut_params->cipher_xform);
4834         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4835
4836         /* Generate Crypto op data structure */
4837         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4838                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4839         TEST_ASSERT_NOT_NULL(ut_params->op,
4840                         "Failed to allocate symmetric crypto operation struct");
4841
4842         /* Set crypto operation data parameters */
4843         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4844
4845         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4846
4847         sym_op->m_src = ut_params->ibuf;
4848
4849         sym_op->cipher.data.offset = 0;
4850         sym_op->cipher.data.length = QUOTE_512_BYTES;
4851
4852         sym_op->auth.data.offset = 0;
4853         sym_op->auth.data.length = QUOTE_512_BYTES;
4854
4855         /* Process crypto operation */
4856         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4857                         ut_params->op);
4858         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4859
4860         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4861                         "crypto operation processing failed");
4862
4863         /* Validate obuf */
4864         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4865                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4866                         catch_22_quote,
4867                         QUOTE_512_BYTES,
4868                         "Ciphertext data not as expected");
4869
4870         return TEST_SUCCESS;
4871 }
4872
4873 static int
4874 test_null_auth_cipher_operation(void)
4875 {
4876         struct crypto_testsuite_params *ts_params = &testsuite_params;
4877         struct crypto_unittest_params *ut_params = &unittest_params;
4878
4879         /* Generate test mbuf data and space for digest */
4880         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
4881                         catch_22_quote, QUOTE_512_BYTES, 0);
4882
4883         /* Setup Cipher Parameters */
4884         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4885         ut_params->cipher_xform.next = NULL;
4886
4887         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4888         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4889
4890         /* Setup HMAC Parameters */
4891         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4892         ut_params->auth_xform.next = &ut_params->cipher_xform;
4893
4894         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
4895         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4896
4897         /* Create Crypto session*/
4898         ut_params->sess = rte_cryptodev_sym_session_create(
4899                         ts_params->valid_devs[0], &ut_params->cipher_xform);
4900         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4901
4902         /* Generate Crypto op data structure */
4903         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4904                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4905         TEST_ASSERT_NOT_NULL(ut_params->op,
4906                         "Failed to allocate symmetric crypto operation struct");
4907
4908         /* Set crypto operation data parameters */
4909         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4910
4911         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4912
4913         sym_op->m_src = ut_params->ibuf;
4914
4915         sym_op->cipher.data.offset = 0;
4916         sym_op->cipher.data.length = QUOTE_512_BYTES;
4917
4918         sym_op->auth.data.offset = 0;
4919         sym_op->auth.data.length = QUOTE_512_BYTES;
4920
4921         /* Process crypto operation */
4922         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4923                         ut_params->op);
4924         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
4925
4926         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4927                         "crypto operation processing failed");
4928
4929         /* Validate obuf */
4930         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4931                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
4932                         catch_22_quote,
4933                         QUOTE_512_BYTES,
4934                         "Ciphertext data not as expected");
4935
4936         return TEST_SUCCESS;
4937 }
4938
4939
4940 static int
4941 test_null_invalid_operation(void)
4942 {
4943         struct crypto_testsuite_params *ts_params = &testsuite_params;
4944         struct crypto_unittest_params *ut_params = &unittest_params;
4945
4946         /* Setup Cipher Parameters */
4947         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4948         ut_params->cipher_xform.next = NULL;
4949
4950         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
4951         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4952
4953         /* Create Crypto session*/
4954         ut_params->sess = rte_cryptodev_sym_session_create(
4955                         ts_params->valid_devs[0], &ut_params->cipher_xform);
4956         TEST_ASSERT_NULL(ut_params->sess,
4957                         "Session creation succeeded unexpectedly");
4958
4959
4960         /* Setup HMAC Parameters */
4961         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4962         ut_params->auth_xform.next = NULL;
4963
4964         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
4965         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
4966
4967         /* Create Crypto session*/
4968         ut_params->sess = rte_cryptodev_sym_session_create(
4969                         ts_params->valid_devs[0], &ut_params->auth_xform);
4970         TEST_ASSERT_NULL(ut_params->sess,
4971                         "Session creation succeeded unexpectedly");
4972
4973         return TEST_SUCCESS;
4974 }
4975
4976
4977 #define NULL_BURST_LENGTH (32)
4978
4979 static int
4980 test_null_burst_operation(void)
4981 {
4982         struct crypto_testsuite_params *ts_params = &testsuite_params;
4983         struct crypto_unittest_params *ut_params = &unittest_params;
4984
4985         unsigned i, burst_len = NULL_BURST_LENGTH;
4986
4987         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
4988         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
4989
4990         /* Setup Cipher Parameters */
4991         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4992         ut_params->cipher_xform.next = &ut_params->auth_xform;
4993
4994         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
4995         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4996
4997         /* Setup HMAC Parameters */
4998         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4999         ut_params->auth_xform.next = NULL;
5000
5001         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
5002         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
5003
5004         /* Create Crypto session*/
5005         ut_params->sess = rte_cryptodev_sym_session_create(
5006                         ts_params->valid_devs[0], &ut_params->cipher_xform);
5007         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5008
5009         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
5010                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
5011                         burst_len, "failed to generate burst of crypto ops");
5012
5013         /* Generate an operation for each mbuf in burst */
5014         for (i = 0; i < burst_len; i++) {
5015                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5016
5017                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
5018
5019                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
5020                                 sizeof(unsigned));
5021                 *data = i;
5022
5023                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
5024
5025                 burst[i]->sym->m_src = m;
5026         }
5027
5028         /* Process crypto operation */
5029         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
5030                         0, burst, burst_len),
5031                         burst_len,
5032                         "Error enqueuing burst");
5033
5034         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
5035                         0, burst_dequeued, burst_len),
5036                         burst_len,
5037                         "Error dequeuing burst");
5038
5039
5040         for (i = 0; i < burst_len; i++) {
5041                 TEST_ASSERT_EQUAL(
5042                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
5043                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
5044                                         uint32_t *),
5045                         "data not as expected");
5046
5047                 rte_pktmbuf_free(burst[i]->sym->m_src);
5048                 rte_crypto_op_free(burst[i]);
5049         }
5050
5051         return TEST_SUCCESS;
5052 }
5053
5054 static void
5055 generate_gmac_large_plaintext(uint8_t *data)
5056 {
5057         uint16_t i;
5058
5059         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
5060                 memcpy(&data[i], &data[0], 32);
5061 }
5062
5063 static int
5064 create_gmac_operation(enum rte_crypto_auth_operation op,
5065                 const struct gmac_test_data *tdata)
5066 {
5067         struct crypto_testsuite_params *ts_params = &testsuite_params;
5068         struct crypto_unittest_params *ut_params = &unittest_params;
5069         struct rte_crypto_sym_op *sym_op;
5070
5071         unsigned iv_pad_len;
5072         unsigned aad_pad_len;
5073
5074         iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
5075         aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
5076
5077         /*
5078          * Runtime generate the large plain text instead of use hard code
5079          * plain text vector. It is done to avoid create huge source file
5080          * with the test vector.
5081          */
5082         if (tdata->aad.len == GMAC_LARGE_PLAINTEXT_LENGTH)
5083                 generate_gmac_large_plaintext(tdata->aad.data);
5084
5085         /* Generate Crypto op data structure */
5086         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5087                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5088         TEST_ASSERT_NOT_NULL(ut_params->op,
5089                         "Failed to allocate symmetric crypto operation struct");
5090
5091         sym_op = ut_params->op->sym;
5092         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5093                         aad_pad_len);
5094         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
5095                         "no room to append aad");
5096
5097         sym_op->auth.aad.length = tdata->aad.len;
5098         sym_op->auth.aad.phys_addr =
5099                         rte_pktmbuf_mtophys(ut_params->ibuf);
5100         memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len);
5101
5102         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5103                         ut_params->ibuf, tdata->gmac_tag.len);
5104         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5105                         "no room to append digest");
5106
5107         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5108                         ut_params->ibuf, aad_pad_len);
5109         sym_op->auth.digest.length = tdata->gmac_tag.len;
5110
5111         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
5112                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
5113                                 tdata->gmac_tag.len);
5114                 TEST_HEXDUMP(stdout, "digest:",
5115                                 sym_op->auth.digest.data,
5116                                 sym_op->auth.digest.length);
5117         }
5118
5119         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
5120                         ut_params->ibuf, iv_pad_len);
5121         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
5122
5123         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
5124         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5125         sym_op->cipher.iv.length = tdata->iv.len;
5126
5127         rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
5128
5129         TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
5130
5131         sym_op->cipher.data.length = 0;
5132         sym_op->cipher.data.offset = 0;
5133
5134         sym_op->auth.data.offset = 0;
5135         sym_op->auth.data.length = 0;
5136
5137         return 0;
5138 }
5139
5140 static int create_gmac_session(uint8_t dev_id,
5141                 enum rte_crypto_cipher_operation op,
5142                 const struct gmac_test_data *tdata,
5143                 enum rte_crypto_auth_operation auth_op)
5144 {
5145         uint8_t cipher_key[tdata->key.len];
5146
5147         struct crypto_unittest_params *ut_params = &unittest_params;
5148
5149         memcpy(cipher_key, tdata->key.data, tdata->key.len);
5150
5151         /* For GMAC we setup cipher parameters */
5152         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5153         ut_params->cipher_xform.next = NULL;
5154         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
5155         ut_params->cipher_xform.cipher.op = op;
5156         ut_params->cipher_xform.cipher.key.data = cipher_key;
5157         ut_params->cipher_xform.cipher.key.length = tdata->key.len;
5158
5159         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5160         ut_params->auth_xform.next = NULL;
5161
5162         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
5163         ut_params->auth_xform.auth.op = auth_op;
5164         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
5165         ut_params->auth_xform.auth.add_auth_data_length = 0;
5166         ut_params->auth_xform.auth.key.length = 0;
5167         ut_params->auth_xform.auth.key.data = NULL;
5168
5169         ut_params->cipher_xform.next = &ut_params->auth_xform;
5170
5171         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
5172                         &ut_params->cipher_xform);
5173
5174         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5175
5176         return 0;
5177 }
5178
5179 static int
5180 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
5181 {
5182         struct crypto_testsuite_params *ts_params = &testsuite_params;
5183         struct crypto_unittest_params *ut_params = &unittest_params;
5184
5185         int retval;
5186
5187         uint8_t *auth_tag, *p;
5188         uint16_t aad_pad_len;
5189
5190         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
5191                               "No GMAC length in the source data");
5192
5193         retval = create_gmac_session(ts_params->valid_devs[0],
5194                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5195                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
5196
5197         if (retval < 0)
5198                 return retval;
5199
5200         if (tdata->aad.len > MBUF_SIZE)
5201                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5202         else
5203                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5204         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5205                         "Failed to allocate input buffer in mempool");
5206
5207         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5208                         rte_pktmbuf_tailroom(ut_params->ibuf));
5209
5210         aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
5211
5212         p = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *);
5213
5214         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
5215                         tdata);
5216
5217         if (retval < 0)
5218                 return retval;
5219
5220         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5221
5222         ut_params->op->sym->m_src = ut_params->ibuf;
5223
5224         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5225                         ut_params->op), "failed to process sym crypto op");
5226
5227         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5228                         "crypto op processing failed");
5229
5230         if (ut_params->op->sym->m_dst) {
5231                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5232                                 uint8_t *, aad_pad_len);
5233         } else {
5234                 auth_tag = p + aad_pad_len;
5235         }
5236
5237         TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
5238
5239         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5240                         auth_tag,
5241                         tdata->gmac_tag.data,
5242                         tdata->gmac_tag.len,
5243                         "GMAC Generated auth tag not as expected");
5244
5245         return 0;
5246 }
5247
5248 static int
5249 test_AES_GMAC_authentication_test_case_1(void)
5250 {
5251         return test_AES_GMAC_authentication(&gmac_test_case_1);
5252 }
5253
5254 static int
5255 test_AES_GMAC_authentication_test_case_2(void)
5256 {
5257         return test_AES_GMAC_authentication(&gmac_test_case_2);
5258 }
5259
5260 static int
5261 test_AES_GMAC_authentication_test_case_3(void)
5262 {
5263         return test_AES_GMAC_authentication(&gmac_test_case_3);
5264 }
5265
5266 static int
5267 test_AES_GMAC_authentication_test_case_4(void)
5268 {
5269         return test_AES_GMAC_authentication(&gmac_test_case_4);
5270 }
5271
5272 static int
5273 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
5274 {
5275         struct crypto_testsuite_params *ts_params = &testsuite_params;
5276         struct crypto_unittest_params *ut_params = &unittest_params;
5277         int retval;
5278
5279         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
5280                               "No GMAC length in the source data");
5281
5282         retval = create_gmac_session(ts_params->valid_devs[0],
5283                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
5284                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
5285
5286         if (retval < 0)
5287                 return retval;
5288
5289         if (tdata->aad.len > MBUF_SIZE)
5290                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5291         else
5292                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5293         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5294                         "Failed to allocate input buffer in mempool");
5295
5296         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5297                         rte_pktmbuf_tailroom(ut_params->ibuf));
5298
5299         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
5300                         tdata);
5301
5302         if (retval < 0)
5303                 return retval;
5304
5305         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5306
5307         ut_params->op->sym->m_src = ut_params->ibuf;
5308
5309         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5310                         ut_params->op), "failed to process sym crypto op");
5311
5312         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5313                         "crypto op processing failed");
5314
5315         return 0;
5316
5317 }
5318
5319 static int
5320 test_AES_GMAC_authentication_verify_test_case_1(void)
5321 {
5322         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
5323 }
5324
5325 static int
5326 test_AES_GMAC_authentication_verify_test_case_2(void)
5327 {
5328         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
5329 }
5330
5331 static int
5332 test_AES_GMAC_authentication_verify_test_case_3(void)
5333 {
5334         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
5335 }
5336
5337 static int
5338 test_AES_GMAC_authentication_verify_test_case_4(void)
5339 {
5340         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
5341 }
5342
5343 struct test_crypto_vector {
5344         enum rte_crypto_cipher_algorithm crypto_algo;
5345
5346         struct {
5347                 uint8_t data[64];
5348                 unsigned int len;
5349         } cipher_key;
5350
5351         struct {
5352                 uint8_t data[64];
5353                 unsigned int len;
5354         } iv;
5355
5356         struct {
5357                 const uint8_t *data;
5358                 unsigned int len;
5359         } plaintext;
5360
5361         struct {
5362                 const uint8_t *data;
5363                 unsigned int len;
5364         } ciphertext;
5365
5366         enum rte_crypto_auth_algorithm auth_algo;
5367
5368         struct {
5369                 uint8_t data[128];
5370                 unsigned int len;
5371         } auth_key;
5372
5373         struct {
5374                 const uint8_t *data;
5375                 unsigned int len;
5376         } aad;
5377
5378         struct {
5379                 uint8_t data[128];
5380                 unsigned int len;
5381         } digest;
5382 };
5383
5384 static const struct test_crypto_vector
5385 hmac_sha1_test_crypto_vector = {
5386         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
5387         .plaintext = {
5388                 .data = plaintext_hash,
5389                 .len = 512
5390         },
5391         .auth_key = {
5392                 .data = {
5393                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
5394                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
5395                         0xDE, 0xF4, 0xDE, 0xAD
5396                 },
5397                 .len = 20
5398         },
5399         .digest = {
5400                 .data = {
5401                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
5402                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
5403                         0x3F, 0x91, 0x64, 0x59
5404                 },
5405                 .len = 20
5406         }
5407 };
5408
5409 static const struct test_crypto_vector
5410 aes128_gmac_test_vector = {
5411         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
5412         .crypto_algo = RTE_CRYPTO_CIPHER_AES_GCM,
5413         .aad = {
5414                 .data = plaintext_hash,
5415                 .len = 512
5416         },
5417         .iv = {
5418                 .data = {
5419                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
5420                         0x08, 0x09, 0x0A, 0x0B
5421                 },
5422                 .len = 12
5423         },
5424         .cipher_key = {
5425                 .data = {
5426                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
5427                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
5428                 },
5429                 .len = 16
5430         },
5431         .digest = {
5432                 .data = {
5433                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
5434                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
5435                 },
5436                 .len = 16
5437         }
5438 };
5439
5440 static const struct test_crypto_vector
5441 aes128cbc_hmac_sha1_test_vector = {
5442         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
5443         .cipher_key = {
5444                 .data = {
5445                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
5446                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
5447                 },
5448                 .len = 16
5449         },
5450         .iv = {
5451                 .data = {
5452                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
5453                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
5454                 },
5455                 .len = 16
5456         },
5457         .plaintext = {
5458                 .data = plaintext_hash,
5459                 .len = 512
5460         },
5461         .ciphertext = {
5462                 .data = ciphertext512_aes128cbc,
5463                 .len = 512
5464         },
5465         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
5466         .auth_key = {
5467                 .data = {
5468                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
5469                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
5470                         0xDE, 0xF4, 0xDE, 0xAD
5471                 },
5472                 .len = 20
5473         },
5474         .digest = {
5475                 .data = {
5476                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
5477                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
5478                         0x18, 0x8C, 0x1D, 0x32
5479                 },
5480                 .len = 20
5481         }
5482 };
5483
5484 static void
5485 data_corruption(uint8_t *data)
5486 {
5487         data[0] += 1;
5488 }
5489
5490 static void
5491 tag_corruption(uint8_t *data, unsigned int tag_offset)
5492 {
5493         data[tag_offset] += 1;
5494 }
5495
5496 static int
5497 create_auth_session(struct crypto_unittest_params *ut_params,
5498                 uint8_t dev_id,
5499                 const struct test_crypto_vector *reference,
5500                 enum rte_crypto_auth_operation auth_op)
5501 {
5502         uint8_t auth_key[reference->auth_key.len + 1];
5503
5504         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
5505
5506         /* Setup Authentication Parameters */
5507         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5508         ut_params->auth_xform.auth.op = auth_op;
5509         ut_params->auth_xform.next = NULL;
5510         ut_params->auth_xform.auth.algo = reference->auth_algo;
5511         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
5512         ut_params->auth_xform.auth.key.data = auth_key;
5513         ut_params->auth_xform.auth.digest_length = reference->digest.len;
5514         ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
5515
5516         /* Create Crypto session*/
5517         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
5518                                 &ut_params->auth_xform);
5519
5520         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5521
5522         return 0;
5523 }
5524
5525 static int
5526 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
5527                 uint8_t dev_id,
5528                 const struct test_crypto_vector *reference,
5529                 enum rte_crypto_auth_operation auth_op,
5530                 enum rte_crypto_cipher_operation cipher_op)
5531 {
5532         uint8_t cipher_key[reference->cipher_key.len + 1];
5533         uint8_t auth_key[reference->auth_key.len + 1];
5534
5535         memcpy(cipher_key, reference->cipher_key.data,
5536                         reference->cipher_key.len);
5537         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
5538
5539         /* Setup Authentication Parameters */
5540         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5541         ut_params->auth_xform.auth.op = auth_op;
5542         ut_params->auth_xform.next = &ut_params->cipher_xform;
5543         ut_params->auth_xform.auth.algo = reference->auth_algo;
5544         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
5545         ut_params->auth_xform.auth.key.data = auth_key;
5546         ut_params->auth_xform.auth.digest_length = reference->digest.len;
5547         ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
5548
5549         /* Setup Cipher Parameters */
5550         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5551         ut_params->cipher_xform.next = NULL;
5552         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
5553         ut_params->cipher_xform.cipher.op = cipher_op;
5554         ut_params->cipher_xform.cipher.key.data = cipher_key;
5555         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
5556
5557         /* Create Crypto session*/
5558         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
5559                                 &ut_params->auth_xform);
5560
5561         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5562
5563         return 0;
5564 }
5565
5566 static int
5567 create_auth_operation(struct crypto_testsuite_params *ts_params,
5568                 struct crypto_unittest_params *ut_params,
5569                 const struct test_crypto_vector *reference,
5570                 unsigned int auth_generate)
5571 {
5572         /* Generate Crypto op data structure */
5573         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5574                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5575         TEST_ASSERT_NOT_NULL(ut_params->op,
5576                         "Failed to allocate pktmbuf offload");
5577
5578         /* Set crypto operation data parameters */
5579         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5580
5581         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5582
5583         /* set crypto operation source mbuf */
5584         sym_op->m_src = ut_params->ibuf;
5585
5586         /* digest */
5587         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5588                         ut_params->ibuf, reference->digest.len);
5589
5590         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5591                         "no room to append auth tag");
5592
5593         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5594                         ut_params->ibuf, reference->plaintext.len);
5595         sym_op->auth.digest.length = reference->digest.len;
5596
5597         if (auth_generate)
5598                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
5599         else
5600                 memcpy(sym_op->auth.digest.data,
5601                                 reference->digest.data,
5602                                 reference->digest.len);
5603
5604         TEST_HEXDUMP(stdout, "digest:",
5605                         sym_op->auth.digest.data,
5606                         sym_op->auth.digest.length);
5607
5608         sym_op->auth.data.length = reference->plaintext.len;
5609         sym_op->auth.data.offset = 0;
5610
5611         return 0;
5612 }
5613
5614 static int
5615 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
5616                 struct crypto_unittest_params *ut_params,
5617                 const struct test_crypto_vector *reference,
5618                 unsigned int auth_generate)
5619 {
5620         /* Generate Crypto op data structure */
5621         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5622                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5623         TEST_ASSERT_NOT_NULL(ut_params->op,
5624                         "Failed to allocate pktmbuf offload");
5625
5626         /* Set crypto operation data parameters */
5627         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5628
5629         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5630
5631         /* set crypto operation source mbuf */
5632         sym_op->m_src = ut_params->ibuf;
5633
5634         /* aad */
5635         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5636                         reference->aad.len);
5637         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, "no room to append AAD");
5638         memcpy(sym_op->auth.aad.data, reference->aad.data, reference->aad.len);
5639
5640         TEST_HEXDUMP(stdout, "AAD:", sym_op->auth.aad.data, reference->aad.len);
5641
5642         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5643         sym_op->auth.aad.length = reference->aad.len;
5644
5645         /* digest */
5646         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5647                         ut_params->ibuf, reference->digest.len);
5648
5649         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5650                         "no room to append auth tag");
5651
5652         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5653                         ut_params->ibuf, reference->ciphertext.len);
5654         sym_op->auth.digest.length = reference->digest.len;
5655
5656         if (auth_generate)
5657                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
5658         else
5659                 memcpy(sym_op->auth.digest.data,
5660                                 reference->digest.data,
5661                                 reference->digest.len);
5662
5663         TEST_HEXDUMP(stdout, "digest:",
5664                         sym_op->auth.digest.data,
5665                         sym_op->auth.digest.length);
5666
5667         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
5668                 ut_params->ibuf, reference->iv.len);
5669         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
5670
5671         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5672         sym_op->cipher.iv.length = reference->iv.len;
5673
5674         memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
5675
5676         sym_op->cipher.data.length = 0;
5677         sym_op->cipher.data.offset = 0;
5678
5679         sym_op->auth.data.length = 0;
5680         sym_op->auth.data.offset = 0;
5681
5682         return 0;
5683 }
5684
5685 static int
5686 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
5687                 struct crypto_unittest_params *ut_params,
5688                 const struct test_crypto_vector *reference,
5689                 unsigned int auth_generate)
5690 {
5691         /* Generate Crypto op data structure */
5692         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5693                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5694         TEST_ASSERT_NOT_NULL(ut_params->op,
5695                         "Failed to allocate pktmbuf offload");
5696
5697         /* Set crypto operation data parameters */
5698         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5699
5700         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5701
5702         /* set crypto operation source mbuf */
5703         sym_op->m_src = ut_params->ibuf;
5704
5705         /* digest */
5706         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5707                         ut_params->ibuf, reference->digest.len);
5708
5709         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5710                         "no room to append auth tag");
5711
5712         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5713                         ut_params->ibuf, reference->ciphertext.len);
5714         sym_op->auth.digest.length = reference->digest.len;
5715
5716         if (auth_generate)
5717                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
5718         else
5719                 memcpy(sym_op->auth.digest.data,
5720                                 reference->digest.data,
5721                                 reference->digest.len);
5722
5723         TEST_HEXDUMP(stdout, "digest:",
5724                         sym_op->auth.digest.data,
5725                         sym_op->auth.digest.length);
5726
5727         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
5728                 ut_params->ibuf, reference->iv.len);
5729         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
5730
5731         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
5732         sym_op->cipher.iv.length = reference->iv.len;
5733
5734         memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
5735
5736         sym_op->cipher.data.length = reference->ciphertext.len;
5737         sym_op->cipher.data.offset = reference->iv.len;
5738
5739         sym_op->auth.data.length = reference->ciphertext.len;
5740         sym_op->auth.data.offset = reference->iv.len;
5741
5742         return 0;
5743 }
5744
5745 static int
5746 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
5747                 struct crypto_unittest_params *ut_params,
5748                 const struct test_crypto_vector *reference)
5749 {
5750         return create_auth_operation(ts_params, ut_params, reference, 0);
5751 }
5752
5753 static int
5754 create_auth_verify_GMAC_operation(
5755                 struct crypto_testsuite_params *ts_params,
5756                 struct crypto_unittest_params *ut_params,
5757                 const struct test_crypto_vector *reference)
5758 {
5759         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
5760 }
5761
5762 static int
5763 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
5764                 struct crypto_unittest_params *ut_params,
5765                 const struct test_crypto_vector *reference)
5766 {
5767         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
5768 }
5769
5770 static int
5771 test_authentication_verify_fail_when_data_corruption(
5772                 struct crypto_testsuite_params *ts_params,
5773                 struct crypto_unittest_params *ut_params,
5774                 const struct test_crypto_vector *reference,
5775                 unsigned int data_corrupted)
5776 {
5777         int retval;
5778
5779         uint8_t *plaintext;
5780
5781         /* Create session */
5782         retval = create_auth_session(ut_params,
5783                         ts_params->valid_devs[0],
5784                         reference,
5785                         RTE_CRYPTO_AUTH_OP_VERIFY);
5786         if (retval < 0)
5787                 return retval;
5788
5789         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5790         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5791                         "Failed to allocate input buffer in mempool");
5792
5793         /* clear mbuf payload */
5794         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5795                         rte_pktmbuf_tailroom(ut_params->ibuf));
5796
5797         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5798                         reference->plaintext.len);
5799         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
5800         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
5801
5802         TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len);
5803
5804         /* Create operation */
5805         retval = create_auth_verify_operation(ts_params, ut_params, reference);
5806
5807         if (retval < 0)
5808                 return retval;
5809
5810         if (data_corrupted)
5811                 data_corruption(plaintext);
5812         else
5813                 tag_corruption(plaintext, reference->plaintext.len);
5814
5815         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5816                         ut_params->op);
5817         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5818         TEST_ASSERT_EQUAL(ut_params->op->status,
5819                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
5820                         "authentication not failed");
5821
5822         ut_params->obuf = ut_params->op->sym->m_src;
5823         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
5824
5825         return 0;
5826 }
5827
5828 static int
5829 test_authentication_verify_GMAC_fail_when_corruption(
5830                 struct crypto_testsuite_params *ts_params,
5831                 struct crypto_unittest_params *ut_params,
5832                 const struct test_crypto_vector *reference,
5833                 unsigned int data_corrupted)
5834 {
5835         int retval;
5836
5837         /* Create session */
5838         retval = create_auth_cipher_session(ut_params,
5839                         ts_params->valid_devs[0],
5840                         reference,
5841                         RTE_CRYPTO_AUTH_OP_VERIFY,
5842                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
5843         if (retval < 0)
5844                 return retval;
5845
5846         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5847         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5848                         "Failed to allocate input buffer in mempool");
5849
5850         /* clear mbuf payload */
5851         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5852                         rte_pktmbuf_tailroom(ut_params->ibuf));
5853
5854         /* Create operation */
5855         retval = create_auth_verify_GMAC_operation(ts_params,
5856                         ut_params,
5857                         reference);
5858
5859         if (retval < 0)
5860                 return retval;
5861
5862         if (data_corrupted)
5863                 data_corruption(ut_params->op->sym->auth.aad.data);
5864         else
5865                 tag_corruption(ut_params->op->sym->auth.aad.data,
5866                                 reference->aad.len);
5867
5868         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5869                         ut_params->op);
5870         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5871         TEST_ASSERT_EQUAL(ut_params->op->status,
5872                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
5873                         "authentication not failed");
5874
5875         ut_params->obuf = ut_params->op->sym->m_src;
5876         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
5877
5878         return 0;
5879 }
5880
5881 static int
5882 test_authenticated_decryption_fail_when_corruption(
5883                 struct crypto_testsuite_params *ts_params,
5884                 struct crypto_unittest_params *ut_params,
5885                 const struct test_crypto_vector *reference,
5886                 unsigned int data_corrupted)
5887 {
5888         int retval;
5889
5890         uint8_t *ciphertext;
5891
5892         /* Create session */
5893         retval = create_auth_cipher_session(ut_params,
5894                         ts_params->valid_devs[0],
5895                         reference,
5896                         RTE_CRYPTO_AUTH_OP_VERIFY,
5897                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
5898         if (retval < 0)
5899                 return retval;
5900
5901         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5902         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5903                         "Failed to allocate input buffer in mempool");
5904
5905         /* clear mbuf payload */
5906         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5907                         rte_pktmbuf_tailroom(ut_params->ibuf));
5908
5909         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5910                         reference->ciphertext.len);
5911         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
5912         memcpy(ciphertext, reference->ciphertext.data,
5913                         reference->ciphertext.len);
5914
5915         /* Create operation */
5916         retval = create_cipher_auth_verify_operation(ts_params,
5917                         ut_params,
5918                         reference);
5919
5920         if (retval < 0)
5921                 return retval;
5922
5923         if (data_corrupted)
5924                 data_corruption(ciphertext);
5925         else
5926                 tag_corruption(ciphertext, reference->ciphertext.len);
5927
5928         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5929                         ut_params->op);
5930
5931         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5932         TEST_ASSERT_EQUAL(ut_params->op->status,
5933                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
5934                         "authentication not failed");
5935
5936         ut_params->obuf = ut_params->op->sym->m_src;
5937         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
5938
5939         return 0;
5940 }
5941
5942 static int
5943 test_authentication_verify_fail_when_data_corrupted(
5944                 struct crypto_testsuite_params *ts_params,
5945                 struct crypto_unittest_params *ut_params,
5946                 const struct test_crypto_vector *reference)
5947 {
5948         return test_authentication_verify_fail_when_data_corruption(
5949                         ts_params, ut_params, reference, 1);
5950 }
5951
5952 static int
5953 test_authentication_verify_fail_when_tag_corrupted(
5954                 struct crypto_testsuite_params *ts_params,
5955                 struct crypto_unittest_params *ut_params,
5956                 const struct test_crypto_vector *reference)
5957 {
5958         return test_authentication_verify_fail_when_data_corruption(
5959                         ts_params, ut_params, reference, 0);
5960 }
5961
5962 static int
5963 test_authentication_verify_GMAC_fail_when_data_corrupted(
5964                 struct crypto_testsuite_params *ts_params,
5965                 struct crypto_unittest_params *ut_params,
5966                 const struct test_crypto_vector *reference)
5967 {
5968         return test_authentication_verify_GMAC_fail_when_corruption(
5969                         ts_params, ut_params, reference, 1);
5970 }
5971
5972 static int
5973 test_authentication_verify_GMAC_fail_when_tag_corrupted(
5974                 struct crypto_testsuite_params *ts_params,
5975                 struct crypto_unittest_params *ut_params,
5976                 const struct test_crypto_vector *reference)
5977 {
5978         return test_authentication_verify_GMAC_fail_when_corruption(
5979                         ts_params, ut_params, reference, 0);
5980 }
5981
5982 static int
5983 test_authenticated_decryption_fail_when_data_corrupted(
5984                 struct crypto_testsuite_params *ts_params,
5985                 struct crypto_unittest_params *ut_params,
5986                 const struct test_crypto_vector *reference)
5987 {
5988         return test_authenticated_decryption_fail_when_corruption(
5989                         ts_params, ut_params, reference, 1);
5990 }
5991
5992 static int
5993 test_authenticated_decryption_fail_when_tag_corrupted(
5994                 struct crypto_testsuite_params *ts_params,
5995                 struct crypto_unittest_params *ut_params,
5996                 const struct test_crypto_vector *reference)
5997 {
5998         return test_authenticated_decryption_fail_when_corruption(
5999                         ts_params, ut_params, reference, 0);
6000 }
6001
6002 static int
6003 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
6004 {
6005         return test_authentication_verify_fail_when_data_corrupted(
6006                         &testsuite_params, &unittest_params,
6007                         &hmac_sha1_test_crypto_vector);
6008 }
6009
6010 static int
6011 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
6012 {
6013         return test_authentication_verify_fail_when_tag_corrupted(
6014                         &testsuite_params, &unittest_params,
6015                         &hmac_sha1_test_crypto_vector);
6016 }
6017
6018 static int
6019 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
6020 {
6021         return test_authentication_verify_GMAC_fail_when_data_corrupted(
6022                         &testsuite_params, &unittest_params,
6023                         &aes128_gmac_test_vector);
6024 }
6025
6026 static int
6027 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
6028 {
6029         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
6030                         &testsuite_params, &unittest_params,
6031                         &aes128_gmac_test_vector);
6032 }
6033
6034 static int
6035 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
6036 {
6037         return test_authenticated_decryption_fail_when_data_corrupted(
6038                         &testsuite_params,
6039                         &unittest_params,
6040                         &aes128cbc_hmac_sha1_test_vector);
6041 }
6042
6043 static int
6044 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
6045 {
6046         return test_authenticated_decryption_fail_when_tag_corrupted(
6047                         &testsuite_params,
6048                         &unittest_params,
6049                         &aes128cbc_hmac_sha1_test_vector);
6050 }
6051
6052 static struct unit_test_suite cryptodev_qat_testsuite  = {
6053         .suite_name = "Crypto QAT Unit Test Suite",
6054         .setup = testsuite_setup,
6055         .teardown = testsuite_teardown,
6056         .unit_test_cases = {
6057                 TEST_CASE_ST(ut_setup, ut_teardown,
6058                                 test_device_configure_invalid_dev_id),
6059                 TEST_CASE_ST(ut_setup, ut_teardown,
6060                                 test_device_configure_invalid_queue_pair_ids),
6061                 TEST_CASE_ST(ut_setup, ut_teardown,
6062                                 test_queue_pair_descriptor_setup),
6063                 TEST_CASE_ST(ut_setup, ut_teardown,
6064                                 test_multi_session),
6065
6066                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
6067                 TEST_CASE_ST(ut_setup, ut_teardown,
6068                                                 test_AES_cipheronly_qat_all),
6069                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
6070                 TEST_CASE_ST(ut_setup, ut_teardown,
6071                                                 test_3DES_cipheronly_qat_all),
6072                 TEST_CASE_ST(ut_setup, ut_teardown,
6073                                                 test_DES_cipheronly_qat_all),
6074                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
6075
6076                 /** AES GCM Authenticated Encryption */
6077                 TEST_CASE_ST(ut_setup, ut_teardown,
6078                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
6079                 TEST_CASE_ST(ut_setup, ut_teardown,
6080                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
6081                 TEST_CASE_ST(ut_setup, ut_teardown,
6082                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
6083                 TEST_CASE_ST(ut_setup, ut_teardown,
6084                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
6085                 TEST_CASE_ST(ut_setup, ut_teardown,
6086                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
6087                 TEST_CASE_ST(ut_setup, ut_teardown,
6088                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
6089                 TEST_CASE_ST(ut_setup, ut_teardown,
6090                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
6091
6092                 /** AES GCM Authenticated Decryption */
6093                 TEST_CASE_ST(ut_setup, ut_teardown,
6094                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
6095                 TEST_CASE_ST(ut_setup, ut_teardown,
6096                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
6097                 TEST_CASE_ST(ut_setup, ut_teardown,
6098                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
6099                 TEST_CASE_ST(ut_setup, ut_teardown,
6100                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
6101                 TEST_CASE_ST(ut_setup, ut_teardown,
6102                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
6103                 TEST_CASE_ST(ut_setup, ut_teardown,
6104                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
6105                 TEST_CASE_ST(ut_setup, ut_teardown,
6106                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
6107
6108                 /** AES GMAC Authentication */
6109                 TEST_CASE_ST(ut_setup, ut_teardown,
6110                         test_AES_GMAC_authentication_test_case_1),
6111                 TEST_CASE_ST(ut_setup, ut_teardown,
6112                         test_AES_GMAC_authentication_verify_test_case_1),
6113                 TEST_CASE_ST(ut_setup, ut_teardown,
6114                         test_AES_GMAC_authentication_test_case_2),
6115                 TEST_CASE_ST(ut_setup, ut_teardown,
6116                         test_AES_GMAC_authentication_verify_test_case_2),
6117                 TEST_CASE_ST(ut_setup, ut_teardown,
6118                         test_AES_GMAC_authentication_test_case_3),
6119                 TEST_CASE_ST(ut_setup, ut_teardown,
6120                         test_AES_GMAC_authentication_verify_test_case_3),
6121
6122                 /** SNOW 3G encrypt only (UEA2) */
6123                 TEST_CASE_ST(ut_setup, ut_teardown,
6124                         test_snow3g_encryption_test_case_1),
6125                 TEST_CASE_ST(ut_setup, ut_teardown,
6126                         test_snow3g_encryption_test_case_2),
6127                 TEST_CASE_ST(ut_setup, ut_teardown,
6128                         test_snow3g_encryption_test_case_3),
6129                 TEST_CASE_ST(ut_setup, ut_teardown,
6130                         test_snow3g_encryption_test_case_4),
6131                 TEST_CASE_ST(ut_setup, ut_teardown,
6132                         test_snow3g_encryption_test_case_5),
6133
6134                 TEST_CASE_ST(ut_setup, ut_teardown,
6135                         test_snow3g_encryption_test_case_1_oop),
6136                 TEST_CASE_ST(ut_setup, ut_teardown,
6137                         test_snow3g_decryption_test_case_1_oop),
6138
6139                 /** SNOW 3G decrypt only (UEA2) */
6140                 TEST_CASE_ST(ut_setup, ut_teardown,
6141                         test_snow3g_decryption_test_case_1),
6142                 TEST_CASE_ST(ut_setup, ut_teardown,
6143                         test_snow3g_decryption_test_case_2),
6144                 TEST_CASE_ST(ut_setup, ut_teardown,
6145                         test_snow3g_decryption_test_case_3),
6146                 TEST_CASE_ST(ut_setup, ut_teardown,
6147                         test_snow3g_decryption_test_case_4),
6148                 TEST_CASE_ST(ut_setup, ut_teardown,
6149                         test_snow3g_decryption_test_case_5),
6150                 TEST_CASE_ST(ut_setup, ut_teardown,
6151                         test_snow3g_hash_generate_test_case_1),
6152                 TEST_CASE_ST(ut_setup, ut_teardown,
6153                         test_snow3g_hash_generate_test_case_2),
6154                 TEST_CASE_ST(ut_setup, ut_teardown,
6155                         test_snow3g_hash_generate_test_case_3),
6156                 TEST_CASE_ST(ut_setup, ut_teardown,
6157                         test_snow3g_hash_verify_test_case_1),
6158                 TEST_CASE_ST(ut_setup, ut_teardown,
6159                         test_snow3g_hash_verify_test_case_2),
6160                 TEST_CASE_ST(ut_setup, ut_teardown,
6161                         test_snow3g_hash_verify_test_case_3),
6162                 TEST_CASE_ST(ut_setup, ut_teardown,
6163                         test_snow3g_cipher_auth_test_case_1),
6164                 TEST_CASE_ST(ut_setup, ut_teardown,
6165                         test_snow3g_auth_cipher_test_case_1),
6166
6167                 /** HMAC_MD5 Authentication */
6168                 TEST_CASE_ST(ut_setup, ut_teardown,
6169                         test_MD5_HMAC_generate_case_1),
6170                 TEST_CASE_ST(ut_setup, ut_teardown,
6171                         test_MD5_HMAC_verify_case_1),
6172                 TEST_CASE_ST(ut_setup, ut_teardown,
6173                         test_MD5_HMAC_generate_case_2),
6174                 TEST_CASE_ST(ut_setup, ut_teardown,
6175                         test_MD5_HMAC_verify_case_2),
6176
6177                 /** NULL tests */
6178                 TEST_CASE_ST(ut_setup, ut_teardown,
6179                         test_null_auth_only_operation),
6180                 TEST_CASE_ST(ut_setup, ut_teardown,
6181                         test_null_cipher_only_operation),
6182                 TEST_CASE_ST(ut_setup, ut_teardown,
6183                         test_null_cipher_auth_operation),
6184                 TEST_CASE_ST(ut_setup, ut_teardown,
6185                         test_null_auth_cipher_operation),
6186
6187                 TEST_CASE_ST(ut_setup, ut_teardown,
6188                         test_kasumi_hash_generate_test_case_6),
6189
6190                 /** KASUMI tests */
6191                 TEST_CASE_ST(ut_setup, ut_teardown,
6192                         test_kasumi_encryption_test_case_1),
6193                 TEST_CASE_ST(ut_setup, ut_teardown,
6194                         test_kasumi_encryption_test_case_3),
6195                 TEST_CASE_ST(ut_setup, ut_teardown,
6196                         test_kasumi_auth_cipher_test_case_1),
6197                 TEST_CASE_ST(ut_setup, ut_teardown,
6198                         test_kasumi_cipher_auth_test_case_1),
6199
6200                 /** Negative tests */
6201                 TEST_CASE_ST(ut_setup, ut_teardown,
6202                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
6203                 TEST_CASE_ST(ut_setup, ut_teardown,
6204                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
6205                 TEST_CASE_ST(ut_setup, ut_teardown,
6206                         authentication_verify_AES128_GMAC_fail_data_corrupt),
6207                 TEST_CASE_ST(ut_setup, ut_teardown,
6208                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
6209                 TEST_CASE_ST(ut_setup, ut_teardown,
6210                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
6211                 TEST_CASE_ST(ut_setup, ut_teardown,
6212                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
6213
6214                 TEST_CASES_END() /**< NULL terminate unit test array */
6215         }
6216 };
6217
6218 static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
6219         .suite_name = "Crypto Device AESNI MB Unit Test Suite",
6220         .setup = testsuite_setup,
6221         .teardown = testsuite_teardown,
6222         .unit_test_cases = {
6223                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
6224
6225                 TEST_CASES_END() /**< NULL terminate unit test array */
6226         }
6227 };
6228
6229 static struct unit_test_suite cryptodev_openssl_testsuite  = {
6230         .suite_name = "Crypto Device OPENSSL Unit Test Suite",
6231         .setup = testsuite_setup,
6232         .teardown = testsuite_teardown,
6233         .unit_test_cases = {
6234                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
6235                 TEST_CASE_ST(ut_setup, ut_teardown,
6236                                 test_multi_session_random_usage),
6237                 TEST_CASE_ST(ut_setup, ut_teardown,
6238                                 test_AES_chain_openssl_all),
6239                 TEST_CASE_ST(ut_setup, ut_teardown,
6240                                 test_AES_cipheronly_openssl_all),
6241                 TEST_CASE_ST(ut_setup, ut_teardown,
6242                                 test_3DES_chain_openssl_all),
6243                 TEST_CASE_ST(ut_setup, ut_teardown,
6244                                 test_3DES_cipheronly_openssl_all),
6245                 TEST_CASE_ST(ut_setup, ut_teardown,
6246                                 test_authonly_openssl_all),
6247
6248                 /** AES GCM Authenticated Encryption */
6249                 TEST_CASE_ST(ut_setup, ut_teardown,
6250                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
6251                 TEST_CASE_ST(ut_setup, ut_teardown,
6252                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
6253                 TEST_CASE_ST(ut_setup, ut_teardown,
6254                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
6255                 TEST_CASE_ST(ut_setup, ut_teardown,
6256                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
6257                 TEST_CASE_ST(ut_setup, ut_teardown,
6258                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
6259                 TEST_CASE_ST(ut_setup, ut_teardown,
6260                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
6261                 TEST_CASE_ST(ut_setup, ut_teardown,
6262                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
6263
6264                 /** AES GCM Authenticated Decryption */
6265                 TEST_CASE_ST(ut_setup, ut_teardown,
6266                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
6267                 TEST_CASE_ST(ut_setup, ut_teardown,
6268                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
6269                 TEST_CASE_ST(ut_setup, ut_teardown,
6270                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
6271                 TEST_CASE_ST(ut_setup, ut_teardown,
6272                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
6273                 TEST_CASE_ST(ut_setup, ut_teardown,
6274                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
6275                 TEST_CASE_ST(ut_setup, ut_teardown,
6276                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
6277                 TEST_CASE_ST(ut_setup, ut_teardown,
6278                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
6279
6280                 /** AES GMAC Authentication */
6281                 TEST_CASE_ST(ut_setup, ut_teardown,
6282                         test_AES_GMAC_authentication_test_case_1),
6283                 TEST_CASE_ST(ut_setup, ut_teardown,
6284                         test_AES_GMAC_authentication_verify_test_case_1),
6285                 TEST_CASE_ST(ut_setup, ut_teardown,
6286                         test_AES_GMAC_authentication_test_case_2),
6287                 TEST_CASE_ST(ut_setup, ut_teardown,
6288                         test_AES_GMAC_authentication_verify_test_case_2),
6289                 TEST_CASE_ST(ut_setup, ut_teardown,
6290                         test_AES_GMAC_authentication_test_case_3),
6291                 TEST_CASE_ST(ut_setup, ut_teardown,
6292                         test_AES_GMAC_authentication_verify_test_case_3),
6293                 TEST_CASE_ST(ut_setup, ut_teardown,
6294                         test_AES_GMAC_authentication_test_case_4),
6295                 TEST_CASE_ST(ut_setup, ut_teardown,
6296                         test_AES_GMAC_authentication_verify_test_case_4),
6297
6298                 /** Negative tests */
6299                 TEST_CASE_ST(ut_setup, ut_teardown,
6300                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
6301                 TEST_CASE_ST(ut_setup, ut_teardown,
6302                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
6303                 TEST_CASE_ST(ut_setup, ut_teardown,
6304                         authentication_verify_AES128_GMAC_fail_data_corrupt),
6305                 TEST_CASE_ST(ut_setup, ut_teardown,
6306                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
6307                 TEST_CASE_ST(ut_setup, ut_teardown,
6308                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
6309                 TEST_CASE_ST(ut_setup, ut_teardown,
6310                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
6311
6312                 TEST_CASES_END() /**< NULL terminate unit test array */
6313         }
6314 };
6315
6316 static struct unit_test_suite cryptodev_aesni_gcm_testsuite  = {
6317         .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
6318         .setup = testsuite_setup,
6319         .teardown = testsuite_teardown,
6320         .unit_test_cases = {
6321                 /** AES GCM Authenticated Encryption */
6322                 TEST_CASE_ST(ut_setup, ut_teardown,
6323                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
6324                 TEST_CASE_ST(ut_setup, ut_teardown,
6325                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
6326                 TEST_CASE_ST(ut_setup, ut_teardown,
6327                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
6328                 TEST_CASE_ST(ut_setup, ut_teardown,
6329                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
6330                 TEST_CASE_ST(ut_setup, ut_teardown,
6331                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
6332                 TEST_CASE_ST(ut_setup, ut_teardown,
6333                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
6334                 TEST_CASE_ST(ut_setup, ut_teardown,
6335                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
6336
6337                 /** AES GCM Authenticated Decryption */
6338                 TEST_CASE_ST(ut_setup, ut_teardown,
6339                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
6340                 TEST_CASE_ST(ut_setup, ut_teardown,
6341                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
6342                 TEST_CASE_ST(ut_setup, ut_teardown,
6343                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
6344                 TEST_CASE_ST(ut_setup, ut_teardown,
6345                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
6346                 TEST_CASE_ST(ut_setup, ut_teardown,
6347                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
6348                 TEST_CASE_ST(ut_setup, ut_teardown,
6349                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
6350                 TEST_CASE_ST(ut_setup, ut_teardown,
6351                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
6352
6353                 TEST_CASES_END() /**< NULL terminate unit test array */
6354         }
6355 };
6356
6357 static struct unit_test_suite cryptodev_sw_kasumi_testsuite  = {
6358         .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
6359         .setup = testsuite_setup,
6360         .teardown = testsuite_teardown,
6361         .unit_test_cases = {
6362                 /** KASUMI encrypt only (UEA1) */
6363                 TEST_CASE_ST(ut_setup, ut_teardown,
6364                         test_kasumi_encryption_test_case_1),
6365                 TEST_CASE_ST(ut_setup, ut_teardown,
6366                         test_kasumi_encryption_test_case_2),
6367                 TEST_CASE_ST(ut_setup, ut_teardown,
6368                         test_kasumi_encryption_test_case_3),
6369                 TEST_CASE_ST(ut_setup, ut_teardown,
6370                         test_kasumi_encryption_test_case_4),
6371                 TEST_CASE_ST(ut_setup, ut_teardown,
6372                         test_kasumi_encryption_test_case_5),
6373                 /** KASUMI decrypt only (UEA1) */
6374                 TEST_CASE_ST(ut_setup, ut_teardown,
6375                         test_kasumi_decryption_test_case_1),
6376                 TEST_CASE_ST(ut_setup, ut_teardown,
6377                         test_kasumi_decryption_test_case_2),
6378                 TEST_CASE_ST(ut_setup, ut_teardown,
6379                         test_kasumi_decryption_test_case_3),
6380                 TEST_CASE_ST(ut_setup, ut_teardown,
6381                         test_kasumi_decryption_test_case_4),
6382                 TEST_CASE_ST(ut_setup, ut_teardown,
6383                         test_kasumi_decryption_test_case_5),
6384
6385                 TEST_CASE_ST(ut_setup, ut_teardown,
6386                         test_kasumi_encryption_test_case_1_oop),
6387                 TEST_CASE_ST(ut_setup, ut_teardown,
6388                         test_kasumi_decryption_test_case_1_oop),
6389
6390                 /** KASUMI hash only (UIA1) */
6391                 TEST_CASE_ST(ut_setup, ut_teardown,
6392                         test_kasumi_hash_generate_test_case_1),
6393                 TEST_CASE_ST(ut_setup, ut_teardown,
6394                         test_kasumi_hash_generate_test_case_2),
6395                 TEST_CASE_ST(ut_setup, ut_teardown,
6396                         test_kasumi_hash_generate_test_case_3),
6397                 TEST_CASE_ST(ut_setup, ut_teardown,
6398                         test_kasumi_hash_generate_test_case_4),
6399                 TEST_CASE_ST(ut_setup, ut_teardown,
6400                         test_kasumi_hash_generate_test_case_5),
6401                 TEST_CASE_ST(ut_setup, ut_teardown,
6402                         test_kasumi_hash_generate_test_case_6),
6403                 TEST_CASE_ST(ut_setup, ut_teardown,
6404                         test_kasumi_hash_verify_test_case_1),
6405                 TEST_CASE_ST(ut_setup, ut_teardown,
6406                         test_kasumi_hash_verify_test_case_2),
6407                 TEST_CASE_ST(ut_setup, ut_teardown,
6408                         test_kasumi_hash_verify_test_case_3),
6409                 TEST_CASE_ST(ut_setup, ut_teardown,
6410                         test_kasumi_hash_verify_test_case_4),
6411                 TEST_CASE_ST(ut_setup, ut_teardown,
6412                         test_kasumi_hash_verify_test_case_5),
6413                 TEST_CASE_ST(ut_setup, ut_teardown,
6414                         test_kasumi_auth_cipher_test_case_1),
6415                 TEST_CASE_ST(ut_setup, ut_teardown,
6416                         test_kasumi_cipher_auth_test_case_1),
6417                 TEST_CASES_END() /**< NULL terminate unit test array */
6418         }
6419 };
6420 static struct unit_test_suite cryptodev_sw_snow3g_testsuite  = {
6421         .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
6422         .setup = testsuite_setup,
6423         .teardown = testsuite_teardown,
6424         .unit_test_cases = {
6425                 /** SNOW 3G encrypt only (UEA2) */
6426                 TEST_CASE_ST(ut_setup, ut_teardown,
6427                         test_snow3g_encryption_test_case_1),
6428                 TEST_CASE_ST(ut_setup, ut_teardown,
6429                         test_snow3g_encryption_test_case_2),
6430                 TEST_CASE_ST(ut_setup, ut_teardown,
6431                         test_snow3g_encryption_test_case_3),
6432                 TEST_CASE_ST(ut_setup, ut_teardown,
6433                         test_snow3g_encryption_test_case_4),
6434                 TEST_CASE_ST(ut_setup, ut_teardown,
6435                         test_snow3g_encryption_test_case_5),
6436
6437                 TEST_CASE_ST(ut_setup, ut_teardown,
6438                         test_snow3g_encryption_test_case_1_oop),
6439                 TEST_CASE_ST(ut_setup, ut_teardown,
6440                         test_snow3g_decryption_test_case_1_oop),
6441
6442                 TEST_CASE_ST(ut_setup, ut_teardown,
6443                         test_snow3g_encryption_test_case_1_offset_oop),
6444
6445                 /** SNOW 3G decrypt only (UEA2) */
6446                 TEST_CASE_ST(ut_setup, ut_teardown,
6447                         test_snow3g_decryption_test_case_1),
6448                 TEST_CASE_ST(ut_setup, ut_teardown,
6449                         test_snow3g_decryption_test_case_2),
6450                 TEST_CASE_ST(ut_setup, ut_teardown,
6451                         test_snow3g_decryption_test_case_3),
6452                 TEST_CASE_ST(ut_setup, ut_teardown,
6453                         test_snow3g_decryption_test_case_4),
6454                 TEST_CASE_ST(ut_setup, ut_teardown,
6455                         test_snow3g_decryption_test_case_5),
6456                 TEST_CASE_ST(ut_setup, ut_teardown,
6457                         test_snow3g_hash_generate_test_case_1),
6458                 TEST_CASE_ST(ut_setup, ut_teardown,
6459                         test_snow3g_hash_generate_test_case_2),
6460                 TEST_CASE_ST(ut_setup, ut_teardown,
6461                         test_snow3g_hash_generate_test_case_3),
6462                 /* Tests with buffers which length is not byte-aligned */
6463                 TEST_CASE_ST(ut_setup, ut_teardown,
6464                         test_snow3g_hash_generate_test_case_4),
6465                 TEST_CASE_ST(ut_setup, ut_teardown,
6466                         test_snow3g_hash_generate_test_case_5),
6467                 TEST_CASE_ST(ut_setup, ut_teardown,
6468                         test_snow3g_hash_generate_test_case_6),
6469                 TEST_CASE_ST(ut_setup, ut_teardown,
6470                         test_snow3g_hash_verify_test_case_1),
6471                 TEST_CASE_ST(ut_setup, ut_teardown,
6472                         test_snow3g_hash_verify_test_case_2),
6473                 TEST_CASE_ST(ut_setup, ut_teardown,
6474                         test_snow3g_hash_verify_test_case_3),
6475                 /* Tests with buffers which length is not byte-aligned */
6476                 TEST_CASE_ST(ut_setup, ut_teardown,
6477                         test_snow3g_hash_verify_test_case_4),
6478                 TEST_CASE_ST(ut_setup, ut_teardown,
6479                         test_snow3g_hash_verify_test_case_5),
6480                 TEST_CASE_ST(ut_setup, ut_teardown,
6481                         test_snow3g_hash_verify_test_case_6),
6482                 TEST_CASE_ST(ut_setup, ut_teardown,
6483                         test_snow3g_cipher_auth_test_case_1),
6484                 TEST_CASE_ST(ut_setup, ut_teardown,
6485                         test_snow3g_auth_cipher_test_case_1),
6486
6487                 TEST_CASES_END() /**< NULL terminate unit test array */
6488         }
6489 };
6490
6491 static struct unit_test_suite cryptodev_sw_zuc_testsuite  = {
6492         .suite_name = "Crypto Device SW ZUC Unit Test Suite",
6493         .setup = testsuite_setup,
6494         .teardown = testsuite_teardown,
6495         .unit_test_cases = {
6496                 /** ZUC encrypt only (EEA3) */
6497                 TEST_CASE_ST(ut_setup, ut_teardown,
6498                         test_zuc_encryption_test_case_1),
6499                 TEST_CASE_ST(ut_setup, ut_teardown,
6500                         test_zuc_encryption_test_case_2),
6501                 TEST_CASE_ST(ut_setup, ut_teardown,
6502                         test_zuc_encryption_test_case_3),
6503                 TEST_CASE_ST(ut_setup, ut_teardown,
6504                         test_zuc_encryption_test_case_4),
6505                 TEST_CASE_ST(ut_setup, ut_teardown,
6506                         test_zuc_encryption_test_case_5),
6507                 TEST_CASE_ST(ut_setup, ut_teardown,
6508                         test_zuc_hash_generate_test_case_1),
6509                 TEST_CASE_ST(ut_setup, ut_teardown,
6510                         test_zuc_hash_generate_test_case_2),
6511                 TEST_CASE_ST(ut_setup, ut_teardown,
6512                         test_zuc_hash_generate_test_case_3),
6513                 TEST_CASE_ST(ut_setup, ut_teardown,
6514                         test_zuc_hash_generate_test_case_4),
6515                 TEST_CASE_ST(ut_setup, ut_teardown,
6516                         test_zuc_hash_generate_test_case_5),
6517                 TEST_CASES_END() /**< NULL terminate unit test array */
6518         }
6519 };
6520
6521 static struct unit_test_suite cryptodev_null_testsuite  = {
6522         .suite_name = "Crypto Device NULL Unit Test Suite",
6523         .setup = testsuite_setup,
6524         .teardown = testsuite_teardown,
6525         .unit_test_cases = {
6526                 TEST_CASE_ST(ut_setup, ut_teardown,
6527                         test_null_auth_only_operation),
6528                 TEST_CASE_ST(ut_setup, ut_teardown,
6529                         test_null_cipher_only_operation),
6530                 TEST_CASE_ST(ut_setup, ut_teardown,
6531                         test_null_cipher_auth_operation),
6532                 TEST_CASE_ST(ut_setup, ut_teardown,
6533                         test_null_auth_cipher_operation),
6534                 TEST_CASE_ST(ut_setup, ut_teardown,
6535                         test_null_invalid_operation),
6536                 TEST_CASE_ST(ut_setup, ut_teardown,
6537                         test_null_burst_operation),
6538
6539                 TEST_CASES_END() /**< NULL terminate unit test array */
6540         }
6541 };
6542
6543 static int
6544 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
6545 {
6546         gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
6547         return unit_test_suite_runner(&cryptodev_qat_testsuite);
6548 }
6549
6550 static int
6551 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
6552 {
6553         gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
6554
6555         return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
6556 }
6557
6558 static int
6559 test_cryptodev_openssl(void)
6560 {
6561         gbl_cryptodev_type = RTE_CRYPTODEV_OPENSSL_PMD;
6562
6563         return unit_test_suite_runner(&cryptodev_openssl_testsuite);
6564 }
6565
6566 static int
6567 test_cryptodev_aesni_gcm(void)
6568 {
6569         gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD;
6570
6571         return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
6572 }
6573
6574 static int
6575 test_cryptodev_null(void)
6576 {
6577         gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD;
6578
6579         return unit_test_suite_runner(&cryptodev_null_testsuite);
6580 }
6581
6582 static int
6583 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
6584 {
6585         gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD;
6586
6587         return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
6588 }
6589
6590 static int
6591 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
6592 {
6593         gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD;
6594
6595         return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
6596 }
6597
6598 static int
6599 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
6600 {
6601         gbl_cryptodev_type = RTE_CRYPTODEV_ZUC_PMD;
6602
6603         return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
6604 }
6605
6606 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
6607 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
6608 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
6609 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
6610 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
6611 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
6612 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
6613 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);