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