test/test/test_cryptodev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2017 Intel Corporation
   3  */
   4
   5 #include <time.h>
   6
   7 #include <rte_common.h>
   8 #include <rte_hexdump.h>
   9 #include <rte_mbuf.h>
  10 #include <rte_malloc.h>
  11 #include <rte_memcpy.h>
  12 #include <rte_pause.h>
  13 #include <rte_bus_vdev.h>
  14
  15 #include <rte_crypto.h>
  16 #include <rte_cryptodev.h>
  17 #include <rte_cryptodev_pmd.h>
  18
  19 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
  20 #include <rte_cryptodev_scheduler.h>
  21 #include <rte_cryptodev_scheduler_operations.h>
  22 #endif
  23
  24 #include <rte_lcore.h>
  25
  26 #include "test.h"
  27 #include "test_cryptodev.h"
  28
  29 #include "test_cryptodev_blockcipher.h"
  30 #include "test_cryptodev_aes_test_vectors.h"
  31 #include "test_cryptodev_des_test_vectors.h"
  32 #include "test_cryptodev_hash_test_vectors.h"
  33 #include "test_cryptodev_kasumi_test_vectors.h"
  34 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  35 #include "test_cryptodev_snow3g_test_vectors.h"
  36 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  37 #include "test_cryptodev_zuc_test_vectors.h"
  38 #include "test_cryptodev_aead_test_vectors.h"
  39 #include "test_cryptodev_hmac_test_vectors.h"
  40
  41 #define VDEV_ARGS_SIZE 100
  42 #define MAX_NB_SESSIONS            4
  43
  44 static int gbl_driver_id;
  45
  46 struct crypto_testsuite_params {
  47         struct rte_mempool *mbuf_pool;
  48         struct rte_mempool *large_mbuf_pool;
  49         struct rte_mempool *op_mpool;
  50         struct rte_mempool *session_mpool;
  51         struct rte_mempool *session_priv_mpool;
  52         struct rte_cryptodev_config conf;
  53         struct rte_cryptodev_qp_conf qp_conf;
  54
  55         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  56         uint8_t valid_dev_count;
  57 };
  58
  59 struct crypto_unittest_params {
  60         struct rte_crypto_sym_xform cipher_xform;
  61         struct rte_crypto_sym_xform auth_xform;
  62         struct rte_crypto_sym_xform aead_xform;
  63
  64         struct rte_cryptodev_sym_session *sess;
  65
  66         struct rte_crypto_op *op;
  67
  68         struct rte_mbuf *obuf, *ibuf;
  69
  70         uint8_t *digest;
  71 };
  72
  73 #define ALIGN_POW2_ROUNDUP(num, align) \
  74         (((num) + (align) - 1) & ~((align) - 1))
  75
  76 /*
  77  * Forward declarations.
  78  */
  79 static int
  80 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
  81                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
  82                 uint8_t *hmac_key);
  83
  84 static int
  85 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
  86                 struct crypto_unittest_params *ut_params,
  87                 struct crypto_testsuite_params *ts_param,
  88                 const uint8_t *cipher,
  89                 const uint8_t *digest,
  90                 const uint8_t *iv);
  91
  92 static struct rte_mbuf *
  93 setup_test_string(struct rte_mempool *mpool,
  94                 const char *string, size_t len, uint8_t blocksize)
  95 {
  96         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
  97         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
  98
  99         memset(m->buf_addr, 0, m->buf_len);
 100         if (m) {
 101                 char *dst = rte_pktmbuf_append(m, t_len);
 102
 103                 if (!dst) {
 104                         rte_pktmbuf_free(m);
 105                         return NULL;
 106                 }
 107                 if (string != NULL)
 108                         rte_memcpy(dst, string, t_len);
 109                 else
 110                         memset(dst, 0, t_len);
 111         }
 112
 113         return m;
 114 }
 115
 116 /* Get number of bytes in X bits (rounding up) */
 117 static uint32_t
 118 ceil_byte_length(uint32_t num_bits)
 119 {
 120         if (num_bits % 8)
 121                 return ((num_bits >> 3) + 1);
 122         else
 123                 return (num_bits >> 3);
 124 }
 125
 126 static struct rte_crypto_op *
 127 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 128 {
 129         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 130                 printf("Error sending packet for encryption");
 131                 return NULL;
 132         }
 133
 134         op = NULL;
 135
 136         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 137                 rte_pause();
 138
 139         return op;
 140 }
 141
 142 static struct crypto_testsuite_params testsuite_params = { NULL };
 143 static struct crypto_unittest_params unittest_params;
 144
 145 static int
 146 testsuite_setup(void)
 147 {
 148         struct crypto_testsuite_params *ts_params = &testsuite_params;
 149         struct rte_cryptodev_info info;
 150         uint32_t i = 0, nb_devs, dev_id;
 151         int ret;
 152         uint16_t qp_id;
 153
 154         memset(ts_params, 0, sizeof(*ts_params));
 155
 156         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 157         if (ts_params->mbuf_pool == NULL) {
 158                 /* Not already created so create */
 159                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 160                                 "CRYPTO_MBUFPOOL",
 161                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 162                                 rte_socket_id());
 163                 if (ts_params->mbuf_pool == NULL) {
 164                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 165                         return TEST_FAILED;
 166                 }
 167         }
 168
 169         ts_params->large_mbuf_pool = rte_mempool_lookup(
 170                         "CRYPTO_LARGE_MBUFPOOL");
 171         if (ts_params->large_mbuf_pool == NULL) {
 172                 /* Not already created so create */
 173                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 174                                 "CRYPTO_LARGE_MBUFPOOL",
 175                                 1, 0, 0, UINT16_MAX,
 176                                 rte_socket_id());
 177                 if (ts_params->large_mbuf_pool == NULL) {
 178                         RTE_LOG(ERR, USER1,
 179                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 180                         return TEST_FAILED;
 181                 }
 182         }
 183
 184         ts_params->op_mpool = rte_crypto_op_pool_create(
 185                         "MBUF_CRYPTO_SYM_OP_POOL",
 186                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 187                         NUM_MBUFS, MBUF_CACHE_SIZE,
 188                         DEFAULT_NUM_XFORMS *
 189                         sizeof(struct rte_crypto_sym_xform) +
 190                         MAXIMUM_IV_LENGTH,
 191                         rte_socket_id());
 192         if (ts_params->op_mpool == NULL) {
 193                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 194                 return TEST_FAILED;
 195         }
 196
 197         /* Create an AESNI MB device if required */
 198         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 199                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
 200                 nb_devs = rte_cryptodev_device_count_by_driver(
 201                                 rte_cryptodev_driver_id_get(
 202                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
 203                 if (nb_devs < 1) {
 204                         ret = rte_vdev_init(
 205                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
 206
 207                         TEST_ASSERT(ret == 0,
 208                                 "Failed to create instance of"
 209                                 " pmd : %s",
 210                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
 211                 }
 212         }
 213
 214         /* Create an AESNI GCM device if required */
 215         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 216                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
 217                 nb_devs = rte_cryptodev_device_count_by_driver(
 218                                 rte_cryptodev_driver_id_get(
 219                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
 220                 if (nb_devs < 1) {
 221                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 222                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
 223                                 "Failed to create instance of"
 224                                 " pmd : %s",
 225                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
 226                 }
 227         }
 228
 229         /* Create a SNOW 3G device if required */
 230         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 231                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
 232                 nb_devs = rte_cryptodev_device_count_by_driver(
 233                                 rte_cryptodev_driver_id_get(
 234                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
 235                 if (nb_devs < 1) {
 236                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 237                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
 238                                 "Failed to create instance of"
 239                                 " pmd : %s",
 240                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
 241                 }
 242         }
 243
 244         /* Create a KASUMI device if required */
 245         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 246                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) {
 247                 nb_devs = rte_cryptodev_device_count_by_driver(
 248                                 rte_cryptodev_driver_id_get(
 249                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)));
 250                 if (nb_devs < 1) {
 251                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 252                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
 253                                 "Failed to create instance of"
 254                                 " pmd : %s",
 255                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
 256                 }
 257         }
 258
 259         /* Create a ZUC device if required */
 260         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 261                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) {
 262                 nb_devs = rte_cryptodev_device_count_by_driver(
 263                                 rte_cryptodev_driver_id_get(
 264                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD)));
 265                 if (nb_devs < 1) {
 266                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 267                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
 268                                 "Failed to create instance of"
 269                                 " pmd : %s",
 270                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
 271                 }
 272         }
 273
 274         /* Create a NULL device if required */
 275         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 276                         RTE_STR(CRYPTODEV_NAME_NULL_PMD))) {
 277                 nb_devs = rte_cryptodev_device_count_by_driver(
 278                                 rte_cryptodev_driver_id_get(
 279                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD)));
 280                 if (nb_devs < 1) {
 281                         ret = rte_vdev_init(
 282                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
 283
 284                         TEST_ASSERT(ret == 0,
 285                                 "Failed to create instance of"
 286                                 " pmd : %s",
 287                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
 288                 }
 289         }
 290
 291         /* Create an OPENSSL device if required */
 292         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 293                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
 294                 nb_devs = rte_cryptodev_device_count_by_driver(
 295                                 rte_cryptodev_driver_id_get(
 296                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
 297                 if (nb_devs < 1) {
 298                         ret = rte_vdev_init(
 299                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
 300                                 NULL);
 301
 302                         TEST_ASSERT(ret == 0, "Failed to create "
 303                                 "instance of pmd : %s",
 304                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
 305                 }
 306         }
 307
 308         /* Create a ARMv8 device if required */
 309         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 310                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
 311                 nb_devs = rte_cryptodev_device_count_by_driver(
 312                                 rte_cryptodev_driver_id_get(
 313                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
 314                 if (nb_devs < 1) {
 315                         ret = rte_vdev_init(
 316                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
 317                                 NULL);
 318
 319                         TEST_ASSERT(ret == 0, "Failed to create "
 320                                 "instance of pmd : %s",
 321                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
 322                 }
 323         }
 324
 325         /* Create a MVSAM device if required */
 326         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 327                         RTE_STR(CRYPTODEV_NAME_MVSAM_PMD))) {
 328                 nb_devs = rte_cryptodev_device_count_by_driver(
 329                                 rte_cryptodev_driver_id_get(
 330                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)));
 331                 if (nb_devs < 1) {
 332                         ret = rte_vdev_init(
 333                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD),
 334                                 NULL);
 335
 336                         TEST_ASSERT(ret == 0, "Failed to create "
 337                                 "instance of pmd : %s",
 338                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
 339                 }
 340         }
 341
 342         /* Create an CCP device if required */
 343         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 344                         RTE_STR(CRYPTODEV_NAME_CCP_PMD))) {
 345                 nb_devs = rte_cryptodev_device_count_by_driver(
 346                                 rte_cryptodev_driver_id_get(
 347                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)));
 348                 if (nb_devs < 1) {
 349                         ret = rte_vdev_init(
 350                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD),
 351                                 NULL);
 352
 353                         TEST_ASSERT(ret == 0, "Failed to create "
 354                                 "instance of pmd : %s",
 355                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
 356                 }
 357         }
 358
 359 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
 360         char vdev_args[VDEV_ARGS_SIZE] = {""};
 361         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
 362                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
 363         uint16_t slave_core_count = 0;
 364         uint16_t socket_id = 0;
 365
 366         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 367                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
 368
 369                 /* Identify the Slave Cores
 370                  * Use 2 slave cores for the device args
 371                  */
 372                 RTE_LCORE_FOREACH_SLAVE(i) {
 373                         if (slave_core_count > 1)
 374                                 break;
 375                         snprintf(vdev_args, sizeof(vdev_args),
 376                                         "%s%d", temp_str, i);
 377                         strcpy(temp_str, vdev_args);
 378                         strcat(temp_str, ";");
 379                         slave_core_count++;
 380                         socket_id = lcore_config[i].socket_id;
 381                 }
 382                 if (slave_core_count != 2) {
 383                         RTE_LOG(ERR, USER1,
 384                                 "Cryptodev scheduler test require at least "
 385                                 "two slave cores to run. "
 386                                 "Please use the correct coremask.\n");
 387                         return TEST_FAILED;
 388                 }
 389                 strcpy(temp_str, vdev_args);
 390                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
 391                                 temp_str, socket_id);
 392                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
 393                 nb_devs = rte_cryptodev_device_count_by_driver(
 394                                 rte_cryptodev_driver_id_get(
 395                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
 396                 if (nb_devs < 1) {
 397                         ret = rte_vdev_init(
 398                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
 399                                         vdev_args);
 400                         TEST_ASSERT(ret == 0,
 401                                 "Failed to create instance %u of"
 402                                 " pmd : %s",
 403                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
 404                 }
 405         }
 406 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
 407
 408         nb_devs = rte_cryptodev_count();
 409         if (nb_devs < 1) {
 410                 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
 411                 return TEST_FAILED;
 412         }
 413
 414         /* Create list of valid crypto devs */
 415         for (i = 0; i < nb_devs; i++) {
 416                 rte_cryptodev_info_get(i, &info);
 417                 if (info.driver_id == gbl_driver_id)
 418                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 419         }
 420
 421         if (ts_params->valid_dev_count < 1)
 422                 return TEST_FAILED;
 423
 424         /* Set up all the qps on the first of the valid devices found */
 425
 426         dev_id = ts_params->valid_devs[0];
 427
 428         rte_cryptodev_info_get(dev_id, &info);
 429
 430         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 431         ts_params->conf.socket_id = SOCKET_ID_ANY;
 432
 433         unsigned int session_size =
 434                 rte_cryptodev_sym_get_private_session_size(dev_id);
 435
 436         /*
 437          * Create mempool with maximum number of sessions * 2,
 438          * to include the session headers
 439          */
 440         if (info.sym.max_nb_sessions != 0 &&
 441                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 442                 RTE_LOG(ERR, USER1, "Device does not support "
 443                                 "at least %u sessions\n",
 444                                 MAX_NB_SESSIONS);
 445                 return TEST_FAILED;
 446         }
 447
 448         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 449                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 450                         SOCKET_ID_ANY);
 451         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 452                         "session mempool allocation failed");
 453
 454         ts_params->session_priv_mpool = rte_mempool_create(
 455                         "test_sess_mp_priv",
 456                         MAX_NB_SESSIONS,
 457                         session_size,
 458                         0, 0, NULL, NULL, NULL,
 459                         NULL, SOCKET_ID_ANY,
 460                         0);
 461         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 462                         "session mempool allocation failed");
 463
 464
 465
 466         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 467                         &ts_params->conf),
 468                         "Failed to configure cryptodev %u with %u qps",
 469                         dev_id, ts_params->conf.nb_queue_pairs);
 470
 471         ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 472         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 473         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 474
 475         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 476                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 477                         dev_id, qp_id, &ts_params->qp_conf,
 478                         rte_cryptodev_socket_id(dev_id)),
 479                         "Failed to setup queue pair %u on cryptodev %u",
 480                         qp_id, dev_id);
 481         }
 482
 483         return TEST_SUCCESS;
 484 }
 485
 486 static void
 487 testsuite_teardown(void)
 488 {
 489         struct crypto_testsuite_params *ts_params = &testsuite_params;
 490
 491         if (ts_params->mbuf_pool != NULL) {
 492                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 493                 rte_mempool_avail_count(ts_params->mbuf_pool));
 494         }
 495
 496         if (ts_params->op_mpool != NULL) {
 497                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 498                 rte_mempool_avail_count(ts_params->op_mpool));
 499         }
 500
 501         /* Free session mempools */
 502         if (ts_params->session_priv_mpool != NULL) {
 503                 rte_mempool_free(ts_params->session_priv_mpool);
 504                 ts_params->session_priv_mpool = NULL;
 505         }
 506
 507         if (ts_params->session_mpool != NULL) {
 508                 rte_mempool_free(ts_params->session_mpool);
 509                 ts_params->session_mpool = NULL;
 510         }
 511 }
 512
 513 static int
 514 ut_setup(void)
 515 {
 516         struct crypto_testsuite_params *ts_params = &testsuite_params;
 517         struct crypto_unittest_params *ut_params = &unittest_params;
 518
 519         uint16_t qp_id;
 520
 521         /* Clear unit test parameters before running test */
 522         memset(ut_params, 0, sizeof(*ut_params));
 523
 524         /* Reconfigure device to default parameters */
 525         ts_params->conf.socket_id = SOCKET_ID_ANY;
 526         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 527         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 528         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 529
 530         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 531                         &ts_params->conf),
 532                         "Failed to configure cryptodev %u",
 533                         ts_params->valid_devs[0]);
 534
 535         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 536                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 537                         ts_params->valid_devs[0], qp_id,
 538                         &ts_params->qp_conf,
 539                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 540                         "Failed to setup queue pair %u on cryptodev %u",
 541                         qp_id, ts_params->valid_devs[0]);
 542         }
 543
 544
 545         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 546
 547         /* Start the device */
 548         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
 549                         "Failed to start cryptodev %u",
 550                         ts_params->valid_devs[0]);
 551
 552         return TEST_SUCCESS;
 553 }
 554
 555 static void
 556 ut_teardown(void)
 557 {
 558         struct crypto_testsuite_params *ts_params = &testsuite_params;
 559         struct crypto_unittest_params *ut_params = &unittest_params;
 560         struct rte_cryptodev_stats stats;
 561
 562         /* free crypto session structure */
 563         if (ut_params->sess) {
 564                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
 565                                 ut_params->sess);
 566                 rte_cryptodev_sym_session_free(ut_params->sess);
 567                 ut_params->sess = NULL;
 568         }
 569
 570         /* free crypto operation structure */
 571         if (ut_params->op)
 572                 rte_crypto_op_free(ut_params->op);
 573
 574         /*
 575          * free mbuf - both obuf and ibuf are usually the same,
 576          * so check if they point at the same address is necessary,
 577          * to avoid freeing the mbuf twice.
 578          */
 579         if (ut_params->obuf) {
 580                 rte_pktmbuf_free(ut_params->obuf);
 581                 if (ut_params->ibuf == ut_params->obuf)
 582                         ut_params->ibuf = 0;
 583                 ut_params->obuf = 0;
 584         }
 585         if (ut_params->ibuf) {
 586                 rte_pktmbuf_free(ut_params->ibuf);
 587                 ut_params->ibuf = 0;
 588         }
 589
 590         if (ts_params->mbuf_pool != NULL)
 591                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 592                         rte_mempool_avail_count(ts_params->mbuf_pool));
 593
 594         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
 595
 596         /* Stop the device */
 597         rte_cryptodev_stop(ts_params->valid_devs[0]);
 598 }
 599
 600 static int
 601 test_device_configure_invalid_dev_id(void)
 602 {
 603         struct crypto_testsuite_params *ts_params = &testsuite_params;
 604         uint16_t dev_id, num_devs = 0;
 605
 606         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
 607                         "Need at least %d devices for test", 1);
 608
 609         /* valid dev_id values */
 610         dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
 611
 612         /* Stop the device in case it's started so it can be configured */
 613         rte_cryptodev_stop(dev_id);
 614
 615         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
 616                         "Failed test for rte_cryptodev_configure: "
 617                         "invalid dev_num %u", dev_id);
 618
 619         /* invalid dev_id values */
 620         dev_id = num_devs;
 621
 622         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 623                         "Failed test for rte_cryptodev_configure: "
 624                         "invalid dev_num %u", dev_id);
 625
 626         dev_id = 0xff;
 627
 628         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 629                         "Failed test for rte_cryptodev_configure:"
 630                         "invalid dev_num %u", dev_id);
 631
 632         return TEST_SUCCESS;
 633 }
 634
 635 static int
 636 test_device_configure_invalid_queue_pair_ids(void)
 637 {
 638         struct crypto_testsuite_params *ts_params = &testsuite_params;
 639         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
 640
 641         /* Stop the device in case it's started so it can be configured */
 642         rte_cryptodev_stop(ts_params->valid_devs[0]);
 643
 644         /* valid - one queue pairs */
 645         ts_params->conf.nb_queue_pairs = 1;
 646
 647         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 648                         &ts_params->conf),
 649                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 650                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 651
 652
 653         /* valid - max value queue pairs */
 654         ts_params->conf.nb_queue_pairs = orig_nb_qps;
 655
 656         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 657                         &ts_params->conf),
 658                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 659                         ts_params->valid_devs[0],
 660                         ts_params->conf.nb_queue_pairs);
 661
 662
 663         /* invalid - zero queue pairs */
 664         ts_params->conf.nb_queue_pairs = 0;
 665
 666         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 667                         &ts_params->conf),
 668                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 669                         " invalid qps: %u",
 670                         ts_params->valid_devs[0],
 671                         ts_params->conf.nb_queue_pairs);
 672
 673
 674         /* invalid - max value supported by field queue pairs */
 675         ts_params->conf.nb_queue_pairs = UINT16_MAX;
 676
 677         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 678                         &ts_params->conf),
 679                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 680                         " invalid qps: %u",
 681                         ts_params->valid_devs[0],
 682                         ts_params->conf.nb_queue_pairs);
 683
 684
 685         /* invalid - max value + 1 queue pairs */
 686         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
 687
 688         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 689                         &ts_params->conf),
 690                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 691                         " invalid qps: %u",
 692                         ts_params->valid_devs[0],
 693                         ts_params->conf.nb_queue_pairs);
 694
 695         /* revert to original testsuite value */
 696         ts_params->conf.nb_queue_pairs = orig_nb_qps;
 697
 698         return TEST_SUCCESS;
 699 }
 700
 701 static int
 702 test_queue_pair_descriptor_setup(void)
 703 {
 704         struct crypto_testsuite_params *ts_params = &testsuite_params;
 705         struct rte_cryptodev_info dev_info;
 706         struct rte_cryptodev_qp_conf qp_conf = {
 707                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
 708         };
 709
 710         uint16_t qp_id;
 711
 712         /* Stop the device in case it's started so it can be configured */
 713         rte_cryptodev_stop(ts_params->valid_devs[0]);
 714
 715
 716         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 717
 718         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 719                         &ts_params->conf),
 720                         "Failed to configure cryptodev %u",
 721                         ts_params->valid_devs[0]);
 722
 723         /*
 724          * Test various ring sizes on this device. memzones can't be
 725          * freed so are re-used if ring is released and re-created.
 726          */
 727         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
 728         qp_conf.mp_session = ts_params->session_mpool;
 729         qp_conf.mp_session_private = ts_params->session_priv_mpool;
 730
 731         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 732                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 733                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 734                                 rte_cryptodev_socket_id(
 735                                                 ts_params->valid_devs[0])),
 736                                 "Failed test for "
 737                                 "rte_cryptodev_queue_pair_setup: num_inflights "
 738                                 "%u on qp %u on cryptodev %u",
 739                                 qp_conf.nb_descriptors, qp_id,
 740                                 ts_params->valid_devs[0]);
 741         }
 742
 743         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
 744
 745         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 746                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 747                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 748                                 rte_cryptodev_socket_id(
 749                                                 ts_params->valid_devs[0])),
 750                                 "Failed test for"
 751                                 " rte_cryptodev_queue_pair_setup: num_inflights"
 752                                 " %u on qp %u on cryptodev %u",
 753                                 qp_conf.nb_descriptors, qp_id,
 754                                 ts_params->valid_devs[0]);
 755         }
 756
 757         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
 758
 759         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 760                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 761                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 762                                 rte_cryptodev_socket_id(
 763                                                 ts_params->valid_devs[0])),
 764                                 "Failed test for "
 765                                 "rte_cryptodev_queue_pair_setup: num_inflights"
 766                                 " %u on qp %u on cryptodev %u",
 767                                 qp_conf.nb_descriptors, qp_id,
 768                                 ts_params->valid_devs[0]);
 769         }
 770
 771         /* invalid number of descriptors - max supported + 2 */
 772         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
 773
 774         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 775                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 776                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 777                                 rte_cryptodev_socket_id(
 778                                                 ts_params->valid_devs[0])),
 779                                 "Unexpectedly passed test for "
 780                                 "rte_cryptodev_queue_pair_setup:"
 781                                 "num_inflights %u on qp %u on cryptodev %u",
 782                                 qp_conf.nb_descriptors, qp_id,
 783                                 ts_params->valid_devs[0]);
 784         }
 785
 786         /* invalid number of descriptors - max value of parameter */
 787         qp_conf.nb_descriptors = UINT32_MAX-1;
 788
 789         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 790                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 791                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 792                                 rte_cryptodev_socket_id(
 793                                                 ts_params->valid_devs[0])),
 794                                 "Unexpectedly passed test for "
 795                                 "rte_cryptodev_queue_pair_setup:"
 796                                 "num_inflights %u on qp %u on cryptodev %u",
 797                                 qp_conf.nb_descriptors, qp_id,
 798                                 ts_params->valid_devs[0]);
 799         }
 800
 801         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 802
 803         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 804                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 805                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 806                                 rte_cryptodev_socket_id(
 807                                                 ts_params->valid_devs[0])),
 808                                 "Failed test for"
 809                                 " rte_cryptodev_queue_pair_setup:"
 810                                 "num_inflights %u on qp %u on cryptodev %u",
 811                                 qp_conf.nb_descriptors, qp_id,
 812                                 ts_params->valid_devs[0]);
 813         }
 814
 815         /* invalid number of descriptors - max supported + 1 */
 816         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
 817
 818         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 819                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 820                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 821                                 rte_cryptodev_socket_id(
 822                                                 ts_params->valid_devs[0])),
 823                                 "Unexpectedly passed test for "
 824                                 "rte_cryptodev_queue_pair_setup:"
 825                                 "num_inflights %u on qp %u on cryptodev %u",
 826                                 qp_conf.nb_descriptors, qp_id,
 827                                 ts_params->valid_devs[0]);
 828         }
 829
 830         /* test invalid queue pair id */
 831         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
 832
 833         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
 834
 835         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 836                         ts_params->valid_devs[0],
 837                         qp_id, &qp_conf,
 838                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 839                         "Failed test for rte_cryptodev_queue_pair_setup:"
 840                         "invalid qp %u on cryptodev %u",
 841                         qp_id, ts_params->valid_devs[0]);
 842
 843         qp_id = 0xffff; /*invalid*/
 844
 845         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 846                         ts_params->valid_devs[0],
 847                         qp_id, &qp_conf,
 848                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 849                         "Failed test for rte_cryptodev_queue_pair_setup:"
 850                         "invalid qp %u on cryptodev %u",
 851                         qp_id, ts_params->valid_devs[0]);
 852
 853         return TEST_SUCCESS;
 854 }
 855
 856 /* ***** Plaintext data for tests ***** */
 857
 858 const char catch_22_quote_1[] =
 859                 "There was only one catch and that was Catch-22, which "
 860                 "specified that a concern for one's safety in the face of "
 861                 "dangers that were real and immediate was the process of a "
 862                 "rational mind. Orr was crazy and could be grounded. All he "
 863                 "had to do was ask; and as soon as he did, he would no longer "
 864                 "be crazy and would have to fly more missions. Orr would be "
 865                 "crazy to fly more missions and sane if he didn't, but if he "
 866                 "was sane he had to fly them. If he flew them he was crazy "
 867                 "and didn't have to; but if he didn't want to he was sane and "
 868                 "had to. Yossarian was moved very deeply by the absolute "
 869                 "simplicity of this clause of Catch-22 and let out a "
 870                 "respectful whistle. \"That's some catch, that Catch-22\", he "
 871                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
 872
 873 const char catch_22_quote[] =
 874                 "What a lousy earth! He wondered how many people were "
 875                 "destitute that same night even in his own prosperous country, "
 876                 "how many homes were shanties, how many husbands were drunk "
 877                 "and wives socked, and how many children were bullied, abused, "
 878                 "or abandoned. How many families hungered for food they could "
 879                 "not afford to buy? How many hearts were broken? How many "
 880                 "suicides would take place that same night, how many people "
 881                 "would go insane? How many cockroaches and landlords would "
 882                 "triumph? How many winners were losers, successes failures, "
 883                 "and rich men poor men? How many wise guys were stupid? How "
 884                 "many happy endings were unhappy endings? How many honest men "
 885                 "were liars, brave men cowards, loyal men traitors, how many "
 886                 "sainted men were corrupt, how many people in positions of "
 887                 "trust had sold their souls to bodyguards, how many had never "
 888                 "had souls? How many straight-and-narrow paths were crooked "
 889                 "paths? How many best families were worst families and how "
 890                 "many good people were bad people? When you added them all up "
 891                 "and then subtracted, you might be left with only the children, "
 892                 "and perhaps with Albert Einstein and an old violinist or "
 893                 "sculptor somewhere.";
 894
 895 #define QUOTE_480_BYTES         (480)
 896 #define QUOTE_512_BYTES         (512)
 897 #define QUOTE_768_BYTES         (768)
 898 #define QUOTE_1024_BYTES        (1024)
 899
 900
 901
 902 /* ***** SHA1 Hash Tests ***** */
 903
 904 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
 905
 906 static uint8_t hmac_sha1_key[] = {
 907         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 908         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 909         0xDE, 0xF4, 0xDE, 0xAD };
 910
 911 /* ***** SHA224 Hash Tests ***** */
 912
 913 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
 914
 915
 916 /* ***** AES-CBC Cipher Tests ***** */
 917
 918 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
 919 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
 920
 921 static uint8_t aes_cbc_key[] = {
 922         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 923         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
 924
 925 static uint8_t aes_cbc_iv[] = {
 926         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 927         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
 928
 929
 930 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
 931
 932 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
 933         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
 934         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
 935         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
 936         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
 937         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
 938         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
 939         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
 940         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
 941         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
 942         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
 943         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
 944         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
 945         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
 946         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
 947         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
 948         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
 949         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
 950         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
 951         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
 952         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
 953         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
 954         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
 955         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 956         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
 957         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
 958         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
 959         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
 960         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
 961         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
 962         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
 963         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
 964         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
 965         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
 966         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
 967         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
 968         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
 969         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
 970         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
 971         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
 972         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
 973         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
 974         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
 975         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
 976         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
 977         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
 978         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
 979         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
 980         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
 981         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
 982         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
 983         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
 984         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
 985         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
 986         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
 987         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
 988         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
 989         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
 990         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
 991         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
 992         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
 993         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
 994         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
 995         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
 996         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
 997 };
 998
 999 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1000         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1001         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1002         0x18, 0x8c, 0x1d, 0x32
1003 };
1004
1005
1006 /* Multisession Vector context Test */
1007 /*Begin Session 0 */
1008 static uint8_t ms_aes_cbc_key0[] = {
1009         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1010         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1011 };
1012
1013 static uint8_t ms_aes_cbc_iv0[] = {
1014         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1015         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1016 };
1017
1018 static const uint8_t ms_aes_cbc_cipher0[] = {
1019                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1020                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1021                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1022                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1023                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1024                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1025                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1026                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1027                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1028                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1029                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1030                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1031                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1032                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1033                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1034                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1035                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1036                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1037                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1038                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1039                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1040                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1041                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1042                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1043                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1044                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1045                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1046                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1047                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1048                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1049                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1050                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1051                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1052                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1053                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1054                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1055                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1056                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1057                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1058                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1059                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1060                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1061                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1062                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1063                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1064                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1065                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1066                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1067                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1068                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1069                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1070                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1071                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1072                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1073                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1074                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1075                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1076                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1077                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1078                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1079                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1080                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1081                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1082                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1083 };
1084
1085
1086 static  uint8_t ms_hmac_key0[] = {
1087                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1088                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1089                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1090                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1091                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1092                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1093                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1094                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1095 };
1096
1097 static const uint8_t ms_hmac_digest0[] = {
1098                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1099                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1100                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1101                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1102                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1103                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1104                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1105                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1106                 };
1107
1108 /* End Session 0 */
1109 /* Begin session 1 */
1110
1111 static  uint8_t ms_aes_cbc_key1[] = {
1112                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1113                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1114 };
1115
1116 static  uint8_t ms_aes_cbc_iv1[] = {
1117         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1118         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1119 };
1120
1121 static const uint8_t ms_aes_cbc_cipher1[] = {
1122                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1123                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1124                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1125                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1126                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1127                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1128                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1129                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1130                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1131                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1132                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1133                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1134                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1135                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1136                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1137                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1138                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1139                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1140                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1141                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1142                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1143                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1144                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1145                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1146                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1147                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1148                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1149                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1150                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1151                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1152                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1153                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1154                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1155                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1156                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1157                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1158                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1159                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1160                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1161                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1162                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1163                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1164                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1165                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1166                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1167                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1168                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1169                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1170                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1171                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1172                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1173                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1174                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1175                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1176                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1177                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1178                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1179                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1180                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1181                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1182                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1183                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1184                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1185                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1186
1187 };
1188
1189 static uint8_t ms_hmac_key1[] = {
1190                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1191                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1192                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1193                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1194                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1195                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1196                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1197                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1198 };
1199
1200 static const uint8_t ms_hmac_digest1[] = {
1201                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1202                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1203                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1204                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1205                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1206                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1207                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1208                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1209 };
1210 /* End Session 1  */
1211 /* Begin Session 2 */
1212 static  uint8_t ms_aes_cbc_key2[] = {
1213                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1214                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1215 };
1216
1217 static  uint8_t ms_aes_cbc_iv2[] = {
1218                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1219                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1220 };
1221
1222 static const uint8_t ms_aes_cbc_cipher2[] = {
1223                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1224                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1225                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1226                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1227                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1228                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1229                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1230                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1231                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1232                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1233                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1234                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1235                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1236                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1237                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1238                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1239                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1240                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1241                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1242                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1243                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1244                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1245                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1246                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1247                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1248                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1249                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1250                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1251                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1252                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1253                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1254                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1255                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1256                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1257                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1258                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1259                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1260                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1261                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1262                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1263                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1264                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1265                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1266                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1267                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1268                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1269                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1270                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1271                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1272                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1273                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1274                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1275                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1276                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1277                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1278                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1279                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1280                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1281                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1282                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1283                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1284                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1285                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1286                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1287 };
1288
1289 static  uint8_t ms_hmac_key2[] = {
1290                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1291                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1292                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1293                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1294                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1295                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1296                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1297                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1298 };
1299
1300 static const uint8_t ms_hmac_digest2[] = {
1301                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1302                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1303                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1304                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1305                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1306                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1307                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1308                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1309 };
1310
1311 /* End Session 2 */
1312
1313
1314 static int
1315 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1316 {
1317         struct crypto_testsuite_params *ts_params = &testsuite_params;
1318         struct crypto_unittest_params *ut_params = &unittest_params;
1319
1320         /* Generate test mbuf data and space for digest */
1321         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1322                         catch_22_quote, QUOTE_512_BYTES, 0);
1323
1324         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1325                         DIGEST_BYTE_LENGTH_SHA1);
1326         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1327
1328         /* Setup Cipher Parameters */
1329         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1330         ut_params->cipher_xform.next = &ut_params->auth_xform;
1331
1332         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1333         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1334         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1335         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1336         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1337         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1338
1339         /* Setup HMAC Parameters */
1340         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1341
1342         ut_params->auth_xform.next = NULL;
1343
1344         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1345         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1346         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1347         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1348         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1349
1350         ut_params->sess = rte_cryptodev_sym_session_create(
1351                         ts_params->session_mpool);
1352
1353         /* Create crypto session*/
1354         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
1355                         ut_params->sess, &ut_params->cipher_xform,
1356                         ts_params->session_priv_mpool);
1357         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1358
1359         /* Generate crypto op data structure */
1360         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1361                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1362         TEST_ASSERT_NOT_NULL(ut_params->op,
1363                         "Failed to allocate symmetric crypto operation struct");
1364
1365         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1366
1367         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1368
1369         /* set crypto operation source mbuf */
1370         sym_op->m_src = ut_params->ibuf;
1371
1372         /* Set crypto operation authentication parameters */
1373         sym_op->auth.digest.data = ut_params->digest;
1374         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1375                         ut_params->ibuf, QUOTE_512_BYTES);
1376
1377         sym_op->auth.data.offset = 0;
1378         sym_op->auth.data.length = QUOTE_512_BYTES;
1379
1380         /* Copy IV at the end of the crypto operation */
1381         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1382                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
1383
1384         /* Set crypto operation cipher parameters */
1385         sym_op->cipher.data.offset = 0;
1386         sym_op->cipher.data.length = QUOTE_512_BYTES;
1387
1388         /* Process crypto operation */
1389         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1390                         ut_params->op), "failed to process sym crypto op");
1391
1392         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1393                         "crypto op processing failed");
1394
1395         /* Validate obuf */
1396         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
1397                         uint8_t *);
1398
1399         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1400                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1401                         QUOTE_512_BYTES,
1402                         "ciphertext data not as expected");
1403
1404         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1405
1406         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1407                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1408                         gbl_driver_id == rte_cryptodev_driver_id_get(
1409                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
1410                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1411                                         DIGEST_BYTE_LENGTH_SHA1,
1412                         "Generated digest data not as expected");
1413
1414         return TEST_SUCCESS;
1415 }
1416
1417 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1418
1419 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
1420
1421 static uint8_t hmac_sha512_key[] = {
1422         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1423         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1424         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1425         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1426         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1427         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1428         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1429         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1430
1431 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1432         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1433         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1434         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1435         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1436         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1437         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1438         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1439         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1440
1441
1442
1443 static int
1444 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1445                 struct crypto_unittest_params *ut_params,
1446                 uint8_t *cipher_key,
1447                 uint8_t *hmac_key);
1448
1449 static int
1450 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1451                 struct crypto_unittest_params *ut_params,
1452                 struct crypto_testsuite_params *ts_params,
1453                 const uint8_t *cipher,
1454                 const uint8_t *digest,
1455                 const uint8_t *iv);
1456
1457
1458 static int
1459 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1460                 struct crypto_unittest_params *ut_params,
1461                 uint8_t *cipher_key,
1462                 uint8_t *hmac_key)
1463 {
1464
1465         /* Setup Cipher Parameters */
1466         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1467         ut_params->cipher_xform.next = NULL;
1468
1469         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1470         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1471         ut_params->cipher_xform.cipher.key.data = cipher_key;
1472         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1473         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1474         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1475
1476         /* Setup HMAC Parameters */
1477         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1478         ut_params->auth_xform.next = &ut_params->cipher_xform;
1479
1480         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1481         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1482         ut_params->auth_xform.auth.key.data = hmac_key;
1483         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1484         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1485
1486         return TEST_SUCCESS;
1487 }
1488
1489
1490 static int
1491 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1492                 struct crypto_unittest_params *ut_params,
1493                 struct crypto_testsuite_params *ts_params,
1494                 const uint8_t *cipher,
1495                 const uint8_t *digest,
1496                 const uint8_t *iv)
1497 {
1498         /* Generate test mbuf data and digest */
1499         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1500                         (const char *)
1501                         cipher,
1502                         QUOTE_512_BYTES, 0);
1503
1504         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1505                         DIGEST_BYTE_LENGTH_SHA512);
1506         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1507
1508         rte_memcpy(ut_params->digest,
1509                         digest,
1510                         DIGEST_BYTE_LENGTH_SHA512);
1511
1512         /* Generate Crypto op data structure */
1513         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1514                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1515         TEST_ASSERT_NOT_NULL(ut_params->op,
1516                         "Failed to allocate symmetric crypto operation struct");
1517
1518         rte_crypto_op_attach_sym_session(ut_params->op, sess);
1519
1520         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1521
1522         /* set crypto operation source mbuf */
1523         sym_op->m_src = ut_params->ibuf;
1524
1525         sym_op->auth.digest.data = ut_params->digest;
1526         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1527                         ut_params->ibuf, QUOTE_512_BYTES);
1528
1529         sym_op->auth.data.offset = 0;
1530         sym_op->auth.data.length = QUOTE_512_BYTES;
1531
1532         /* Copy IV at the end of the crypto operation */
1533         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1534                         iv, CIPHER_IV_LENGTH_AES_CBC);
1535
1536         sym_op->cipher.data.offset = 0;
1537         sym_op->cipher.data.length = QUOTE_512_BYTES;
1538
1539         /* Process crypto operation */
1540         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1541                         ut_params->op), "failed to process sym crypto op");
1542
1543         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1544                         "crypto op processing failed");
1545
1546         ut_params->obuf = ut_params->op->sym->m_src;
1547
1548         /* Validate obuf */
1549         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1550                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
1551                         catch_22_quote,
1552                         QUOTE_512_BYTES,
1553                         "Plaintext data not as expected");
1554
1555         /* Validate obuf */
1556         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1557                         "Digest verification failed");
1558
1559         return TEST_SUCCESS;
1560 }
1561
1562 static int
1563 test_AES_cipheronly_mb_all(void)
1564 {
1565         struct crypto_testsuite_params *ts_params = &testsuite_params;
1566         int status;
1567
1568         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1569                 ts_params->op_mpool,
1570                 ts_params->session_mpool, ts_params->session_priv_mpool,
1571                 ts_params->valid_devs[0],
1572                 rte_cryptodev_driver_id_get(
1573                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1574                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1575
1576         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1577
1578         return TEST_SUCCESS;
1579 }
1580
1581 static int
1582 test_AES_docsis_mb_all(void)
1583 {
1584         struct crypto_testsuite_params *ts_params = &testsuite_params;
1585         int status;
1586
1587         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1588                 ts_params->op_mpool,
1589                 ts_params->session_mpool, ts_params->session_priv_mpool,
1590                 ts_params->valid_devs[0],
1591                 rte_cryptodev_driver_id_get(
1592                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1593                 BLKCIPHER_AES_DOCSIS_TYPE);
1594
1595         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1596
1597         return TEST_SUCCESS;
1598 }
1599
1600 static int
1601 test_AES_docsis_qat_all(void)
1602 {
1603         struct crypto_testsuite_params *ts_params = &testsuite_params;
1604         int status;
1605
1606         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1607                 ts_params->op_mpool,
1608                 ts_params->session_mpool, ts_params->session_priv_mpool,
1609                 ts_params->valid_devs[0],
1610                 rte_cryptodev_driver_id_get(
1611                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1612                 BLKCIPHER_AES_DOCSIS_TYPE);
1613
1614         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1615
1616         return TEST_SUCCESS;
1617 }
1618
1619 static int
1620 test_DES_docsis_qat_all(void)
1621 {
1622         struct crypto_testsuite_params *ts_params = &testsuite_params;
1623         int status;
1624
1625         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1626                 ts_params->op_mpool,
1627                 ts_params->session_mpool, ts_params->session_priv_mpool,
1628                 ts_params->valid_devs[0],
1629                 rte_cryptodev_driver_id_get(
1630                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1631                 BLKCIPHER_DES_DOCSIS_TYPE);
1632
1633         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1634
1635         return TEST_SUCCESS;
1636 }
1637
1638 static int
1639 test_authonly_mb_all(void)
1640 {
1641         struct crypto_testsuite_params *ts_params = &testsuite_params;
1642         int status;
1643
1644         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1645                 ts_params->op_mpool,
1646                 ts_params->session_mpool, ts_params->session_priv_mpool,
1647                 ts_params->valid_devs[0],
1648                 rte_cryptodev_driver_id_get(
1649                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1650                 BLKCIPHER_AUTHONLY_TYPE);
1651
1652         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1653
1654         return TEST_SUCCESS;
1655 }
1656
1657 static int
1658 test_authonly_qat_all(void)
1659 {
1660         struct crypto_testsuite_params *ts_params = &testsuite_params;
1661         int status;
1662
1663         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1664                 ts_params->op_mpool,
1665                 ts_params->session_mpool, ts_params->session_priv_mpool,
1666                 ts_params->valid_devs[0],
1667                 rte_cryptodev_driver_id_get(
1668                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1669                 BLKCIPHER_AUTHONLY_TYPE);
1670
1671         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1672
1673         return TEST_SUCCESS;
1674 }
1675 static int
1676 test_AES_chain_mb_all(void)
1677 {
1678         struct crypto_testsuite_params *ts_params = &testsuite_params;
1679         int status;
1680
1681         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1682                 ts_params->op_mpool,
1683                 ts_params->session_mpool, ts_params->session_priv_mpool,
1684                 ts_params->valid_devs[0],
1685                 rte_cryptodev_driver_id_get(
1686                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1687                 BLKCIPHER_AES_CHAIN_TYPE);
1688
1689         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1690
1691         return TEST_SUCCESS;
1692 }
1693
1694 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
1695
1696 static int
1697 test_AES_cipheronly_scheduler_all(void)
1698 {
1699         struct crypto_testsuite_params *ts_params = &testsuite_params;
1700         int status;
1701
1702         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1703                 ts_params->op_mpool,
1704                 ts_params->session_mpool, ts_params->session_priv_mpool,
1705                 ts_params->valid_devs[0],
1706                 rte_cryptodev_driver_id_get(
1707                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1708                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1709
1710         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1711
1712         return TEST_SUCCESS;
1713 }
1714
1715 static int
1716 test_AES_chain_scheduler_all(void)
1717 {
1718         struct crypto_testsuite_params *ts_params = &testsuite_params;
1719         int status;
1720
1721         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1722                 ts_params->op_mpool,
1723                 ts_params->session_mpool, ts_params->session_priv_mpool,
1724                 ts_params->valid_devs[0],
1725                 rte_cryptodev_driver_id_get(
1726                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1727                 BLKCIPHER_AES_CHAIN_TYPE);
1728
1729         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1730
1731         return TEST_SUCCESS;
1732 }
1733
1734 static int
1735 test_authonly_scheduler_all(void)
1736 {
1737         struct crypto_testsuite_params *ts_params = &testsuite_params;
1738         int status;
1739
1740         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1741                 ts_params->op_mpool,
1742                 ts_params->session_mpool, ts_params->session_priv_mpool,
1743                 ts_params->valid_devs[0],
1744                 rte_cryptodev_driver_id_get(
1745                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1746                 BLKCIPHER_AUTHONLY_TYPE);
1747
1748         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1749
1750         return TEST_SUCCESS;
1751 }
1752
1753 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
1754
1755 static int
1756 test_AES_chain_openssl_all(void)
1757 {
1758         struct crypto_testsuite_params *ts_params = &testsuite_params;
1759         int status;
1760
1761         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1762                 ts_params->op_mpool,
1763                 ts_params->session_mpool, ts_params->session_priv_mpool,
1764                 ts_params->valid_devs[0],
1765                 rte_cryptodev_driver_id_get(
1766                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
1767                 BLKCIPHER_AES_CHAIN_TYPE);
1768
1769         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1770
1771         return TEST_SUCCESS;
1772 }
1773
1774 static int
1775 test_AES_cipheronly_openssl_all(void)
1776 {
1777         struct crypto_testsuite_params *ts_params = &testsuite_params;
1778         int status;
1779
1780         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1781                 ts_params->op_mpool,
1782                 ts_params->session_mpool, ts_params->session_priv_mpool,
1783                 ts_params->valid_devs[0],
1784                 rte_cryptodev_driver_id_get(
1785                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
1786                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1787
1788         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1789
1790         return TEST_SUCCESS;
1791 }
1792
1793 static int
1794 test_AES_chain_ccp_all(void)
1795 {
1796         struct crypto_testsuite_params *ts_params = &testsuite_params;
1797         int status;
1798
1799         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1800                 ts_params->op_mpool,
1801                 ts_params->session_mpool, ts_params->session_priv_mpool,
1802                 ts_params->valid_devs[0],
1803                 rte_cryptodev_driver_id_get(
1804                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
1805                 BLKCIPHER_AES_CHAIN_TYPE);
1806
1807         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1808
1809         return TEST_SUCCESS;
1810 }
1811
1812 static int
1813 test_AES_cipheronly_ccp_all(void)
1814 {
1815         struct crypto_testsuite_params *ts_params = &testsuite_params;
1816         int status;
1817
1818         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1819                 ts_params->op_mpool,
1820                 ts_params->session_mpool, ts_params->session_priv_mpool,
1821                 ts_params->valid_devs[0],
1822                 rte_cryptodev_driver_id_get(
1823                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
1824                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1825
1826         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1827
1828         return TEST_SUCCESS;
1829 }
1830
1831 static int
1832 test_AES_chain_qat_all(void)
1833 {
1834         struct crypto_testsuite_params *ts_params = &testsuite_params;
1835         int status;
1836
1837         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1838                 ts_params->op_mpool,
1839                 ts_params->session_mpool, ts_params->session_priv_mpool,
1840                 ts_params->valid_devs[0],
1841                 rte_cryptodev_driver_id_get(
1842                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1843                 BLKCIPHER_AES_CHAIN_TYPE);
1844
1845         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1846
1847         return TEST_SUCCESS;
1848 }
1849
1850 static int
1851 test_AES_cipheronly_qat_all(void)
1852 {
1853         struct crypto_testsuite_params *ts_params = &testsuite_params;
1854         int status;
1855
1856         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1857                 ts_params->op_mpool,
1858                 ts_params->session_mpool, ts_params->session_priv_mpool,
1859                 ts_params->valid_devs[0],
1860                 rte_cryptodev_driver_id_get(
1861                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1862                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1863
1864         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1865
1866         return TEST_SUCCESS;
1867 }
1868
1869 static int
1870 test_AES_cipheronly_virtio_all(void)
1871 {
1872         struct crypto_testsuite_params *ts_params = &testsuite_params;
1873         int status;
1874
1875         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1876                 ts_params->op_mpool,
1877                 ts_params->session_mpool, ts_params->session_priv_mpool,
1878                 ts_params->valid_devs[0],
1879                 rte_cryptodev_driver_id_get(
1880                 RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD)),
1881                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1882
1883         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1884
1885         return TEST_SUCCESS;
1886 }
1887
1888 static int
1889 test_AES_chain_caam_jr_all(void)
1890 {
1891         struct crypto_testsuite_params *ts_params = &testsuite_params;
1892         int status;
1893
1894         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1895                 ts_params->op_mpool,
1896                 ts_params->session_mpool, ts_params->session_priv_mpool,
1897                 ts_params->valid_devs[0],
1898                 rte_cryptodev_driver_id_get(
1899                 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
1900                 BLKCIPHER_AES_CHAIN_TYPE);
1901
1902         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1903
1904         return TEST_SUCCESS;
1905 }
1906
1907 static int
1908 test_AES_cipheronly_caam_jr_all(void)
1909 {
1910         struct crypto_testsuite_params *ts_params = &testsuite_params;
1911         int status;
1912
1913         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1914                 ts_params->op_mpool,
1915                 ts_params->session_mpool, ts_params->session_priv_mpool,
1916                 ts_params->valid_devs[0],
1917                 rte_cryptodev_driver_id_get(
1918                 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
1919                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1920
1921         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1922
1923         return TEST_SUCCESS;
1924 }
1925
1926 static int
1927 test_authonly_caam_jr_all(void)
1928 {
1929         struct crypto_testsuite_params *ts_params = &testsuite_params;
1930         int status;
1931
1932         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1933                 ts_params->op_mpool,
1934                 ts_params->session_mpool, ts_params->session_priv_mpool,
1935                 ts_params->valid_devs[0],
1936                 rte_cryptodev_driver_id_get(
1937                 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
1938                 BLKCIPHER_AUTHONLY_TYPE);
1939
1940         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1941
1942         return TEST_SUCCESS;
1943 }
1944
1945
1946 static int
1947 test_AES_chain_dpaa_sec_all(void)
1948 {
1949         struct crypto_testsuite_params *ts_params = &testsuite_params;
1950         int status;
1951
1952         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1953                 ts_params->op_mpool,
1954                 ts_params->session_mpool, ts_params->session_priv_mpool,
1955                 ts_params->valid_devs[0],
1956                 rte_cryptodev_driver_id_get(
1957                 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
1958                 BLKCIPHER_AES_CHAIN_TYPE);
1959
1960         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1961
1962         return TEST_SUCCESS;
1963 }
1964
1965 static int
1966 test_AES_cipheronly_dpaa_sec_all(void)
1967 {
1968         struct crypto_testsuite_params *ts_params = &testsuite_params;
1969         int status;
1970
1971         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1972                 ts_params->op_mpool,
1973                 ts_params->session_mpool, ts_params->session_priv_mpool,
1974                 ts_params->valid_devs[0],
1975                 rte_cryptodev_driver_id_get(
1976                 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
1977                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1978
1979         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1980
1981         return TEST_SUCCESS;
1982 }
1983
1984 static int
1985 test_authonly_dpaa_sec_all(void)
1986 {
1987         struct crypto_testsuite_params *ts_params = &testsuite_params;
1988         int status;
1989
1990         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1991                 ts_params->op_mpool,
1992                 ts_params->session_mpool, ts_params->session_priv_mpool,
1993                 ts_params->valid_devs[0],
1994                 rte_cryptodev_driver_id_get(
1995                 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
1996                 BLKCIPHER_AUTHONLY_TYPE);
1997
1998         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1999
2000         return TEST_SUCCESS;
2001 }
2002
2003 static int
2004 test_AES_chain_dpaa2_sec_all(void)
2005 {
2006         struct crypto_testsuite_params *ts_params = &testsuite_params;
2007         int status;
2008
2009         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2010                 ts_params->op_mpool,
2011                 ts_params->session_mpool, ts_params->session_priv_mpool,
2012                 ts_params->valid_devs[0],
2013                 rte_cryptodev_driver_id_get(
2014                 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
2015                 BLKCIPHER_AES_CHAIN_TYPE);
2016
2017         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2018
2019         return TEST_SUCCESS;
2020 }
2021
2022 static int
2023 test_AES_cipheronly_dpaa2_sec_all(void)
2024 {
2025         struct crypto_testsuite_params *ts_params = &testsuite_params;
2026         int status;
2027
2028         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2029                 ts_params->op_mpool,
2030                 ts_params->session_mpool, ts_params->session_priv_mpool,
2031                 ts_params->valid_devs[0],
2032                 rte_cryptodev_driver_id_get(
2033                 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
2034                 BLKCIPHER_AES_CIPHERONLY_TYPE);
2035
2036         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2037
2038         return TEST_SUCCESS;
2039 }
2040
2041 static int
2042 test_authonly_dpaa2_sec_all(void)
2043 {
2044         struct crypto_testsuite_params *ts_params = &testsuite_params;
2045         int status;
2046
2047         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2048                 ts_params->op_mpool,
2049                 ts_params->session_mpool, ts_params->session_priv_mpool,
2050                 ts_params->valid_devs[0],
2051                 rte_cryptodev_driver_id_get(
2052                 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
2053                 BLKCIPHER_AUTHONLY_TYPE);
2054
2055         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2056
2057         return TEST_SUCCESS;
2058 }
2059
2060 static int
2061 test_authonly_openssl_all(void)
2062 {
2063         struct crypto_testsuite_params *ts_params = &testsuite_params;
2064         int status;
2065
2066         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2067                 ts_params->op_mpool,
2068                 ts_params->session_mpool, ts_params->session_priv_mpool,
2069                 ts_params->valid_devs[0],
2070                 rte_cryptodev_driver_id_get(
2071                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
2072                 BLKCIPHER_AUTHONLY_TYPE);
2073
2074         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2075
2076         return TEST_SUCCESS;
2077 }
2078
2079 static int
2080 test_authonly_ccp_all(void)
2081 {
2082         struct crypto_testsuite_params *ts_params = &testsuite_params;
2083         int status;
2084
2085         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2086                 ts_params->op_mpool,
2087                 ts_params->session_mpool, ts_params->session_priv_mpool,
2088                 ts_params->valid_devs[0],
2089                 rte_cryptodev_driver_id_get(
2090                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
2091                 BLKCIPHER_AUTHONLY_TYPE);
2092
2093         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2094
2095         return TEST_SUCCESS;
2096 }
2097
2098 static int
2099 test_AES_chain_armv8_all(void)
2100 {
2101         struct crypto_testsuite_params *ts_params = &testsuite_params;
2102         int status;
2103
2104         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2105                 ts_params->op_mpool,
2106                 ts_params->session_mpool, ts_params->session_priv_mpool,
2107                 ts_params->valid_devs[0],
2108                 rte_cryptodev_driver_id_get(
2109                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)),
2110                 BLKCIPHER_AES_CHAIN_TYPE);
2111
2112         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2113
2114         return TEST_SUCCESS;
2115 }
2116
2117 static int
2118 test_AES_chain_mrvl_all(void)
2119 {
2120         struct crypto_testsuite_params *ts_params = &testsuite_params;
2121         int status;
2122
2123         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2124                 ts_params->op_mpool,
2125                 ts_params->session_mpool, ts_params->session_priv_mpool,
2126                 ts_params->valid_devs[0],
2127                 rte_cryptodev_driver_id_get(
2128                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2129                 BLKCIPHER_AES_CHAIN_TYPE);
2130
2131         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2132
2133         return TEST_SUCCESS;
2134 }
2135
2136 static int
2137 test_AES_cipheronly_mrvl_all(void)
2138 {
2139         struct crypto_testsuite_params *ts_params = &testsuite_params;
2140         int status;
2141
2142         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2143                 ts_params->op_mpool,
2144                 ts_params->session_mpool, ts_params->session_priv_mpool,
2145                 ts_params->valid_devs[0],
2146                 rte_cryptodev_driver_id_get(
2147                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2148                 BLKCIPHER_AES_CIPHERONLY_TYPE);
2149
2150         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2151
2152         return TEST_SUCCESS;
2153 }
2154
2155 static int
2156 test_authonly_mrvl_all(void)
2157 {
2158         struct crypto_testsuite_params *ts_params = &testsuite_params;
2159         int status;
2160
2161         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2162                 ts_params->op_mpool,
2163                 ts_params->session_mpool, ts_params->session_priv_mpool,
2164                 ts_params->valid_devs[0],
2165                 rte_cryptodev_driver_id_get(
2166                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2167                 BLKCIPHER_AUTHONLY_TYPE);
2168
2169         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2170
2171         return TEST_SUCCESS;
2172 }
2173
2174 static int
2175 test_3DES_chain_mrvl_all(void)
2176 {
2177         struct crypto_testsuite_params *ts_params = &testsuite_params;
2178         int status;
2179
2180         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2181                 ts_params->op_mpool,
2182                 ts_params->session_mpool, ts_params->session_priv_mpool,
2183                 ts_params->valid_devs[0],
2184                 rte_cryptodev_driver_id_get(
2185                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2186                 BLKCIPHER_3DES_CHAIN_TYPE);
2187
2188         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2189
2190         return TEST_SUCCESS;
2191 }
2192
2193 static int
2194 test_3DES_cipheronly_mrvl_all(void)
2195 {
2196         struct crypto_testsuite_params *ts_params = &testsuite_params;
2197         int status;
2198
2199         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2200                 ts_params->op_mpool,
2201                 ts_params->session_mpool, ts_params->session_priv_mpool,
2202                 ts_params->valid_devs[0],
2203                 rte_cryptodev_driver_id_get(
2204                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2205                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
2206
2207         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2208
2209         return TEST_SUCCESS;
2210 }
2211
2212 static int
2213 test_AES_chain_octeontx_all(void)
2214 {
2215         struct crypto_testsuite_params *ts_params = &testsuite_params;
2216         int status;
2217
2218         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2219                 ts_params->op_mpool, ts_params->session_mpool,
2220                 ts_params->session_priv_mpool,
2221                 ts_params->valid_devs[0],
2222                 rte_cryptodev_driver_id_get(
2223                 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2224                 BLKCIPHER_AES_CHAIN_TYPE);
2225
2226         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2227
2228         return TEST_SUCCESS;
2229 }
2230
2231 static int
2232 test_AES_cipheronly_octeontx_all(void)
2233 {
2234         struct crypto_testsuite_params *ts_params = &testsuite_params;
2235         int status;
2236
2237         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2238                 ts_params->op_mpool, ts_params->session_mpool,
2239                 ts_params->session_priv_mpool,
2240                 ts_params->valid_devs[0],
2241                 rte_cryptodev_driver_id_get(
2242                 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2243                 BLKCIPHER_AES_CIPHERONLY_TYPE);
2244
2245         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2246
2247         return TEST_SUCCESS;
2248 }
2249
2250 static int
2251 test_3DES_chain_octeontx_all(void)
2252 {
2253         struct crypto_testsuite_params *ts_params = &testsuite_params;
2254         int status;
2255
2256         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2257                 ts_params->op_mpool, ts_params->session_mpool,
2258                 ts_params->session_priv_mpool,
2259                 ts_params->valid_devs[0],
2260                 rte_cryptodev_driver_id_get(
2261                 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2262                 BLKCIPHER_3DES_CHAIN_TYPE);
2263
2264         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2265
2266         return TEST_SUCCESS;
2267 }
2268
2269 static int
2270 test_3DES_cipheronly_octeontx_all(void)
2271 {
2272         struct crypto_testsuite_params *ts_params = &testsuite_params;
2273         int status;
2274
2275         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2276                 ts_params->op_mpool, ts_params->session_mpool,
2277                 ts_params->session_priv_mpool,
2278                 ts_params->valid_devs[0],
2279                 rte_cryptodev_driver_id_get(
2280                 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2281                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
2282
2283         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2284
2285         return TEST_SUCCESS;
2286 }
2287
2288 static int
2289 test_authonly_octeontx_all(void)
2290 {
2291         struct crypto_testsuite_params *ts_params = &testsuite_params;
2292         int status;
2293
2294         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2295                 ts_params->op_mpool, ts_params->session_mpool,
2296                 ts_params->session_priv_mpool,
2297                 ts_params->valid_devs[0],
2298                 rte_cryptodev_driver_id_get(
2299                 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2300                 BLKCIPHER_AUTHONLY_TYPE);
2301
2302         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2303
2304         return TEST_SUCCESS;
2305 }
2306
2307 /* ***** SNOW 3G Tests ***** */
2308 static int
2309 create_wireless_algo_hash_session(uint8_t dev_id,
2310         const uint8_t *key, const uint8_t key_len,
2311         const uint8_t iv_len, const uint8_t auth_len,
2312         enum rte_crypto_auth_operation op,
2313         enum rte_crypto_auth_algorithm algo)
2314 {
2315         uint8_t hash_key[key_len];
2316
2317         struct crypto_testsuite_params *ts_params = &testsuite_params;
2318         struct crypto_unittest_params *ut_params = &unittest_params;
2319
2320         memcpy(hash_key, key, key_len);
2321
2322         debug_hexdump(stdout, "key:", key, key_len);
2323
2324         /* Setup Authentication Parameters */
2325         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2326         ut_params->auth_xform.next = NULL;
2327
2328         ut_params->auth_xform.auth.op = op;
2329         ut_params->auth_xform.auth.algo = algo;
2330         ut_params->auth_xform.auth.key.length = key_len;
2331         ut_params->auth_xform.auth.key.data = hash_key;
2332         ut_params->auth_xform.auth.digest_length = auth_len;
2333         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2334         ut_params->auth_xform.auth.iv.length = iv_len;
2335         ut_params->sess = rte_cryptodev_sym_session_create(
2336                         ts_params->session_mpool);
2337
2338         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2339                         &ut_params->auth_xform,
2340                         ts_params->session_priv_mpool);
2341         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2342         return 0;
2343 }
2344
2345 static int
2346 create_wireless_algo_cipher_session(uint8_t dev_id,
2347                         enum rte_crypto_cipher_operation op,
2348                         enum rte_crypto_cipher_algorithm algo,
2349                         const uint8_t *key, const uint8_t key_len,
2350                         uint8_t iv_len)
2351 {
2352         uint8_t cipher_key[key_len];
2353
2354         struct crypto_testsuite_params *ts_params = &testsuite_params;
2355         struct crypto_unittest_params *ut_params = &unittest_params;
2356
2357         memcpy(cipher_key, key, key_len);
2358
2359         /* Setup Cipher Parameters */
2360         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2361         ut_params->cipher_xform.next = NULL;
2362
2363         ut_params->cipher_xform.cipher.algo = algo;
2364         ut_params->cipher_xform.cipher.op = op;
2365         ut_params->cipher_xform.cipher.key.data = cipher_key;
2366         ut_params->cipher_xform.cipher.key.length = key_len;
2367         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2368         ut_params->cipher_xform.cipher.iv.length = iv_len;
2369
2370         debug_hexdump(stdout, "key:", key, key_len);
2371
2372         /* Create Crypto session */
2373         ut_params->sess = rte_cryptodev_sym_session_create(
2374                         ts_params->session_mpool);
2375
2376         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2377                         &ut_params->cipher_xform,
2378                         ts_params->session_priv_mpool);
2379         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2380         return 0;
2381 }
2382
2383 static int
2384 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2385                         unsigned int cipher_len,
2386                         unsigned int cipher_offset)
2387 {
2388         struct crypto_testsuite_params *ts_params = &testsuite_params;
2389         struct crypto_unittest_params *ut_params = &unittest_params;
2390
2391         /* Generate Crypto op data structure */
2392         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2393                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2394         TEST_ASSERT_NOT_NULL(ut_params->op,
2395                                 "Failed to allocate pktmbuf offload");
2396
2397         /* Set crypto operation data parameters */
2398         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2399
2400         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2401
2402         /* set crypto operation source mbuf */
2403         sym_op->m_src = ut_params->ibuf;
2404
2405         /* iv */
2406         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2407                         iv, iv_len);
2408         sym_op->cipher.data.length = cipher_len;
2409         sym_op->cipher.data.offset = cipher_offset;
2410         return 0;
2411 }
2412
2413 static int
2414 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2415                         unsigned int cipher_len,
2416                         unsigned int cipher_offset)
2417 {
2418         struct crypto_testsuite_params *ts_params = &testsuite_params;
2419         struct crypto_unittest_params *ut_params = &unittest_params;
2420
2421         /* Generate Crypto op data structure */
2422         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2423                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2424         TEST_ASSERT_NOT_NULL(ut_params->op,
2425                                 "Failed to allocate pktmbuf offload");
2426
2427         /* Set crypto operation data parameters */
2428         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2429
2430         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2431
2432         /* set crypto operation source mbuf */
2433         sym_op->m_src = ut_params->ibuf;
2434         sym_op->m_dst = ut_params->obuf;
2435
2436         /* iv */
2437         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2438                         iv, iv_len);
2439         sym_op->cipher.data.length = cipher_len;
2440         sym_op->cipher.data.offset = cipher_offset;
2441         return 0;
2442 }
2443
2444 static int
2445 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2446                 enum rte_crypto_cipher_operation cipher_op,
2447                 enum rte_crypto_auth_operation auth_op,
2448                 enum rte_crypto_auth_algorithm auth_algo,
2449                 enum rte_crypto_cipher_algorithm cipher_algo,
2450                 const uint8_t *key, uint8_t key_len,
2451                 uint8_t auth_iv_len, uint8_t auth_len,
2452                 uint8_t cipher_iv_len)
2453
2454 {
2455         uint8_t cipher_auth_key[key_len];
2456
2457         struct crypto_testsuite_params *ts_params = &testsuite_params;
2458         struct crypto_unittest_params *ut_params = &unittest_params;
2459
2460         memcpy(cipher_auth_key, key, key_len);
2461
2462         /* Setup Authentication Parameters */
2463         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2464         ut_params->auth_xform.next = NULL;
2465
2466         ut_params->auth_xform.auth.op = auth_op;
2467         ut_params->auth_xform.auth.algo = auth_algo;
2468         ut_params->auth_xform.auth.key.length = key_len;
2469         /* Hash key = cipher key */
2470         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2471         ut_params->auth_xform.auth.digest_length = auth_len;
2472         /* Auth IV will be after cipher IV */
2473         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2474         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2475
2476         /* Setup Cipher Parameters */
2477         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2478         ut_params->cipher_xform.next = &ut_params->auth_xform;
2479
2480         ut_params->cipher_xform.cipher.algo = cipher_algo;
2481         ut_params->cipher_xform.cipher.op = cipher_op;
2482         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2483         ut_params->cipher_xform.cipher.key.length = key_len;
2484         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2485         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2486
2487         debug_hexdump(stdout, "key:", key, key_len);
2488
2489         /* Create Crypto session*/
2490         ut_params->sess = rte_cryptodev_sym_session_create(
2491                         ts_params->session_mpool);
2492
2493         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2494                         &ut_params->cipher_xform,
2495                         ts_params->session_priv_mpool);
2496
2497         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2498         return 0;
2499 }
2500
2501 static int
2502 create_wireless_cipher_auth_session(uint8_t dev_id,
2503                 enum rte_crypto_cipher_operation cipher_op,
2504                 enum rte_crypto_auth_operation auth_op,
2505                 enum rte_crypto_auth_algorithm auth_algo,
2506                 enum rte_crypto_cipher_algorithm cipher_algo,
2507                 const struct wireless_test_data *tdata)
2508 {
2509         const uint8_t key_len = tdata->key.len;
2510         uint8_t cipher_auth_key[key_len];
2511
2512         struct crypto_testsuite_params *ts_params = &testsuite_params;
2513         struct crypto_unittest_params *ut_params = &unittest_params;
2514         const uint8_t *key = tdata->key.data;
2515         const uint8_t auth_len = tdata->digest.len;
2516         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2517         uint8_t auth_iv_len = tdata->auth_iv.len;
2518
2519         memcpy(cipher_auth_key, key, key_len);
2520
2521         /* Setup Authentication Parameters */
2522         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2523         ut_params->auth_xform.next = NULL;
2524
2525         ut_params->auth_xform.auth.op = auth_op;
2526         ut_params->auth_xform.auth.algo = auth_algo;
2527         ut_params->auth_xform.auth.key.length = key_len;
2528         /* Hash key = cipher key */
2529         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2530         ut_params->auth_xform.auth.digest_length = auth_len;
2531         /* Auth IV will be after cipher IV */
2532         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2533         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2534
2535         /* Setup Cipher Parameters */
2536         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2537         ut_params->cipher_xform.next = &ut_params->auth_xform;
2538
2539         ut_params->cipher_xform.cipher.algo = cipher_algo;
2540         ut_params->cipher_xform.cipher.op = cipher_op;
2541         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2542         ut_params->cipher_xform.cipher.key.length = key_len;
2543         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2544         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2545
2546
2547         debug_hexdump(stdout, "key:", key, key_len);
2548
2549         /* Create Crypto session*/
2550         ut_params->sess = rte_cryptodev_sym_session_create(
2551                         ts_params->session_mpool);
2552
2553         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2554                         &ut_params->cipher_xform,
2555                         ts_params->session_priv_mpool);
2556
2557         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2558         return 0;
2559 }
2560
2561 static int
2562 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2563                 const struct wireless_test_data *tdata)
2564 {
2565         return create_wireless_cipher_auth_session(dev_id,
2566                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2567                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2568                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2569 }
2570
2571 static int
2572 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2573                 enum rte_crypto_cipher_operation cipher_op,
2574                 enum rte_crypto_auth_operation auth_op,
2575                 enum rte_crypto_auth_algorithm auth_algo,
2576                 enum rte_crypto_cipher_algorithm cipher_algo,
2577                 const uint8_t *key, const uint8_t key_len,
2578                 uint8_t auth_iv_len, uint8_t auth_len,
2579                 uint8_t cipher_iv_len)
2580 {
2581         uint8_t auth_cipher_key[key_len];
2582
2583         struct crypto_testsuite_params *ts_params = &testsuite_params;
2584         struct crypto_unittest_params *ut_params = &unittest_params;
2585
2586         memcpy(auth_cipher_key, key, key_len);
2587
2588         /* Setup Authentication Parameters */
2589         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2590         ut_params->auth_xform.auth.op = auth_op;
2591         ut_params->auth_xform.next = &ut_params->cipher_xform;
2592         ut_params->auth_xform.auth.algo = auth_algo;
2593         ut_params->auth_xform.auth.key.length = key_len;
2594         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2595         ut_params->auth_xform.auth.digest_length = auth_len;
2596         /* Auth IV will be after cipher IV */
2597         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2598         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2599
2600         /* Setup Cipher Parameters */
2601         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2602         ut_params->cipher_xform.next = NULL;
2603         ut_params->cipher_xform.cipher.algo = cipher_algo;
2604         ut_params->cipher_xform.cipher.op = cipher_op;
2605         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2606         ut_params->cipher_xform.cipher.key.length = key_len;
2607         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2608         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2609
2610         debug_hexdump(stdout, "key:", key, key_len);
2611
2612         /* Create Crypto session*/
2613         ut_params->sess = rte_cryptodev_sym_session_create(
2614                         ts_params->session_mpool);
2615
2616         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2617                         &ut_params->auth_xform,
2618                         ts_params->session_priv_mpool);
2619
2620         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2621
2622         return 0;
2623 }
2624
2625 static int
2626 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2627                 unsigned int auth_tag_len,
2628                 const uint8_t *iv, unsigned int iv_len,
2629                 unsigned int data_pad_len,
2630                 enum rte_crypto_auth_operation op,
2631                 unsigned int auth_len, unsigned int auth_offset)
2632 {
2633         struct crypto_testsuite_params *ts_params = &testsuite_params;
2634
2635         struct crypto_unittest_params *ut_params = &unittest_params;
2636
2637         /* Generate Crypto op data structure */
2638         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2639                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2640         TEST_ASSERT_NOT_NULL(ut_params->op,
2641                 "Failed to allocate pktmbuf offload");
2642
2643         /* Set crypto operation data parameters */
2644         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2645
2646         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2647
2648         /* set crypto operation source mbuf */
2649         sym_op->m_src = ut_params->ibuf;
2650
2651         /* iv */
2652         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2653                         iv, iv_len);
2654         /* digest */
2655         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2656                                         ut_params->ibuf, auth_tag_len);
2657
2658         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2659                                 "no room to append auth tag");
2660         ut_params->digest = sym_op->auth.digest.data;
2661         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2662                         ut_params->ibuf, data_pad_len);
2663         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2664                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2665         else
2666                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2667
2668         debug_hexdump(stdout, "digest:",
2669                 sym_op->auth.digest.data,
2670                 auth_tag_len);
2671
2672         sym_op->auth.data.length = auth_len;
2673         sym_op->auth.data.offset = auth_offset;
2674
2675         return 0;
2676 }
2677
2678 static int
2679 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2680         enum rte_crypto_auth_operation op)
2681 {
2682         struct crypto_testsuite_params *ts_params = &testsuite_params;
2683         struct crypto_unittest_params *ut_params = &unittest_params;
2684
2685         const uint8_t *auth_tag = tdata->digest.data;
2686         const unsigned int auth_tag_len = tdata->digest.len;
2687         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2688         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2689
2690         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2691         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2692         const uint8_t *auth_iv = tdata->auth_iv.data;
2693         const uint8_t auth_iv_len = tdata->auth_iv.len;
2694         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2695         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2696
2697         /* Generate Crypto op data structure */
2698         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2699                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2700         TEST_ASSERT_NOT_NULL(ut_params->op,
2701                         "Failed to allocate pktmbuf offload");
2702         /* Set crypto operation data parameters */
2703         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2704
2705         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2706
2707         /* set crypto operation source mbuf */
2708         sym_op->m_src = ut_params->ibuf;
2709
2710         /* digest */
2711         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2712                         ut_params->ibuf, auth_tag_len);
2713
2714         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2715                         "no room to append auth tag");
2716         ut_params->digest = sym_op->auth.digest.data;
2717         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2718                         ut_params->ibuf, data_pad_len);
2719         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2720                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2721         else
2722                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2723
2724         debug_hexdump(stdout, "digest:",
2725                 sym_op->auth.digest.data,
2726                 auth_tag_len);
2727
2728         /* Copy cipher and auth IVs at the end of the crypto operation */
2729         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2730                                                 IV_OFFSET);
2731         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2732         iv_ptr += cipher_iv_len;
2733         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2734
2735         sym_op->cipher.data.length = cipher_len;
2736         sym_op->cipher.data.offset = 0;
2737         sym_op->auth.data.length = auth_len;
2738         sym_op->auth.data.offset = 0;
2739
2740         return 0;
2741 }
2742
2743 static int
2744 create_zuc_cipher_hash_generate_operation(
2745                 const struct wireless_test_data *tdata)
2746 {
2747         return create_wireless_cipher_hash_operation(tdata,
2748                 RTE_CRYPTO_AUTH_OP_GENERATE);
2749 }
2750
2751 static int
2752 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2753                 const unsigned auth_tag_len,
2754                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2755                 unsigned data_pad_len,
2756                 enum rte_crypto_auth_operation op,
2757                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2758                 const unsigned cipher_len, const unsigned cipher_offset,
2759                 const unsigned auth_len, const unsigned auth_offset)
2760 {
2761         struct crypto_testsuite_params *ts_params = &testsuite_params;
2762         struct crypto_unittest_params *ut_params = &unittest_params;
2763
2764         /* Generate Crypto op data structure */
2765         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2766                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2767         TEST_ASSERT_NOT_NULL(ut_params->op,
2768                         "Failed to allocate pktmbuf offload");
2769         /* Set crypto operation data parameters */
2770         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2771
2772         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2773
2774         /* set crypto operation source mbuf */
2775         sym_op->m_src = ut_params->ibuf;
2776
2777         /* digest */
2778         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2779                         ut_params->ibuf, auth_tag_len);
2780
2781         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2782                         "no room to append auth tag");
2783         ut_params->digest = sym_op->auth.digest.data;
2784         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2785                         ut_params->ibuf, data_pad_len);
2786         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2787                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2788         else
2789                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2790
2791         debug_hexdump(stdout, "digest:",
2792                 sym_op->auth.digest.data,
2793                 auth_tag_len);
2794
2795         /* Copy cipher and auth IVs at the end of the crypto operation */
2796         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2797                                                 IV_OFFSET);
2798         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2799         iv_ptr += cipher_iv_len;
2800         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2801
2802         sym_op->cipher.data.length = cipher_len;
2803         sym_op->cipher.data.offset = cipher_offset;
2804         sym_op->auth.data.length = auth_len;
2805         sym_op->auth.data.offset = auth_offset;
2806
2807         return 0;
2808 }
2809
2810 static int
2811 create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len,
2812                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2813                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2814                 unsigned int data_pad_len,
2815                 unsigned int cipher_len, unsigned int cipher_offset,
2816                 unsigned int auth_len, unsigned int auth_offset)
2817 {
2818         struct crypto_testsuite_params *ts_params = &testsuite_params;
2819         struct crypto_unittest_params *ut_params = &unittest_params;
2820
2821         /* Generate Crypto op data structure */
2822         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2823                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2824         TEST_ASSERT_NOT_NULL(ut_params->op,
2825                         "Failed to allocate pktmbuf offload");
2826
2827         /* Set crypto operation data parameters */
2828         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2829
2830         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2831
2832         /* set crypto operation source mbuf */
2833         sym_op->m_src = ut_params->ibuf;
2834
2835         /* digest */
2836         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2837                         ut_params->ibuf, auth_tag_len);
2838
2839         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2840                         "no room to append auth tag");
2841
2842         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2843                         ut_params->ibuf, data_pad_len);
2844
2845         memset(sym_op->auth.digest.data, 0, auth_tag_len);
2846
2847         debug_hexdump(stdout, "digest:",
2848                         sym_op->auth.digest.data,
2849                         auth_tag_len);
2850
2851         /* Copy cipher and auth IVs at the end of the crypto operation */
2852         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2853                                                 IV_OFFSET);
2854         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2855         iv_ptr += cipher_iv_len;
2856         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2857
2858         sym_op->cipher.data.length = cipher_len;
2859         sym_op->cipher.data.offset = cipher_offset;
2860
2861         sym_op->auth.data.length = auth_len;
2862         sym_op->auth.data.offset = auth_offset;
2863
2864         return 0;
2865 }
2866
2867 static int
2868 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2869 {
2870         struct crypto_testsuite_params *ts_params = &testsuite_params;
2871         struct crypto_unittest_params *ut_params = &unittest_params;
2872
2873         int retval;
2874         unsigned plaintext_pad_len;
2875         unsigned plaintext_len;
2876         uint8_t *plaintext;
2877
2878         /* Create SNOW 3G session */
2879         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2880                         tdata->key.data, tdata->key.len,
2881                         tdata->auth_iv.len, tdata->digest.len,
2882                         RTE_CRYPTO_AUTH_OP_GENERATE,
2883                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2884         if (retval < 0)
2885                 return retval;
2886
2887         /* alloc mbuf and set payload */
2888         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2889
2890         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2891         rte_pktmbuf_tailroom(ut_params->ibuf));
2892
2893         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2894         /* Append data which is padded to a multiple of */
2895         /* the algorithms block size */
2896         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2897         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2898                                 plaintext_pad_len);
2899         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2900
2901         /* Create SNOW 3G operation */
2902         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2903                         tdata->auth_iv.data, tdata->auth_iv.len,
2904                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2905                         tdata->validAuthLenInBits.len,
2906                         0);
2907         if (retval < 0)
2908                 return retval;
2909
2910         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2911                                 ut_params->op);
2912         ut_params->obuf = ut_params->op->sym->m_src;
2913         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2914         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2915                         + plaintext_pad_len;
2916
2917         /* Validate obuf */
2918         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2919         ut_params->digest,
2920         tdata->digest.data,
2921         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2922         "SNOW 3G Generated auth tag not as expected");
2923
2924         return 0;
2925 }
2926
2927 static int
2928 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2929 {
2930         struct crypto_testsuite_params *ts_params = &testsuite_params;
2931         struct crypto_unittest_params *ut_params = &unittest_params;
2932
2933         int retval;
2934         unsigned plaintext_pad_len;
2935         unsigned plaintext_len;
2936         uint8_t *plaintext;
2937
2938         /* Create SNOW 3G session */
2939         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2940                                 tdata->key.data, tdata->key.len,
2941                                 tdata->auth_iv.len, tdata->digest.len,
2942                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2943                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2944         if (retval < 0)
2945                 return retval;
2946         /* alloc mbuf and set payload */
2947         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2948
2949         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2950         rte_pktmbuf_tailroom(ut_params->ibuf));
2951
2952         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2953         /* Append data which is padded to a multiple of */
2954         /* the algorithms block size */
2955         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2956         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2957                                 plaintext_pad_len);
2958         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2959
2960         /* Create SNOW 3G operation */
2961         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2962                         tdata->digest.len,
2963                         tdata->auth_iv.data, tdata->auth_iv.len,
2964                         plaintext_pad_len,
2965                         RTE_CRYPTO_AUTH_OP_VERIFY,
2966                         tdata->validAuthLenInBits.len,
2967                         0);
2968         if (retval < 0)
2969                 return retval;
2970
2971         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2972                                 ut_params->op);
2973         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2974         ut_params->obuf = ut_params->op->sym->m_src;
2975         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2976                                 + plaintext_pad_len;
2977
2978         /* Validate obuf */
2979         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2980                 return 0;
2981         else
2982                 return -1;
2983
2984         return 0;
2985 }
2986
2987 static int
2988 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2989 {
2990         struct crypto_testsuite_params *ts_params = &testsuite_params;
2991         struct crypto_unittest_params *ut_params = &unittest_params;
2992
2993         int retval;
2994         unsigned plaintext_pad_len;
2995         unsigned plaintext_len;
2996         uint8_t *plaintext;
2997
2998         /* Create KASUMI session */
2999         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3000                         tdata->key.data, tdata->key.len,
3001                         0, tdata->digest.len,
3002                         RTE_CRYPTO_AUTH_OP_GENERATE,
3003                         RTE_CRYPTO_AUTH_KASUMI_F9);
3004         if (retval < 0)
3005                 return retval;
3006
3007         /* alloc mbuf and set payload */
3008         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3009
3010         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3011         rte_pktmbuf_tailroom(ut_params->ibuf));
3012
3013         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3014         /* Append data which is padded to a multiple of */
3015         /* the algorithms block size */
3016         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3017         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3018                                 plaintext_pad_len);
3019         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3020
3021         /* Create KASUMI operation */
3022         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3023                         NULL, 0,
3024                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3025                         tdata->plaintext.len,
3026                         0);
3027         if (retval < 0)
3028                 return retval;
3029
3030         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3031                                 ut_params->op);
3032         ut_params->obuf = ut_params->op->sym->m_src;
3033         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3034         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3035                         + plaintext_pad_len;
3036
3037         /* Validate obuf */
3038         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3039         ut_params->digest,
3040         tdata->digest.data,
3041         DIGEST_BYTE_LENGTH_KASUMI_F9,
3042         "KASUMI Generated auth tag not as expected");
3043
3044         return 0;
3045 }
3046
3047 static int
3048 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3049 {
3050         struct crypto_testsuite_params *ts_params = &testsuite_params;
3051         struct crypto_unittest_params *ut_params = &unittest_params;
3052
3053         int retval;
3054         unsigned plaintext_pad_len;
3055         unsigned plaintext_len;
3056         uint8_t *plaintext;
3057
3058         /* Create KASUMI session */
3059         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3060                                 tdata->key.data, tdata->key.len,
3061                                 0, tdata->digest.len,
3062                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3063                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3064         if (retval < 0)
3065                 return retval;
3066         /* alloc mbuf and set payload */
3067         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3068
3069         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3070         rte_pktmbuf_tailroom(ut_params->ibuf));
3071
3072         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3073         /* Append data which is padded to a multiple */
3074         /* of the algorithms block size */
3075         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3076         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3077                                 plaintext_pad_len);
3078         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3079
3080         /* Create KASUMI operation */
3081         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3082                         tdata->digest.len,
3083                         NULL, 0,
3084                         plaintext_pad_len,
3085                         RTE_CRYPTO_AUTH_OP_VERIFY,
3086                         tdata->plaintext.len,
3087                         0);
3088         if (retval < 0)
3089                 return retval;
3090
3091         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3092                                 ut_params->op);
3093         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3094         ut_params->obuf = ut_params->op->sym->m_src;
3095         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3096                                 + plaintext_pad_len;
3097
3098         /* Validate obuf */
3099         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3100                 return 0;
3101         else
3102                 return -1;
3103
3104         return 0;
3105 }
3106
3107 static int
3108 test_snow3g_hash_generate_test_case_1(void)
3109 {
3110         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3111 }
3112
3113 static int
3114 test_snow3g_hash_generate_test_case_2(void)
3115 {
3116         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3117 }
3118
3119 static int
3120 test_snow3g_hash_generate_test_case_3(void)
3121 {
3122         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3123 }
3124
3125 static int
3126 test_snow3g_hash_generate_test_case_4(void)
3127 {
3128         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3129 }
3130
3131 static int
3132 test_snow3g_hash_generate_test_case_5(void)
3133 {
3134         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3135 }
3136
3137 static int
3138 test_snow3g_hash_generate_test_case_6(void)
3139 {
3140         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3141 }
3142
3143 static int
3144 test_snow3g_hash_verify_test_case_1(void)
3145 {
3146         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3147
3148 }
3149
3150 static int
3151 test_snow3g_hash_verify_test_case_2(void)
3152 {
3153         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3154 }
3155
3156 static int
3157 test_snow3g_hash_verify_test_case_3(void)
3158 {
3159         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3160 }
3161
3162 static int
3163 test_snow3g_hash_verify_test_case_4(void)
3164 {
3165         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3166 }
3167
3168 static int
3169 test_snow3g_hash_verify_test_case_5(void)
3170 {
3171         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3172 }
3173
3174 static int
3175 test_snow3g_hash_verify_test_case_6(void)
3176 {
3177         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3178 }
3179
3180 static int
3181 test_kasumi_hash_generate_test_case_1(void)
3182 {
3183         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3184 }
3185
3186 static int
3187 test_kasumi_hash_generate_test_case_2(void)
3188 {
3189         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3190 }
3191
3192 static int
3193 test_kasumi_hash_generate_test_case_3(void)
3194 {
3195         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3196 }
3197
3198 static int
3199 test_kasumi_hash_generate_test_case_4(void)
3200 {
3201         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3202 }
3203
3204 static int
3205 test_kasumi_hash_generate_test_case_5(void)
3206 {
3207         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3208 }
3209
3210 static int
3211 test_kasumi_hash_generate_test_case_6(void)
3212 {
3213         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3214 }
3215
3216 static int
3217 test_kasumi_hash_verify_test_case_1(void)
3218 {
3219         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3220 }
3221
3222 static int
3223 test_kasumi_hash_verify_test_case_2(void)
3224 {
3225         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3226 }
3227
3228 static int
3229 test_kasumi_hash_verify_test_case_3(void)
3230 {
3231         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3232 }
3233
3234 static int
3235 test_kasumi_hash_verify_test_case_4(void)
3236 {
3237         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3238 }
3239
3240 static int
3241 test_kasumi_hash_verify_test_case_5(void)
3242 {
3243         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3244 }
3245
3246 static int
3247 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3248 {
3249         struct crypto_testsuite_params *ts_params = &testsuite_params;
3250         struct crypto_unittest_params *ut_params = &unittest_params;
3251
3252         int retval;
3253         uint8_t *plaintext, *ciphertext;
3254         unsigned plaintext_pad_len;
3255         unsigned plaintext_len;
3256
3257         /* Create KASUMI session */
3258         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3259                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3260                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3261                                         tdata->key.data, tdata->key.len,
3262                                         tdata->cipher_iv.len);
3263         if (retval < 0)
3264                 return retval;
3265
3266         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3267
3268         /* Clear mbuf payload */
3269         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3270                rte_pktmbuf_tailroom(ut_params->ibuf));
3271
3272         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3273         /* Append data which is padded to a multiple */
3274         /* of the algorithms block size */
3275         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3276         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3277                                 plaintext_pad_len);
3278         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3279
3280         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3281
3282         /* Create KASUMI operation */
3283         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3284                                 tdata->cipher_iv.len,
3285                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3286                                 tdata->validCipherOffsetInBits.len);
3287         if (retval < 0)
3288                 return retval;
3289
3290         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3291                                                 ut_params->op);
3292         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3293
3294         ut_params->obuf = ut_params->op->sym->m_dst;
3295         if (ut_params->obuf)
3296                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3297         else
3298                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3299
3300         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3301
3302         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3303                                 (tdata->validCipherOffsetInBits.len >> 3);
3304         /* Validate obuf */
3305         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3306                 ciphertext,
3307                 reference_ciphertext,
3308                 tdata->validCipherLenInBits.len,
3309                 "KASUMI Ciphertext data not as expected");
3310         return 0;
3311 }
3312
3313 static int
3314 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3315 {
3316         struct crypto_testsuite_params *ts_params = &testsuite_params;
3317         struct crypto_unittest_params *ut_params = &unittest_params;
3318
3319         int retval;
3320
3321         unsigned int plaintext_pad_len;
3322         unsigned int plaintext_len;
3323
3324         uint8_t buffer[10000];
3325         const uint8_t *ciphertext;
3326
3327         struct rte_cryptodev_info dev_info;
3328
3329         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3330
3331         uint64_t feat_flags = dev_info.feature_flags;
3332
3333         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3334                 printf("Device doesn't support in-place scatter-gather. "
3335                                 "Test Skipped.\n");
3336                 return 0;
3337         }
3338
3339         /* Create KASUMI session */
3340         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3341                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3342                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3343                                         tdata->key.data, tdata->key.len,
3344                                         tdata->cipher_iv.len);
3345         if (retval < 0)
3346                 return retval;
3347
3348         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3349
3350
3351         /* Append data which is padded to a multiple */
3352         /* of the algorithms block size */
3353         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3354
3355         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3356                         plaintext_pad_len, 10, 0);
3357
3358         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3359
3360         /* Create KASUMI operation */
3361         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3362                                 tdata->cipher_iv.len,
3363                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3364                                 tdata->validCipherOffsetInBits.len);
3365         if (retval < 0)
3366                 return retval;
3367
3368         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3369                                                 ut_params->op);
3370         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3371
3372         ut_params->obuf = ut_params->op->sym->m_dst;
3373
3374         if (ut_params->obuf)
3375                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3376                                 plaintext_len, buffer);
3377         else
3378                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3379                                 tdata->validCipherOffsetInBits.len >> 3,
3380                                 plaintext_len, buffer);
3381
3382         /* Validate obuf */
3383         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3384
3385         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3386                                 (tdata->validCipherOffsetInBits.len >> 3);
3387         /* Validate obuf */
3388         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3389                 ciphertext,
3390                 reference_ciphertext,
3391                 tdata->validCipherLenInBits.len,
3392                 "KASUMI Ciphertext data not as expected");
3393         return 0;
3394 }
3395
3396 static int
3397 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3398 {
3399         struct crypto_testsuite_params *ts_params = &testsuite_params;
3400         struct crypto_unittest_params *ut_params = &unittest_params;
3401
3402         int retval;
3403         uint8_t *plaintext, *ciphertext;
3404         unsigned plaintext_pad_len;
3405         unsigned plaintext_len;
3406
3407         /* Create KASUMI session */
3408         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3409                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3410                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3411                                         tdata->key.data, tdata->key.len,
3412                                         tdata->cipher_iv.len);
3413         if (retval < 0)
3414                 return retval;
3415
3416         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3417         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3418
3419         /* Clear mbuf payload */
3420         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3421                rte_pktmbuf_tailroom(ut_params->ibuf));
3422
3423         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3424         /* Append data which is padded to a multiple */
3425         /* of the algorithms block size */
3426         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3427         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3428                                 plaintext_pad_len);
3429         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3430         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3431
3432         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3433
3434         /* Create KASUMI operation */
3435         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3436                                 tdata->cipher_iv.len,
3437                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3438                                 tdata->validCipherOffsetInBits.len);
3439         if (retval < 0)
3440                 return retval;
3441
3442         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3443                                                 ut_params->op);
3444         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3445
3446         ut_params->obuf = ut_params->op->sym->m_dst;
3447         if (ut_params->obuf)
3448                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3449         else
3450                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3451
3452         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3453
3454         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3455                                 (tdata->validCipherOffsetInBits.len >> 3);
3456         /* Validate obuf */
3457         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3458                 ciphertext,
3459                 reference_ciphertext,
3460                 tdata->validCipherLenInBits.len,
3461                 "KASUMI Ciphertext data not as expected");
3462         return 0;
3463 }
3464
3465 static int
3466 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3467 {
3468         struct crypto_testsuite_params *ts_params = &testsuite_params;
3469         struct crypto_unittest_params *ut_params = &unittest_params;
3470
3471         int retval;
3472         unsigned int plaintext_pad_len;
3473         unsigned int plaintext_len;
3474
3475         const uint8_t *ciphertext;
3476         uint8_t buffer[2048];
3477
3478         struct rte_cryptodev_info dev_info;
3479
3480         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3481
3482         uint64_t feat_flags = dev_info.feature_flags;
3483         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3484                 printf("Device doesn't support out-of-place scatter-gather "
3485                                 "in both input and output mbufs. "
3486                                 "Test Skipped.\n");
3487                 return 0;
3488         }
3489
3490         /* Create KASUMI session */
3491         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3492                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3493                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3494                                         tdata->key.data, tdata->key.len,
3495                                         tdata->cipher_iv.len);
3496         if (retval < 0)
3497                 return retval;
3498
3499         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3500         /* Append data which is padded to a multiple */
3501         /* of the algorithms block size */
3502         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3503
3504         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3505                         plaintext_pad_len, 10, 0);
3506         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3507                         plaintext_pad_len, 3, 0);
3508
3509         /* Append data which is padded to a multiple */
3510         /* of the algorithms block size */
3511         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3512
3513         /* Create KASUMI operation */
3514         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3515                                 tdata->cipher_iv.len,
3516                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3517                                 tdata->validCipherOffsetInBits.len);
3518         if (retval < 0)
3519                 return retval;
3520
3521         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3522                                                 ut_params->op);
3523         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3524
3525         ut_params->obuf = ut_params->op->sym->m_dst;
3526         if (ut_params->obuf)
3527                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3528                                 plaintext_pad_len, buffer);
3529         else
3530                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3531                                 tdata->validCipherOffsetInBits.len >> 3,
3532                                 plaintext_pad_len, buffer);
3533
3534         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3535                                 (tdata->validCipherOffsetInBits.len >> 3);
3536         /* Validate obuf */
3537         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3538                 ciphertext,
3539                 reference_ciphertext,
3540                 tdata->validCipherLenInBits.len,
3541                 "KASUMI Ciphertext data not as expected");
3542         return 0;
3543 }
3544
3545
3546 static int
3547 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3548 {
3549         struct crypto_testsuite_params *ts_params = &testsuite_params;
3550         struct crypto_unittest_params *ut_params = &unittest_params;
3551
3552         int retval;
3553         uint8_t *ciphertext, *plaintext;
3554         unsigned ciphertext_pad_len;
3555         unsigned ciphertext_len;
3556
3557         /* Create KASUMI session */
3558         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3559                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3560                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3561                                         tdata->key.data, tdata->key.len,
3562                                         tdata->cipher_iv.len);
3563         if (retval < 0)
3564                 return retval;
3565
3566         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3567         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3568
3569         /* Clear mbuf payload */
3570         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3571                rte_pktmbuf_tailroom(ut_params->ibuf));
3572
3573         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3574         /* Append data which is padded to a multiple */
3575         /* of the algorithms block size */
3576         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3577         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3578                                 ciphertext_pad_len);
3579         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3580         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3581
3582         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3583
3584         /* Create KASUMI operation */
3585         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3586                                 tdata->cipher_iv.len,
3587                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3588                                 tdata->validCipherOffsetInBits.len);
3589         if (retval < 0)
3590                 return retval;
3591
3592         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3593                                                 ut_params->op);
3594         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3595
3596         ut_params->obuf = ut_params->op->sym->m_dst;
3597         if (ut_params->obuf)
3598                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3599         else
3600                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3601
3602         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3603
3604         const uint8_t *reference_plaintext = tdata->plaintext.data +
3605                                 (tdata->validCipherOffsetInBits.len >> 3);
3606         /* Validate obuf */
3607         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3608                 plaintext,
3609                 reference_plaintext,
3610                 tdata->validCipherLenInBits.len,
3611                 "KASUMI Plaintext data not as expected");
3612         return 0;
3613 }
3614
3615 static int
3616 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3617 {
3618         struct crypto_testsuite_params *ts_params = &testsuite_params;
3619         struct crypto_unittest_params *ut_params = &unittest_params;
3620
3621         int retval;
3622         uint8_t *ciphertext, *plaintext;
3623         unsigned ciphertext_pad_len;
3624         unsigned ciphertext_len;
3625
3626         /* Create KASUMI session */
3627         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3628                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3629                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3630                                         tdata->key.data, tdata->key.len,
3631                                         tdata->cipher_iv.len);
3632         if (retval < 0)
3633                 return retval;
3634
3635         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3636
3637         /* Clear mbuf payload */
3638         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3639                rte_pktmbuf_tailroom(ut_params->ibuf));
3640
3641         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3642         /* Append data which is padded to a multiple */
3643         /* of the algorithms block size */
3644         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3645         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3646                                 ciphertext_pad_len);
3647         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3648
3649         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3650
3651         /* Create KASUMI operation */
3652         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3653                                         tdata->cipher_iv.len,
3654                                         tdata->ciphertext.len,
3655                                         tdata->validCipherOffsetInBits.len);
3656         if (retval < 0)
3657                 return retval;
3658
3659         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3660                                                 ut_params->op);
3661         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3662
3663         ut_params->obuf = ut_params->op->sym->m_dst;
3664         if (ut_params->obuf)
3665                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3666         else
3667                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3668
3669         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3670
3671         const uint8_t *reference_plaintext = tdata->plaintext.data +
3672                                 (tdata->validCipherOffsetInBits.len >> 3);
3673         /* Validate obuf */
3674         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3675                 plaintext,
3676                 reference_plaintext,
3677                 tdata->validCipherLenInBits.len,
3678                 "KASUMI Plaintext data not as expected");
3679         return 0;
3680 }
3681
3682 static int
3683 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3684 {
3685         struct crypto_testsuite_params *ts_params = &testsuite_params;
3686         struct crypto_unittest_params *ut_params = &unittest_params;
3687
3688         int retval;
3689         uint8_t *plaintext, *ciphertext;
3690         unsigned plaintext_pad_len;
3691         unsigned plaintext_len;
3692
3693         /* Create SNOW 3G session */
3694         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3695                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3696                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3697                                         tdata->key.data, tdata->key.len,
3698                                         tdata->cipher_iv.len);
3699         if (retval < 0)
3700                 return retval;
3701
3702         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3703
3704         /* Clear mbuf payload */
3705         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3706                rte_pktmbuf_tailroom(ut_params->ibuf));
3707
3708         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3709         /* Append data which is padded to a multiple of */
3710         /* the algorithms block size */
3711         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3712         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3713                                 plaintext_pad_len);
3714         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3715
3716         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3717
3718         /* Create SNOW 3G operation */
3719         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3720                                         tdata->cipher_iv.len,
3721                                         tdata->validCipherLenInBits.len,
3722                                         0);
3723         if (retval < 0)
3724                 return retval;
3725
3726         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3727                                                 ut_params->op);
3728         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3729
3730         ut_params->obuf = ut_params->op->sym->m_dst;
3731         if (ut_params->obuf)
3732                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3733         else
3734                 ciphertext = plaintext;
3735
3736         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3737
3738         /* Validate obuf */
3739         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3740                 ciphertext,
3741                 tdata->ciphertext.data,
3742                 tdata->validDataLenInBits.len,
3743                 "SNOW 3G Ciphertext data not as expected");
3744         return 0;
3745 }
3746
3747
3748 static int
3749 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
3750 {
3751         struct crypto_testsuite_params *ts_params = &testsuite_params;
3752         struct crypto_unittest_params *ut_params = &unittest_params;
3753         uint8_t *plaintext, *ciphertext;
3754
3755         int retval;
3756         unsigned plaintext_pad_len;
3757         unsigned plaintext_len;
3758
3759         /* Create SNOW 3G session */
3760         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3761                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3762                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3763                                         tdata->key.data, tdata->key.len,
3764                                         tdata->cipher_iv.len);
3765         if (retval < 0)
3766                 return retval;
3767
3768         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3769         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3770
3771         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3772                         "Failed to allocate input buffer in mempool");
3773         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3774                         "Failed to allocate output buffer in mempool");
3775
3776         /* Clear mbuf payload */
3777         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3778                rte_pktmbuf_tailroom(ut_params->ibuf));
3779
3780         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3781         /* Append data which is padded to a multiple of */
3782         /* the algorithms block size */
3783         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3784         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3785                                 plaintext_pad_len);
3786         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3787         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3788
3789         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3790
3791         /* Create SNOW 3G operation */
3792         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3793                                         tdata->cipher_iv.len,
3794                                         tdata->validCipherLenInBits.len,
3795                                         0);
3796         if (retval < 0)
3797                 return retval;
3798
3799         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3800                                                 ut_params->op);
3801         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3802
3803         ut_params->obuf = ut_params->op->sym->m_dst;
3804         if (ut_params->obuf)
3805                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3806         else
3807                 ciphertext = plaintext;
3808
3809         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3810
3811         /* Validate obuf */
3812         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3813                 ciphertext,
3814                 tdata->ciphertext.data,
3815                 tdata->validDataLenInBits.len,
3816                 "SNOW 3G Ciphertext data not as expected");
3817         return 0;
3818 }
3819
3820 static int
3821 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
3822 {
3823         struct crypto_testsuite_params *ts_params = &testsuite_params;
3824         struct crypto_unittest_params *ut_params = &unittest_params;
3825
3826         int retval;
3827         unsigned int plaintext_pad_len;
3828         unsigned int plaintext_len;
3829         uint8_t buffer[10000];
3830         const uint8_t *ciphertext;
3831
3832         struct rte_cryptodev_info dev_info;
3833
3834         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3835
3836         uint64_t feat_flags = dev_info.feature_flags;
3837
3838         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3839                 printf("Device doesn't support out-of-place scatter-gather "
3840                                 "in both input and output mbufs. "
3841                                 "Test Skipped.\n");
3842                 return 0;
3843         }
3844
3845         /* Create SNOW 3G session */
3846         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3847                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3848                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3849                                         tdata->key.data, tdata->key.len,
3850                                         tdata->cipher_iv.len);
3851         if (retval < 0)
3852                 return retval;
3853
3854         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3855         /* Append data which is padded to a multiple of */
3856         /* the algorithms block size */
3857         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3858
3859         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3860                         plaintext_pad_len, 10, 0);
3861         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3862                         plaintext_pad_len, 3, 0);
3863
3864         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3865                         "Failed to allocate input buffer in mempool");
3866         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3867                         "Failed to allocate output buffer in mempool");
3868
3869         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3870
3871         /* Create SNOW 3G operation */
3872         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3873                                         tdata->cipher_iv.len,
3874                                         tdata->validCipherLenInBits.len,
3875                                         0);
3876         if (retval < 0)
3877                 return retval;
3878
3879         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3880                                                 ut_params->op);
3881         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3882
3883         ut_params->obuf = ut_params->op->sym->m_dst;
3884         if (ut_params->obuf)
3885                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3886                                 plaintext_len, buffer);
3887         else
3888                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
3889                                 plaintext_len, buffer);
3890
3891         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3892
3893         /* Validate obuf */
3894         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3895                 ciphertext,
3896                 tdata->ciphertext.data,
3897                 tdata->validDataLenInBits.len,
3898                 "SNOW 3G Ciphertext data not as expected");
3899
3900         return 0;
3901 }
3902
3903 /* Shift right a buffer by "offset" bits, "offset" < 8 */
3904 static void
3905 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
3906 {
3907         uint8_t curr_byte, prev_byte;
3908         uint32_t length_in_bytes = ceil_byte_length(length + offset);
3909         uint8_t lower_byte_mask = (1 << offset) - 1;
3910         unsigned i;
3911
3912         prev_byte = buffer[0];
3913         buffer[0] >>= offset;
3914
3915         for (i = 1; i < length_in_bytes; i++) {
3916                 curr_byte = buffer[i];
3917                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
3918                                 (curr_byte >> offset);
3919                 prev_byte = curr_byte;
3920         }
3921 }
3922
3923 static int
3924 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
3925 {
3926         struct crypto_testsuite_params *ts_params = &testsuite_params;
3927         struct crypto_unittest_params *ut_params = &unittest_params;
3928         uint8_t *plaintext, *ciphertext;
3929         int retval;
3930         uint32_t plaintext_len;
3931         uint32_t plaintext_pad_len;
3932         uint8_t extra_offset = 4;
3933         uint8_t *expected_ciphertext_shifted;
3934
3935         /* Create SNOW 3G session */
3936         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3937                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3938                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3939                                         tdata->key.data, tdata->key.len,
3940                                         tdata->cipher_iv.len);
3941         if (retval < 0)
3942                 return retval;
3943
3944         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3945         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3946
3947         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3948                         "Failed to allocate input buffer in mempool");
3949         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3950                         "Failed to allocate output buffer in mempool");
3951
3952         /* Clear mbuf payload */
3953         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3954                rte_pktmbuf_tailroom(ut_params->ibuf));
3955
3956         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
3957         /*
3958          * Append data which is padded to a
3959          * multiple of the algorithms block size
3960          */
3961         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3962
3963         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
3964                                                 plaintext_pad_len);
3965
3966         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3967
3968         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
3969         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
3970
3971 #ifdef RTE_APP_TEST_DEBUG
3972         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3973 #endif
3974         /* Create SNOW 3G operation */
3975         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3976                                         tdata->cipher_iv.len,
3977                                         tdata->validCipherLenInBits.len,
3978                                         extra_offset);
3979         if (retval < 0)
3980                 return retval;
3981
3982         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3983                                                 ut_params->op);
3984         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3985
3986         ut_params->obuf = ut_params->op->sym->m_dst;
3987         if (ut_params->obuf)
3988                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3989         else
3990                 ciphertext = plaintext;
3991
3992 #ifdef RTE_APP_TEST_DEBUG
3993         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3994 #endif
3995
3996         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
3997
3998         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
3999                         "failed to reserve memory for ciphertext shifted\n");
4000
4001         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4002                         ceil_byte_length(tdata->ciphertext.len));
4003         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4004                         extra_offset);
4005         /* Validate obuf */
4006         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4007                 ciphertext,
4008                 expected_ciphertext_shifted,
4009                 tdata->validDataLenInBits.len,
4010                 extra_offset,
4011                 "SNOW 3G Ciphertext data not as expected");
4012         return 0;
4013 }
4014
4015 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4016 {
4017         struct crypto_testsuite_params *ts_params = &testsuite_params;
4018         struct crypto_unittest_params *ut_params = &unittest_params;
4019
4020         int retval;
4021
4022         uint8_t *plaintext, *ciphertext;
4023         unsigned ciphertext_pad_len;
4024         unsigned ciphertext_len;
4025
4026         /* Create SNOW 3G session */
4027         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4028                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4029                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4030                                         tdata->key.data, tdata->key.len,
4031                                         tdata->cipher_iv.len);
4032         if (retval < 0)
4033                 return retval;
4034
4035         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4036
4037         /* Clear mbuf payload */
4038         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4039                rte_pktmbuf_tailroom(ut_params->ibuf));
4040
4041         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4042         /* Append data which is padded to a multiple of */
4043         /* the algorithms block size */
4044         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4045         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4046                                 ciphertext_pad_len);
4047         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4048
4049         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4050
4051         /* Create SNOW 3G operation */
4052         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4053                                         tdata->cipher_iv.len,
4054                                         tdata->validCipherLenInBits.len,
4055                                         0);
4056         if (retval < 0)
4057                 return retval;
4058
4059         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4060                                                 ut_params->op);
4061         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4062         ut_params->obuf = ut_params->op->sym->m_dst;
4063         if (ut_params->obuf)
4064                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4065         else
4066                 plaintext = ciphertext;
4067
4068         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4069
4070         /* Validate obuf */
4071         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4072                                 tdata->plaintext.data,
4073                                 tdata->validDataLenInBits.len,
4074                                 "SNOW 3G Plaintext data not as expected");
4075         return 0;
4076 }
4077
4078 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4079 {
4080         struct crypto_testsuite_params *ts_params = &testsuite_params;
4081         struct crypto_unittest_params *ut_params = &unittest_params;
4082
4083         int retval;
4084
4085         uint8_t *plaintext, *ciphertext;
4086         unsigned ciphertext_pad_len;
4087         unsigned ciphertext_len;
4088
4089         /* Create SNOW 3G session */
4090         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4091                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4092                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4093                                         tdata->key.data, tdata->key.len,
4094                                         tdata->cipher_iv.len);
4095         if (retval < 0)
4096                 return retval;
4097
4098         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4099         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4100
4101         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4102                         "Failed to allocate input buffer");
4103         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4104                         "Failed to allocate output buffer");
4105
4106         /* Clear mbuf payload */
4107         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4108                rte_pktmbuf_tailroom(ut_params->ibuf));
4109
4110         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4111                        rte_pktmbuf_tailroom(ut_params->obuf));
4112
4113         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4114         /* Append data which is padded to a multiple of */
4115         /* the algorithms block size */
4116         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4117         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4118                                 ciphertext_pad_len);
4119         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4120         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4121
4122         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4123
4124         /* Create SNOW 3G operation */
4125         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4126                                         tdata->cipher_iv.len,
4127                                         tdata->validCipherLenInBits.len,
4128                                         0);
4129         if (retval < 0)
4130                 return retval;
4131
4132         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4133                                                 ut_params->op);
4134         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4135         ut_params->obuf = ut_params->op->sym->m_dst;
4136         if (ut_params->obuf)
4137                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4138         else
4139                 plaintext = ciphertext;
4140
4141         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4142
4143         /* Validate obuf */
4144         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4145                                 tdata->plaintext.data,
4146                                 tdata->validDataLenInBits.len,
4147                                 "SNOW 3G Plaintext data not as expected");
4148         return 0;
4149 }
4150
4151 static int
4152 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4153 {
4154         struct crypto_testsuite_params *ts_params = &testsuite_params;
4155         struct crypto_unittest_params *ut_params = &unittest_params;
4156
4157         int retval;
4158
4159         uint8_t *plaintext, *ciphertext;
4160         unsigned int plaintext_pad_len;
4161         unsigned int plaintext_len;
4162
4163         struct rte_cryptodev_sym_capability_idx cap_idx;
4164
4165         /* Check if device supports ZUC EEA3 */
4166         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4167         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4168
4169         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4170                         &cap_idx) == NULL)
4171                 return -ENOTSUP;
4172
4173         /* Check if device supports ZUC EIA3 */
4174         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4175         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4176
4177         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4178                         &cap_idx) == NULL)
4179                 return -ENOTSUP;
4180
4181         /* Create ZUC session */
4182         retval = create_zuc_cipher_auth_encrypt_generate_session(
4183                         ts_params->valid_devs[0],
4184                         tdata);
4185         if (retval < 0)
4186                 return retval;
4187         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4188
4189         /* clear mbuf payload */
4190         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4191                         rte_pktmbuf_tailroom(ut_params->ibuf));
4192
4193         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4194         /* Append data which is padded to a multiple of */
4195         /* the algorithms block size */
4196         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4197         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4198                                 plaintext_pad_len);
4199         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4200
4201         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4202
4203         /* Create ZUC operation */
4204         retval = create_zuc_cipher_hash_generate_operation(tdata);
4205         if (retval < 0)
4206                 return retval;
4207
4208         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4209                         ut_params->op);
4210         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4211         ut_params->obuf = ut_params->op->sym->m_src;
4212         if (ut_params->obuf)
4213                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4214         else
4215                 ciphertext = plaintext;
4216
4217         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4218         /* Validate obuf */
4219         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4220                         ciphertext,
4221                         tdata->ciphertext.data,
4222                         tdata->validDataLenInBits.len,
4223                         "ZUC Ciphertext data not as expected");
4224
4225         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4226             + plaintext_pad_len;
4227
4228         /* Validate obuf */
4229         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4230                         ut_params->digest,
4231                         tdata->digest.data,
4232                         4,
4233                         "ZUC Generated auth tag not as expected");
4234         return 0;
4235 }
4236
4237 static int
4238 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4239 {
4240         struct crypto_testsuite_params *ts_params = &testsuite_params;
4241         struct crypto_unittest_params *ut_params = &unittest_params;
4242
4243         int retval;
4244
4245         uint8_t *plaintext, *ciphertext;
4246         unsigned plaintext_pad_len;
4247         unsigned plaintext_len;
4248
4249         /* Create SNOW 3G session */
4250         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4251                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4252                         RTE_CRYPTO_AUTH_OP_GENERATE,
4253                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4254                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4255                         tdata->key.data, tdata->key.len,
4256                         tdata->auth_iv.len, tdata->digest.len,
4257                         tdata->cipher_iv.len);
4258         if (retval < 0)
4259                 return retval;
4260         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4261
4262         /* clear mbuf payload */
4263         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4264                         rte_pktmbuf_tailroom(ut_params->ibuf));
4265
4266         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4267         /* Append data which is padded to a multiple of */
4268         /* the algorithms block size */
4269         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4270         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4271                                 plaintext_pad_len);
4272         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4273
4274         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4275
4276         /* Create SNOW 3G operation */
4277         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4278                         tdata->digest.len, tdata->auth_iv.data,
4279                         tdata->auth_iv.len,
4280                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4281                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4282                         tdata->validCipherLenInBits.len,
4283                         0,
4284                         tdata->validAuthLenInBits.len,
4285                         0
4286                         );
4287         if (retval < 0)
4288                 return retval;
4289
4290         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4291                         ut_params->op);
4292         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4293         ut_params->obuf = ut_params->op->sym->m_src;
4294         if (ut_params->obuf)
4295                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4296         else
4297                 ciphertext = plaintext;
4298
4299         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4300         /* Validate obuf */
4301         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4302                         ciphertext,
4303                         tdata->ciphertext.data,
4304                         tdata->validDataLenInBits.len,
4305                         "SNOW 3G Ciphertext data not as expected");
4306
4307         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4308             + plaintext_pad_len;
4309
4310         /* Validate obuf */
4311         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4312                         ut_params->digest,
4313                         tdata->digest.data,
4314                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4315                         "SNOW 3G Generated auth tag not as expected");
4316         return 0;
4317 }
4318 static int
4319 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
4320 {
4321         struct crypto_testsuite_params *ts_params = &testsuite_params;
4322         struct crypto_unittest_params *ut_params = &unittest_params;
4323
4324         int retval;
4325
4326         uint8_t *plaintext, *ciphertext;
4327         unsigned plaintext_pad_len;
4328         unsigned plaintext_len;
4329
4330         /* Create SNOW 3G session */
4331         retval = create_wireless_algo_auth_cipher_session(ts_params->valid_devs[0],
4332                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4333                         RTE_CRYPTO_AUTH_OP_GENERATE,
4334                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4335                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4336                         tdata->key.data, tdata->key.len,
4337                         tdata->auth_iv.len, tdata->digest.len,
4338                         tdata->cipher_iv.len);
4339         if (retval < 0)
4340                 return retval;
4341
4342         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4343
4344         /* clear mbuf payload */
4345         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4346                         rte_pktmbuf_tailroom(ut_params->ibuf));
4347
4348         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4349         /* Append data which is padded to a multiple of */
4350         /* the algorithms block size */
4351         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4352         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4353                                 plaintext_pad_len);
4354         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4355
4356         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4357
4358         /* Create SNOW 3G operation */
4359         retval = create_wireless_algo_auth_cipher_operation(
4360                 tdata->digest.len,
4361                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4362                 tdata->auth_iv.data, tdata->auth_iv.len,
4363                 plaintext_pad_len,
4364                 tdata->validCipherLenInBits.len,
4365                 0,
4366                 tdata->validAuthLenInBits.len,
4367                 0);
4368
4369         if (retval < 0)
4370                 return retval;
4371
4372         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4373                         ut_params->op);
4374         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4375         ut_params->obuf = ut_params->op->sym->m_src;
4376         if (ut_params->obuf)
4377                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4378         else
4379                 ciphertext = plaintext;
4380
4381         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4382                         + plaintext_pad_len;
4383         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4384
4385         /* Validate obuf */
4386         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4387                 ciphertext,
4388                 tdata->ciphertext.data,
4389                 tdata->validDataLenInBits.len,
4390                 "SNOW 3G Ciphertext data not as expected");
4391
4392         /* Validate obuf */
4393         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4394                 ut_params->digest,
4395                 tdata->digest.data,
4396                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4397                 "SNOW 3G Generated auth tag not as expected");
4398         return 0;
4399 }
4400
4401 static int
4402 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
4403 {
4404         struct crypto_testsuite_params *ts_params = &testsuite_params;
4405         struct crypto_unittest_params *ut_params = &unittest_params;
4406
4407         int retval;
4408
4409         uint8_t *plaintext, *ciphertext;
4410         unsigned plaintext_pad_len;
4411         unsigned plaintext_len;
4412
4413         /* Create KASUMI session */
4414         retval = create_wireless_algo_auth_cipher_session(
4415                         ts_params->valid_devs[0],
4416                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4417                         RTE_CRYPTO_AUTH_OP_GENERATE,
4418                         RTE_CRYPTO_AUTH_KASUMI_F9,
4419                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4420                         tdata->key.data, tdata->key.len,
4421                         0, tdata->digest.len,
4422                         tdata->cipher_iv.len);
4423         if (retval < 0)
4424                 return retval;
4425         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4426
4427         /* clear mbuf payload */
4428         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4429                         rte_pktmbuf_tailroom(ut_params->ibuf));
4430
4431         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4432         /* Append data which is padded to a multiple of */
4433         /* the algorithms block size */
4434         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4435         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4436                                 plaintext_pad_len);
4437         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4438
4439         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4440
4441         /* Create KASUMI operation */
4442         retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len,
4443                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4444                                 NULL, 0,
4445                                 plaintext_pad_len,
4446                                 tdata->validCipherLenInBits.len,
4447                                 tdata->validCipherOffsetInBits.len,
4448                                 tdata->validAuthLenInBits.len,
4449                                 0
4450                                 );
4451
4452         if (retval < 0)
4453                 return retval;
4454
4455         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4456                         ut_params->op);
4457         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4458         if (ut_params->op->sym->m_dst)
4459                 ut_params->obuf = ut_params->op->sym->m_dst;
4460         else
4461                 ut_params->obuf = ut_params->op->sym->m_src;
4462
4463         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
4464                                 tdata->validCipherOffsetInBits.len >> 3);
4465
4466         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
4467                                 (tdata->validCipherOffsetInBits.len >> 3);
4468         /* Validate obuf */
4469         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4470                         ciphertext,
4471                         reference_ciphertext,
4472                         tdata->validCipherLenInBits.len,
4473                         "KASUMI Ciphertext data not as expected");
4474         ut_params->digest = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *)
4475             + plaintext_pad_len;
4476
4477         /* Validate obuf */
4478         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4479                         ut_params->digest,
4480                         tdata->digest.data,
4481                         DIGEST_BYTE_LENGTH_KASUMI_F9,
4482                         "KASUMI Generated auth tag not as expected");
4483         return 0;
4484 }
4485
4486 static int
4487 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
4488 {
4489         struct crypto_testsuite_params *ts_params = &testsuite_params;
4490         struct crypto_unittest_params *ut_params = &unittest_params;
4491
4492         int retval;
4493
4494         uint8_t *plaintext, *ciphertext;
4495         unsigned plaintext_pad_len;
4496         unsigned plaintext_len;
4497
4498         /* Create KASUMI session */
4499         retval = create_wireless_algo_cipher_auth_session(
4500                         ts_params->valid_devs[0],
4501                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4502                         RTE_CRYPTO_AUTH_OP_GENERATE,
4503                         RTE_CRYPTO_AUTH_KASUMI_F9,
4504                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4505                         tdata->key.data, tdata->key.len,
4506                         0, tdata->digest.len,
4507                         tdata->cipher_iv.len);
4508         if (retval < 0)
4509                 return retval;
4510
4511         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4512
4513         /* clear mbuf payload */
4514         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4515                         rte_pktmbuf_tailroom(ut_params->ibuf));
4516
4517         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4518         /* Append data which is padded to a multiple of */
4519         /* the algorithms block size */
4520         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4521         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4522                                 plaintext_pad_len);
4523         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4524
4525         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4526
4527         /* Create KASUMI operation */
4528         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4529                                 tdata->digest.len, NULL, 0,
4530                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4531                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4532                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4533                                 tdata->validCipherOffsetInBits.len,
4534                                 tdata->validAuthLenInBits.len,
4535                                 0
4536                                 );
4537         if (retval < 0)
4538                 return retval;
4539
4540         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4541                         ut_params->op);
4542         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4543
4544         if (ut_params->op->sym->m_dst)
4545                 ut_params->obuf = ut_params->op->sym->m_dst;
4546         else
4547                 ut_params->obuf = ut_params->op->sym->m_src;
4548
4549         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
4550                                 tdata->validCipherOffsetInBits.len >> 3);
4551
4552         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4553                         + plaintext_pad_len;
4554
4555         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
4556                                 (tdata->validCipherOffsetInBits.len >> 3);
4557         /* Validate obuf */
4558         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4559                 ciphertext,
4560                 reference_ciphertext,
4561                 tdata->validCipherLenInBits.len,
4562                 "KASUMI Ciphertext data not as expected");
4563
4564         /* Validate obuf */
4565         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4566                 ut_params->digest,
4567                 tdata->digest.data,
4568                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4569                 "KASUMI Generated auth tag not as expected");
4570         return 0;
4571 }
4572
4573 static int
4574 test_zuc_encryption(const struct wireless_test_data *tdata)
4575 {
4576         struct crypto_testsuite_params *ts_params = &testsuite_params;
4577         struct crypto_unittest_params *ut_params = &unittest_params;
4578
4579         int retval;
4580         uint8_t *plaintext, *ciphertext;
4581         unsigned plaintext_pad_len;
4582         unsigned plaintext_len;
4583
4584         struct rte_cryptodev_sym_capability_idx cap_idx;
4585
4586         /* Check if device supports ZUC EEA3 */
4587         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4588         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4589
4590         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4591                         &cap_idx) == NULL)
4592                 return -ENOTSUP;
4593
4594         /* Create ZUC session */
4595         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4596                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4597                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
4598                                         tdata->key.data, tdata->key.len,
4599                                         tdata->cipher_iv.len);
4600         if (retval < 0)
4601                 return retval;
4602
4603         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4604
4605         /* Clear mbuf payload */
4606         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4607                rte_pktmbuf_tailroom(ut_params->ibuf));
4608
4609         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4610         /* Append data which is padded to a multiple */
4611         /* of the algorithms block size */
4612         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4613         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4614                                 plaintext_pad_len);
4615         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4616
4617         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4618
4619         /* Create ZUC operation */
4620         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4621                                         tdata->cipher_iv.len,
4622                                         tdata->plaintext.len,
4623                                         0);
4624         if (retval < 0)
4625                 return retval;
4626
4627         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4628                                                 ut_params->op);
4629         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4630
4631         ut_params->obuf = ut_params->op->sym->m_dst;
4632         if (ut_params->obuf)
4633                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4634         else
4635                 ciphertext = plaintext;
4636
4637         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4638
4639         /* Validate obuf */
4640         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4641                 ciphertext,
4642                 tdata->ciphertext.data,
4643                 tdata->validCipherLenInBits.len,
4644                 "ZUC Ciphertext data not as expected");
4645         return 0;
4646 }
4647
4648 static int
4649 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
4650 {
4651         struct crypto_testsuite_params *ts_params = &testsuite_params;
4652         struct crypto_unittest_params *ut_params = &unittest_params;
4653
4654         int retval;
4655
4656         unsigned int plaintext_pad_len;
4657         unsigned int plaintext_len;
4658         const uint8_t *ciphertext;
4659         uint8_t ciphertext_buffer[2048];
4660         struct rte_cryptodev_info dev_info;
4661
4662         struct rte_cryptodev_sym_capability_idx cap_idx;
4663
4664         /* Check if device supports ZUC EEA3 */
4665         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4666         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4667
4668         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4669                         &cap_idx) == NULL)
4670                 return -ENOTSUP;
4671
4672         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4673
4674         uint64_t feat_flags = dev_info.feature_flags;
4675
4676         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4677                 printf("Device doesn't support in-place scatter-gather. "
4678                                 "Test Skipped.\n");
4679                 return 0;
4680         }
4681
4682         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4683
4684         /* Append data which is padded to a multiple */
4685         /* of the algorithms block size */
4686         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4687
4688         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4689                         plaintext_pad_len, 10, 0);
4690
4691         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4692                         tdata->plaintext.data);
4693
4694         /* Create ZUC session */
4695         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4696                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4697                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
4698                         tdata->key.data, tdata->key.len,
4699                         tdata->cipher_iv.len);
4700         if (retval < 0)
4701                 return retval;
4702
4703         /* Clear mbuf payload */
4704
4705         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4706
4707         /* Create ZUC operation */
4708         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4709                         tdata->cipher_iv.len, tdata->plaintext.len,
4710                         0);
4711         if (retval < 0)
4712                 return retval;
4713
4714         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4715                                                 ut_params->op);
4716         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4717
4718         ut_params->obuf = ut_params->op->sym->m_dst;
4719         if (ut_params->obuf)
4720                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
4721                         0, plaintext_len, ciphertext_buffer);
4722         else
4723                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
4724                         0, plaintext_len, ciphertext_buffer);
4725
4726         /* Validate obuf */
4727         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4728
4729         /* Validate obuf */
4730         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4731                 ciphertext,
4732                 tdata->ciphertext.data,
4733                 tdata->validCipherLenInBits.len,
4734                 "ZUC Ciphertext data not as expected");
4735
4736         return 0;
4737 }
4738
4739 static int
4740 test_zuc_authentication(const struct wireless_test_data *tdata)
4741 {
4742         struct crypto_testsuite_params *ts_params = &testsuite_params;
4743         struct crypto_unittest_params *ut_params = &unittest_params;
4744
4745         int retval;
4746         unsigned plaintext_pad_len;
4747         unsigned plaintext_len;
4748         uint8_t *plaintext;
4749
4750         struct rte_cryptodev_sym_capability_idx cap_idx;
4751
4752         /* Check if device supports ZUC EIA3 */
4753         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4754         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4755
4756         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4757                         &cap_idx) == NULL)
4758                 return -ENOTSUP;
4759
4760         /* Create ZUC session */
4761         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
4762                         tdata->key.data, tdata->key.len,
4763                         tdata->auth_iv.len, tdata->digest.len,
4764                         RTE_CRYPTO_AUTH_OP_GENERATE,
4765                         RTE_CRYPTO_AUTH_ZUC_EIA3);
4766         if (retval < 0)
4767                 return retval;
4768
4769         /* alloc mbuf and set payload */
4770         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4771
4772         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4773         rte_pktmbuf_tailroom(ut_params->ibuf));
4774
4775         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4776         /* Append data which is padded to a multiple of */
4777         /* the algorithms block size */
4778         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4779         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4780                                 plaintext_pad_len);
4781         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4782
4783         /* Create ZUC operation */
4784         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
4785                         tdata->auth_iv.data, tdata->auth_iv.len,
4786                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4787                         tdata->validAuthLenInBits.len,
4788                         0);
4789         if (retval < 0)
4790                 return retval;
4791
4792         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4793                                 ut_params->op);
4794         ut_params->obuf = ut_params->op->sym->m_src;
4795         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4796         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4797                         + plaintext_pad_len;
4798
4799         /* Validate obuf */
4800         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4801         ut_params->digest,
4802         tdata->digest.data,
4803         DIGEST_BYTE_LENGTH_KASUMI_F9,
4804         "ZUC Generated auth tag not as expected");
4805
4806         return 0;
4807 }
4808
4809 static int
4810 test_kasumi_encryption_test_case_1(void)
4811 {
4812         return test_kasumi_encryption(&kasumi_test_case_1);
4813 }
4814
4815 static int
4816 test_kasumi_encryption_test_case_1_sgl(void)
4817 {
4818         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
4819 }
4820
4821 static int
4822 test_kasumi_encryption_test_case_1_oop(void)
4823 {
4824         return test_kasumi_encryption_oop(&kasumi_test_case_1);
4825 }
4826
4827 static int
4828 test_kasumi_encryption_test_case_1_oop_sgl(void)
4829 {
4830         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
4831 }
4832
4833 static int
4834 test_kasumi_encryption_test_case_2(void)
4835 {
4836         return test_kasumi_encryption(&kasumi_test_case_2);
4837 }
4838
4839 static int
4840 test_kasumi_encryption_test_case_3(void)
4841 {
4842         return test_kasumi_encryption(&kasumi_test_case_3);
4843 }
4844
4845 static int
4846 test_kasumi_encryption_test_case_4(void)
4847 {
4848         return test_kasumi_encryption(&kasumi_test_case_4);
4849 }
4850
4851 static int
4852 test_kasumi_encryption_test_case_5(void)
4853 {
4854         return test_kasumi_encryption(&kasumi_test_case_5);
4855 }
4856
4857 static int
4858 test_kasumi_decryption_test_case_1(void)
4859 {
4860         return test_kasumi_decryption(&kasumi_test_case_1);
4861 }
4862
4863 static int
4864 test_kasumi_decryption_test_case_1_oop(void)
4865 {
4866         return test_kasumi_decryption_oop(&kasumi_test_case_1);
4867 }
4868
4869 static int
4870 test_kasumi_decryption_test_case_2(void)
4871 {
4872         return test_kasumi_decryption(&kasumi_test_case_2);
4873 }
4874
4875 static int
4876 test_kasumi_decryption_test_case_3(void)
4877 {
4878         return test_kasumi_decryption(&kasumi_test_case_3);
4879 }
4880
4881 static int
4882 test_kasumi_decryption_test_case_4(void)
4883 {
4884         return test_kasumi_decryption(&kasumi_test_case_4);
4885 }
4886
4887 static int
4888 test_kasumi_decryption_test_case_5(void)
4889 {
4890         return test_kasumi_decryption(&kasumi_test_case_5);
4891 }
4892 static int
4893 test_snow3g_encryption_test_case_1(void)
4894 {
4895         return test_snow3g_encryption(&snow3g_test_case_1);
4896 }
4897
4898 static int
4899 test_snow3g_encryption_test_case_1_oop(void)
4900 {
4901         return test_snow3g_encryption_oop(&snow3g_test_case_1);
4902 }
4903
4904 static int
4905 test_snow3g_encryption_test_case_1_oop_sgl(void)
4906 {
4907         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
4908 }
4909
4910
4911 static int
4912 test_snow3g_encryption_test_case_1_offset_oop(void)
4913 {
4914         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
4915 }
4916
4917 static int
4918 test_snow3g_encryption_test_case_2(void)
4919 {
4920         return test_snow3g_encryption(&snow3g_test_case_2);
4921 }
4922
4923 static int
4924 test_snow3g_encryption_test_case_3(void)
4925 {
4926         return test_snow3g_encryption(&snow3g_test_case_3);
4927 }
4928
4929 static int
4930 test_snow3g_encryption_test_case_4(void)
4931 {
4932         return test_snow3g_encryption(&snow3g_test_case_4);
4933 }
4934
4935 static int
4936 test_snow3g_encryption_test_case_5(void)
4937 {
4938         return test_snow3g_encryption(&snow3g_test_case_5);
4939 }
4940
4941 static int
4942 test_snow3g_decryption_test_case_1(void)
4943 {
4944         return test_snow3g_decryption(&snow3g_test_case_1);
4945 }
4946
4947 static int
4948 test_snow3g_decryption_test_case_1_oop(void)
4949 {
4950         return test_snow3g_decryption_oop(&snow3g_test_case_1);
4951 }
4952
4953 static int
4954 test_snow3g_decryption_test_case_2(void)
4955 {
4956         return test_snow3g_decryption(&snow3g_test_case_2);
4957 }
4958
4959 static int
4960 test_snow3g_decryption_test_case_3(void)
4961 {
4962         return test_snow3g_decryption(&snow3g_test_case_3);
4963 }
4964
4965 static int
4966 test_snow3g_decryption_test_case_4(void)
4967 {
4968         return test_snow3g_decryption(&snow3g_test_case_4);
4969 }
4970
4971 static int
4972 test_snow3g_decryption_test_case_5(void)
4973 {
4974         return test_snow3g_decryption(&snow3g_test_case_5);
4975 }
4976 static int
4977 test_snow3g_cipher_auth_test_case_1(void)
4978 {
4979         return test_snow3g_cipher_auth(&snow3g_test_case_3);
4980 }
4981
4982 static int
4983 test_snow3g_auth_cipher_test_case_1(void)
4984 {
4985         return test_snow3g_auth_cipher(&snow3g_test_case_6);
4986 }
4987
4988 static int
4989 test_kasumi_auth_cipher_test_case_1(void)
4990 {
4991         return test_kasumi_auth_cipher(&kasumi_test_case_3);
4992 }
4993
4994 static int
4995 test_kasumi_cipher_auth_test_case_1(void)
4996 {
4997         return test_kasumi_cipher_auth(&kasumi_test_case_6);
4998 }
4999
5000 static int
5001 test_zuc_encryption_test_case_1(void)
5002 {
5003         return test_zuc_encryption(&zuc_test_case_cipher_193b);
5004 }
5005
5006 static int
5007 test_zuc_encryption_test_case_2(void)
5008 {
5009         return test_zuc_encryption(&zuc_test_case_cipher_800b);
5010 }
5011
5012 static int
5013 test_zuc_encryption_test_case_3(void)
5014 {
5015         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
5016 }
5017
5018 static int
5019 test_zuc_encryption_test_case_4(void)
5020 {
5021         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
5022 }
5023
5024 static int
5025 test_zuc_encryption_test_case_5(void)
5026 {
5027         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
5028 }
5029
5030 static int
5031 test_zuc_encryption_test_case_6_sgl(void)
5032 {
5033         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
5034 }
5035
5036 static int
5037 test_zuc_hash_generate_test_case_1(void)
5038 {
5039         return test_zuc_authentication(&zuc_test_case_auth_1b);
5040 }
5041
5042 static int
5043 test_zuc_hash_generate_test_case_2(void)
5044 {
5045         return test_zuc_authentication(&zuc_test_case_auth_90b);
5046 }
5047
5048 static int
5049 test_zuc_hash_generate_test_case_3(void)
5050 {
5051         return test_zuc_authentication(&zuc_test_case_auth_577b);
5052 }
5053
5054 static int
5055 test_zuc_hash_generate_test_case_4(void)
5056 {
5057         return test_zuc_authentication(&zuc_test_case_auth_2079b);
5058 }
5059
5060 static int
5061 test_zuc_hash_generate_test_case_5(void)
5062 {
5063         return test_zuc_authentication(&zuc_test_auth_5670b);
5064 }
5065
5066 static int
5067 test_zuc_hash_generate_test_case_6(void)
5068 {
5069         return test_zuc_authentication(&zuc_test_case_auth_128b);
5070 }
5071
5072 static int
5073 test_zuc_hash_generate_test_case_7(void)
5074 {
5075         return test_zuc_authentication(&zuc_test_case_auth_2080b);
5076 }
5077
5078 static int
5079 test_zuc_hash_generate_test_case_8(void)
5080 {
5081         return test_zuc_authentication(&zuc_test_case_auth_584b);
5082 }
5083
5084 static int
5085 test_zuc_cipher_auth_test_case_1(void)
5086 {
5087         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
5088 }
5089
5090 static int
5091 test_zuc_cipher_auth_test_case_2(void)
5092 {
5093         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
5094 }
5095
5096 static int
5097 test_3DES_chain_qat_all(void)
5098 {
5099         struct crypto_testsuite_params *ts_params = &testsuite_params;
5100         int status;
5101
5102         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5103                 ts_params->op_mpool,
5104                 ts_params->session_mpool, ts_params->session_priv_mpool,
5105                 ts_params->valid_devs[0],
5106                 rte_cryptodev_driver_id_get(
5107                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
5108                 BLKCIPHER_3DES_CHAIN_TYPE);
5109
5110         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5111
5112         return TEST_SUCCESS;
5113 }
5114
5115 static int
5116 test_DES_cipheronly_qat_all(void)
5117 {
5118         struct crypto_testsuite_params *ts_params = &testsuite_params;
5119         int status;
5120
5121         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5122                 ts_params->op_mpool,
5123                 ts_params->session_mpool, ts_params->session_priv_mpool,
5124                 ts_params->valid_devs[0],
5125                 rte_cryptodev_driver_id_get(
5126                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
5127                 BLKCIPHER_DES_CIPHERONLY_TYPE);
5128
5129         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5130
5131         return TEST_SUCCESS;
5132 }
5133
5134 static int
5135 test_DES_cipheronly_openssl_all(void)
5136 {
5137         struct crypto_testsuite_params *ts_params = &testsuite_params;
5138         int status;
5139
5140         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5141                 ts_params->op_mpool,
5142                 ts_params->session_mpool, ts_params->session_priv_mpool,
5143                 ts_params->valid_devs[0],
5144                 rte_cryptodev_driver_id_get(
5145                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
5146                 BLKCIPHER_DES_CIPHERONLY_TYPE);
5147
5148         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5149
5150         return TEST_SUCCESS;
5151 }
5152
5153 static int
5154 test_DES_docsis_openssl_all(void)
5155 {
5156         struct crypto_testsuite_params *ts_params = &testsuite_params;
5157         int status;
5158
5159         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5160                 ts_params->op_mpool,
5161                 ts_params->session_mpool, ts_params->session_priv_mpool,
5162                 ts_params->valid_devs[0],
5163                 rte_cryptodev_driver_id_get(
5164                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
5165                 BLKCIPHER_DES_DOCSIS_TYPE);
5166
5167         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5168
5169         return TEST_SUCCESS;
5170 }
5171
5172 static int
5173 test_DES_cipheronly_mb_all(void)
5174 {
5175         struct crypto_testsuite_params *ts_params = &testsuite_params;
5176         int status;
5177
5178         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5179                 ts_params->op_mpool,
5180                 ts_params->session_mpool, ts_params->session_priv_mpool,
5181                 ts_params->valid_devs[0],
5182                 rte_cryptodev_driver_id_get(
5183                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
5184                 BLKCIPHER_DES_CIPHERONLY_TYPE);
5185
5186         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5187
5188         return TEST_SUCCESS;
5189 }
5190 static int
5191 test_3DES_cipheronly_mb_all(void)
5192 {
5193         struct crypto_testsuite_params *ts_params = &testsuite_params;
5194         int status;
5195
5196         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5197                 ts_params->op_mpool,
5198                 ts_params->session_mpool, ts_params->session_priv_mpool,
5199                 ts_params->valid_devs[0],
5200                 rte_cryptodev_driver_id_get(
5201                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
5202                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
5203
5204         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5205
5206         return TEST_SUCCESS;
5207 }
5208
5209 static int
5210 test_DES_docsis_mb_all(void)
5211 {
5212         struct crypto_testsuite_params *ts_params = &testsuite_params;
5213         int status;
5214
5215         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5216                 ts_params->op_mpool,
5217                 ts_params->session_mpool, ts_params->session_priv_mpool,
5218                 ts_params->valid_devs[0],
5219                 rte_cryptodev_driver_id_get(
5220                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
5221                 BLKCIPHER_DES_DOCSIS_TYPE);
5222
5223         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5224
5225         return TEST_SUCCESS;
5226 }
5227
5228 static int
5229 test_3DES_chain_caam_jr_all(void)
5230 {
5231         struct crypto_testsuite_params *ts_params = &testsuite_params;
5232         int status;
5233
5234         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5235                 ts_params->op_mpool,
5236                 ts_params->session_mpool, ts_params->session_priv_mpool,
5237                 ts_params->valid_devs[0],
5238                 rte_cryptodev_driver_id_get(
5239                 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
5240                 BLKCIPHER_3DES_CHAIN_TYPE);
5241
5242         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5243
5244         return TEST_SUCCESS;
5245 }
5246
5247 static int
5248 test_3DES_cipheronly_caam_jr_all(void)
5249 {
5250         struct crypto_testsuite_params *ts_params = &testsuite_params;
5251         int status;
5252
5253         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5254                 ts_params->op_mpool,
5255                 ts_params->session_mpool, ts_params->session_priv_mpool,
5256                 ts_params->valid_devs[0],
5257                 rte_cryptodev_driver_id_get(
5258                 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
5259                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
5260
5261         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5262
5263         return TEST_SUCCESS;
5264 }
5265
5266 static int
5267 test_3DES_chain_dpaa_sec_all(void)
5268 {
5269         struct crypto_testsuite_params *ts_params = &testsuite_params;
5270         int status;
5271
5272         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5273                 ts_params->op_mpool,
5274                 ts_params->session_mpool, ts_params->session_priv_mpool,
5275                 ts_params->valid_devs[0],
5276                 rte_cryptodev_driver_id_get(
5277                 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
5278                 BLKCIPHER_3DES_CHAIN_TYPE);
5279
5280         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5281
5282         return TEST_SUCCESS;
5283 }
5284
5285 static int
5286 test_3DES_cipheronly_dpaa_sec_all(void)
5287 {
5288         struct crypto_testsuite_params *ts_params = &testsuite_params;
5289         int status;
5290
5291         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5292                 ts_params->op_mpool,
5293                 ts_params->session_mpool, ts_params->session_priv_mpool,
5294                 ts_params->valid_devs[0],
5295                 rte_cryptodev_driver_id_get(
5296                 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
5297                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
5298
5299         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5300
5301         return TEST_SUCCESS;
5302 }
5303
5304 static int
5305 test_3DES_chain_dpaa2_sec_all(void)
5306 {
5307         struct crypto_testsuite_params *ts_params = &testsuite_params;
5308         int status;
5309
5310         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5311                 ts_params->op_mpool,
5312                 ts_params->session_mpool, ts_params->session_priv_mpool,
5313                 ts_params->valid_devs[0],
5314                 rte_cryptodev_driver_id_get(
5315                 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
5316                 BLKCIPHER_3DES_CHAIN_TYPE);
5317
5318         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5319
5320         return TEST_SUCCESS;
5321 }
5322
5323 static int
5324 test_3DES_cipheronly_dpaa2_sec_all(void)
5325 {
5326         struct crypto_testsuite_params *ts_params = &testsuite_params;
5327         int status;
5328
5329         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5330                 ts_params->op_mpool,
5331                 ts_params->session_mpool, ts_params->session_priv_mpool,
5332                 ts_params->valid_devs[0],
5333                 rte_cryptodev_driver_id_get(
5334                 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
5335                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
5336
5337         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5338
5339         return TEST_SUCCESS;
5340 }
5341
5342 static int
5343 test_3DES_chain_ccp_all(void)
5344 {
5345         struct crypto_testsuite_params *ts_params = &testsuite_params;
5346         int status;
5347
5348         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5349                 ts_params->op_mpool,
5350                 ts_params->session_mpool, ts_params->session_priv_mpool,
5351                 ts_params->valid_devs[0],
5352                 rte_cryptodev_driver_id_get(
5353                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
5354                 BLKCIPHER_3DES_CHAIN_TYPE);
5355
5356         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5357
5358         return TEST_SUCCESS;
5359 }
5360
5361 static int
5362 test_3DES_cipheronly_ccp_all(void)
5363 {
5364         struct crypto_testsuite_params *ts_params = &testsuite_params;
5365         int status;
5366
5367         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5368                 ts_params->op_mpool,
5369                 ts_params->session_mpool, ts_params->session_priv_mpool,
5370                 ts_params->valid_devs[0],
5371                 rte_cryptodev_driver_id_get(
5372                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
5373                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
5374
5375         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5376
5377         return TEST_SUCCESS;
5378 }
5379
5380 static int
5381 test_3DES_cipheronly_qat_all(void)
5382 {
5383         struct crypto_testsuite_params *ts_params = &testsuite_params;
5384         int status;
5385
5386         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5387                 ts_params->op_mpool,
5388                 ts_params->session_mpool, ts_params->session_priv_mpool,
5389                 ts_params->valid_devs[0],
5390                 rte_cryptodev_driver_id_get(
5391                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
5392                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
5393
5394         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5395
5396         return TEST_SUCCESS;
5397 }
5398
5399 static int
5400 test_3DES_chain_openssl_all(void)
5401 {
5402         struct crypto_testsuite_params *ts_params = &testsuite_params;
5403         int status;
5404
5405         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5406                 ts_params->op_mpool,
5407                 ts_params->session_mpool, ts_params->session_priv_mpool,
5408                 ts_params->valid_devs[0],
5409                 rte_cryptodev_driver_id_get(
5410                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
5411                 BLKCIPHER_3DES_CHAIN_TYPE);
5412
5413         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5414
5415         return TEST_SUCCESS;
5416 }
5417
5418 static int
5419 test_3DES_cipheronly_openssl_all(void)
5420 {
5421         struct crypto_testsuite_params *ts_params = &testsuite_params;
5422         int status;
5423
5424         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
5425                 ts_params->op_mpool,
5426                 ts_params->session_mpool, ts_params->session_priv_mpool,
5427                 ts_params->valid_devs[0],
5428                 rte_cryptodev_driver_id_get(
5429                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
5430                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
5431
5432         TEST_ASSERT_EQUAL(status, 0, "Test failed");
5433
5434         return TEST_SUCCESS;
5435 }
5436
5437 /* ***** AEAD algorithm Tests ***** */
5438
5439 static int
5440 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
5441                 enum rte_crypto_aead_operation op,
5442                 const uint8_t *key, const uint8_t key_len,
5443                 const uint16_t aad_len, const uint8_t auth_len,
5444                 uint8_t iv_len)
5445 {
5446         uint8_t aead_key[key_len];
5447
5448         struct crypto_testsuite_params *ts_params = &testsuite_params;
5449         struct crypto_unittest_params *ut_params = &unittest_params;
5450
5451         memcpy(aead_key, key, key_len);
5452
5453         /* Setup AEAD Parameters */
5454         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
5455         ut_params->aead_xform.next = NULL;
5456         ut_params->aead_xform.aead.algo = algo;
5457         ut_params->aead_xform.aead.op = op;
5458         ut_params->aead_xform.aead.key.data = aead_key;
5459         ut_params->aead_xform.aead.key.length = key_len;
5460         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
5461         ut_params->aead_xform.aead.iv.length = iv_len;
5462         ut_params->aead_xform.aead.digest_length = auth_len;
5463         ut_params->aead_xform.aead.aad_length = aad_len;
5464
5465         debug_hexdump(stdout, "key:", key, key_len);
5466
5467         /* Create Crypto session*/
5468         ut_params->sess = rte_cryptodev_sym_session_create(
5469                         ts_params->session_mpool);
5470
5471         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
5472                         &ut_params->aead_xform,
5473                         ts_params->session_priv_mpool);
5474
5475         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5476
5477         return 0;
5478 }
5479
5480 static int
5481 create_aead_xform(struct rte_crypto_op *op,
5482                 enum rte_crypto_aead_algorithm algo,
5483                 enum rte_crypto_aead_operation aead_op,
5484                 uint8_t *key, const uint8_t key_len,
5485                 const uint8_t aad_len, const uint8_t auth_len,
5486                 uint8_t iv_len)
5487 {
5488         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
5489                         "failed to allocate space for crypto transform");
5490
5491         struct rte_crypto_sym_op *sym_op = op->sym;
5492
5493         /* Setup AEAD Parameters */
5494         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
5495         sym_op->xform->next = NULL;
5496         sym_op->xform->aead.algo = algo;
5497         sym_op->xform->aead.op = aead_op;
5498         sym_op->xform->aead.key.data = key;
5499         sym_op->xform->aead.key.length = key_len;
5500         sym_op->xform->aead.iv.offset = IV_OFFSET;
5501         sym_op->xform->aead.iv.length = iv_len;
5502         sym_op->xform->aead.digest_length = auth_len;
5503         sym_op->xform->aead.aad_length = aad_len;
5504
5505         debug_hexdump(stdout, "key:", key, key_len);
5506
5507         return 0;
5508 }
5509
5510 static int
5511 create_aead_operation(enum rte_crypto_aead_operation op,
5512                 const struct aead_test_data *tdata)
5513 {
5514         struct crypto_testsuite_params *ts_params = &testsuite_params;
5515         struct crypto_unittest_params *ut_params = &unittest_params;
5516
5517         uint8_t *plaintext, *ciphertext;
5518         unsigned int aad_pad_len, plaintext_pad_len;
5519
5520         /* Generate Crypto op data structure */
5521         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5522                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5523         TEST_ASSERT_NOT_NULL(ut_params->op,
5524                         "Failed to allocate symmetric crypto operation struct");
5525
5526         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5527
5528         /* Append aad data */
5529         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
5530                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
5531                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5532                                 aad_pad_len);
5533                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
5534                                 "no room to append aad");
5535
5536                 sym_op->aead.aad.phys_addr =
5537                                 rte_pktmbuf_iova(ut_params->ibuf);
5538                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
5539                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
5540                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
5541                         tdata->aad.len);
5542
5543                 /* Append IV at the end of the crypto operation*/
5544                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
5545                                 uint8_t *, IV_OFFSET);
5546
5547                 /* Copy IV 1 byte after the IV pointer, according to the API */
5548                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
5549                 debug_hexdump(stdout, "iv:", iv_ptr,
5550                         tdata->iv.len);
5551         } else {
5552                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
5553                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5554                                 aad_pad_len);
5555                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
5556                                 "no room to append aad");
5557
5558                 sym_op->aead.aad.phys_addr =
5559                                 rte_pktmbuf_iova(ut_params->ibuf);
5560                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
5561                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
5562                         tdata->aad.len);
5563
5564                 /* Append IV at the end of the crypto operation*/
5565                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
5566                                 uint8_t *, IV_OFFSET);
5567
5568                 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
5569                 debug_hexdump(stdout, "iv:", iv_ptr,
5570                         tdata->iv.len);
5571         }
5572
5573         /* Append plaintext/ciphertext */
5574         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
5575                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5576                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5577                                 plaintext_pad_len);
5578                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
5579
5580                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
5581                 debug_hexdump(stdout, "plaintext:", plaintext,
5582                                 tdata->plaintext.len);
5583
5584                 if (ut_params->obuf) {
5585                         ciphertext = (uint8_t *)rte_pktmbuf_append(
5586                                         ut_params->obuf,
5587                                         plaintext_pad_len + aad_pad_len);
5588                         TEST_ASSERT_NOT_NULL(ciphertext,
5589                                         "no room to append ciphertext");
5590
5591                         memset(ciphertext + aad_pad_len, 0,
5592                                         tdata->ciphertext.len);
5593                 }
5594         } else {
5595                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
5596                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5597                                 plaintext_pad_len);
5598                 TEST_ASSERT_NOT_NULL(ciphertext,
5599                                 "no room to append ciphertext");
5600
5601                 memcpy(ciphertext, tdata->ciphertext.data,
5602                                 tdata->ciphertext.len);
5603                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5604                                 tdata->ciphertext.len);
5605
5606                 if (ut_params->obuf) {
5607                         plaintext = (uint8_t *)rte_pktmbuf_append(
5608                                         ut_params->obuf,
5609                                         plaintext_pad_len + aad_pad_len);
5610                         TEST_ASSERT_NOT_NULL(plaintext,
5611                                         "no room to append plaintext");
5612
5613                         memset(plaintext + aad_pad_len, 0,
5614                                         tdata->plaintext.len);
5615                 }
5616         }
5617
5618         /* Append digest data */
5619         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
5620                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
5621                                 ut_params->obuf ? ut_params->obuf :
5622                                                 ut_params->ibuf,
5623                                                 tdata->auth_tag.len);
5624                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
5625                                 "no room to append digest");
5626                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
5627                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
5628                                 ut_params->obuf ? ut_params->obuf :
5629                                                 ut_params->ibuf,
5630                                                 plaintext_pad_len +
5631                                                 aad_pad_len);
5632         } else {
5633                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
5634                                 ut_params->ibuf, tdata->auth_tag.len);
5635                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
5636                                 "no room to append digest");
5637                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
5638                                 ut_params->ibuf,
5639                                 plaintext_pad_len + aad_pad_len);
5640
5641                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
5642                         tdata->auth_tag.len);
5643                 debug_hexdump(stdout, "digest:",
5644                         sym_op->aead.digest.data,
5645                         tdata->auth_tag.len);
5646         }
5647
5648         sym_op->aead.data.length = tdata->plaintext.len;
5649         sym_op->aead.data.offset = aad_pad_len;
5650
5651         return 0;
5652 }
5653
5654 static int
5655 test_authenticated_encryption(const struct aead_test_data *tdata)
5656 {
5657         struct crypto_testsuite_params *ts_params = &testsuite_params;
5658         struct crypto_unittest_params *ut_params = &unittest_params;
5659
5660         int retval;
5661         uint8_t *ciphertext, *auth_tag;
5662         uint16_t plaintext_pad_len;
5663         uint32_t i;
5664
5665         /* Create AEAD session */
5666         retval = create_aead_session(ts_params->valid_devs[0],
5667                         tdata->algo,
5668                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
5669                         tdata->key.data, tdata->key.len,
5670                         tdata->aad.len, tdata->auth_tag.len,
5671                         tdata->iv.len);
5672         if (retval < 0)
5673                 return retval;
5674
5675         if (tdata->aad.len > MBUF_SIZE) {
5676                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5677                 /* Populate full size of add data */
5678                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
5679                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
5680         } else
5681                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5682
5683         /* clear mbuf payload */
5684         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5685                         rte_pktmbuf_tailroom(ut_params->ibuf));
5686
5687         /* Create AEAD operation */
5688         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
5689         if (retval < 0)
5690                 return retval;
5691
5692         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5693
5694         ut_params->op->sym->m_src = ut_params->ibuf;
5695
5696         /* Process crypto operation */
5697         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5698                         ut_params->op), "failed to process sym crypto op");
5699
5700         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5701                         "crypto op processing failed");
5702
5703         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5704
5705         if (ut_params->op->sym->m_dst) {
5706                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
5707                                 uint8_t *);
5708                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5709                                 uint8_t *, plaintext_pad_len);
5710         } else {
5711                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
5712                                 uint8_t *,
5713                                 ut_params->op->sym->cipher.data.offset);
5714                 auth_tag = ciphertext + plaintext_pad_len;
5715         }
5716
5717         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5718         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5719
5720         /* Validate obuf */
5721         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5722                         ciphertext,
5723                         tdata->ciphertext.data,
5724                         tdata->ciphertext.len,
5725                         "Ciphertext data not as expected");
5726
5727         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5728                         auth_tag,
5729                         tdata->auth_tag.data,
5730                         tdata->auth_tag.len,
5731                         "Generated auth tag not as expected");
5732
5733         return 0;
5734
5735 }
5736
5737 static int
5738 test_AES_GCM_authenticated_encryption_test_case_1(void)
5739 {
5740         return test_authenticated_encryption(&gcm_test_case_1);
5741 }
5742
5743 static int
5744 test_AES_GCM_authenticated_encryption_test_case_2(void)
5745 {
5746         return test_authenticated_encryption(&gcm_test_case_2);
5747 }
5748
5749 static int
5750 test_AES_GCM_authenticated_encryption_test_case_3(void)
5751 {
5752         return test_authenticated_encryption(&gcm_test_case_3);
5753 }
5754
5755 static int
5756 test_AES_GCM_authenticated_encryption_test_case_4(void)
5757 {
5758         return test_authenticated_encryption(&gcm_test_case_4);
5759 }
5760
5761 static int
5762 test_AES_GCM_authenticated_encryption_test_case_5(void)
5763 {
5764         return test_authenticated_encryption(&gcm_test_case_5);
5765 }
5766
5767 static int
5768 test_AES_GCM_authenticated_encryption_test_case_6(void)
5769 {
5770         return test_authenticated_encryption(&gcm_test_case_6);
5771 }
5772
5773 static int
5774 test_AES_GCM_authenticated_encryption_test_case_7(void)
5775 {
5776         return test_authenticated_encryption(&gcm_test_case_7);
5777 }
5778
5779 static int
5780 test_AES_GCM_auth_encryption_test_case_192_1(void)
5781 {
5782         return test_authenticated_encryption(&gcm_test_case_192_1);
5783 }
5784
5785 static int
5786 test_AES_GCM_auth_encryption_test_case_192_2(void)
5787 {
5788         return test_authenticated_encryption(&gcm_test_case_192_2);
5789 }
5790
5791 static int
5792 test_AES_GCM_auth_encryption_test_case_192_3(void)
5793 {
5794         return test_authenticated_encryption(&gcm_test_case_192_3);
5795 }
5796
5797 static int
5798 test_AES_GCM_auth_encryption_test_case_192_4(void)
5799 {
5800         return test_authenticated_encryption(&gcm_test_case_192_4);
5801 }
5802
5803 static int
5804 test_AES_GCM_auth_encryption_test_case_192_5(void)
5805 {
5806         return test_authenticated_encryption(&gcm_test_case_192_5);
5807 }
5808
5809 static int
5810 test_AES_GCM_auth_encryption_test_case_192_6(void)
5811 {
5812         return test_authenticated_encryption(&gcm_test_case_192_6);
5813 }
5814
5815 static int
5816 test_AES_GCM_auth_encryption_test_case_192_7(void)
5817 {
5818         return test_authenticated_encryption(&gcm_test_case_192_7);
5819 }
5820
5821 static int
5822 test_AES_GCM_auth_encryption_test_case_256_1(void)
5823 {
5824         return test_authenticated_encryption(&gcm_test_case_256_1);
5825 }
5826
5827 static int
5828 test_AES_GCM_auth_encryption_test_case_256_2(void)
5829 {
5830         return test_authenticated_encryption(&gcm_test_case_256_2);
5831 }
5832
5833 static int
5834 test_AES_GCM_auth_encryption_test_case_256_3(void)
5835 {
5836         return test_authenticated_encryption(&gcm_test_case_256_3);
5837 }
5838
5839 static int
5840 test_AES_GCM_auth_encryption_test_case_256_4(void)
5841 {
5842         return test_authenticated_encryption(&gcm_test_case_256_4);
5843 }
5844
5845 static int
5846 test_AES_GCM_auth_encryption_test_case_256_5(void)
5847 {
5848         return test_authenticated_encryption(&gcm_test_case_256_5);
5849 }
5850
5851 static int
5852 test_AES_GCM_auth_encryption_test_case_256_6(void)
5853 {
5854         return test_authenticated_encryption(&gcm_test_case_256_6);
5855 }
5856
5857 static int
5858 test_AES_GCM_auth_encryption_test_case_256_7(void)
5859 {
5860         return test_authenticated_encryption(&gcm_test_case_256_7);
5861 }
5862
5863 static int
5864 test_AES_GCM_auth_encryption_test_case_aad_1(void)
5865 {
5866         return test_authenticated_encryption(&gcm_test_case_aad_1);
5867 }
5868
5869 static int
5870 test_AES_GCM_auth_encryption_test_case_aad_2(void)
5871 {
5872         return test_authenticated_encryption(&gcm_test_case_aad_2);
5873 }
5874
5875 static int
5876 test_authenticated_decryption(const struct aead_test_data *tdata)
5877 {
5878         struct crypto_testsuite_params *ts_params = &testsuite_params;
5879         struct crypto_unittest_params *ut_params = &unittest_params;
5880
5881         int retval;
5882         uint8_t *plaintext;
5883         uint32_t i;
5884
5885         /* Create AEAD session */
5886         retval = create_aead_session(ts_params->valid_devs[0],
5887                         tdata->algo,
5888                         RTE_CRYPTO_AEAD_OP_DECRYPT,
5889                         tdata->key.data, tdata->key.len,
5890                         tdata->aad.len, tdata->auth_tag.len,
5891                         tdata->iv.len);
5892         if (retval < 0)
5893                 return retval;
5894
5895         /* alloc mbuf and set payload */
5896         if (tdata->aad.len > MBUF_SIZE) {
5897                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
5898                 /* Populate full size of add data */
5899                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
5900                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
5901         } else
5902                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5903
5904         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5905                         rte_pktmbuf_tailroom(ut_params->ibuf));
5906
5907         /* Create AEAD operation */
5908         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
5909         if (retval < 0)
5910                 return retval;
5911
5912         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5913
5914         ut_params->op->sym->m_src = ut_params->ibuf;
5915
5916         /* Process crypto operation */
5917         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5918                         ut_params->op), "failed to process sym crypto op");
5919
5920         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5921                         "crypto op processing failed");
5922
5923         if (ut_params->op->sym->m_dst)
5924                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
5925                                 uint8_t *);
5926         else
5927                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
5928                                 uint8_t *,
5929                                 ut_params->op->sym->cipher.data.offset);
5930
5931         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5932
5933         /* Validate obuf */
5934         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5935                         plaintext,
5936                         tdata->plaintext.data,
5937                         tdata->plaintext.len,
5938                         "Plaintext data not as expected");
5939
5940         TEST_ASSERT_EQUAL(ut_params->op->status,
5941                         RTE_CRYPTO_OP_STATUS_SUCCESS,
5942                         "Authentication failed");
5943         return 0;
5944 }
5945
5946 static int
5947 test_AES_GCM_authenticated_decryption_test_case_1(void)
5948 {
5949         return test_authenticated_decryption(&gcm_test_case_1);
5950 }
5951
5952 static int
5953 test_AES_GCM_authenticated_decryption_test_case_2(void)
5954 {
5955         return test_authenticated_decryption(&gcm_test_case_2);
5956 }
5957
5958 static int
5959 test_AES_GCM_authenticated_decryption_test_case_3(void)
5960 {
5961         return test_authenticated_decryption(&gcm_test_case_3);
5962 }
5963
5964 static int
5965 test_AES_GCM_authenticated_decryption_test_case_4(void)
5966 {
5967         return test_authenticated_decryption(&gcm_test_case_4);
5968 }
5969
5970 static int
5971 test_AES_GCM_authenticated_decryption_test_case_5(void)
5972 {
5973         return test_authenticated_decryption(&gcm_test_case_5);
5974 }
5975
5976 static int
5977 test_AES_GCM_authenticated_decryption_test_case_6(void)
5978 {
5979         return test_authenticated_decryption(&gcm_test_case_6);
5980 }
5981
5982 static int
5983 test_AES_GCM_authenticated_decryption_test_case_7(void)
5984 {
5985         return test_authenticated_decryption(&gcm_test_case_7);
5986 }
5987
5988 static int
5989 test_AES_GCM_auth_decryption_test_case_192_1(void)
5990 {
5991         return test_authenticated_decryption(&gcm_test_case_192_1);
5992 }
5993
5994 static int
5995 test_AES_GCM_auth_decryption_test_case_192_2(void)
5996 {
5997         return test_authenticated_decryption(&gcm_test_case_192_2);
5998 }
5999
6000 static int
6001 test_AES_GCM_auth_decryption_test_case_192_3(void)
6002 {
6003         return test_authenticated_decryption(&gcm_test_case_192_3);
6004 }
6005
6006 static int
6007 test_AES_GCM_auth_decryption_test_case_192_4(void)
6008 {
6009         return test_authenticated_decryption(&gcm_test_case_192_4);
6010 }
6011
6012 static int
6013 test_AES_GCM_auth_decryption_test_case_192_5(void)
6014 {
6015         return test_authenticated_decryption(&gcm_test_case_192_5);
6016 }
6017
6018 static int
6019 test_AES_GCM_auth_decryption_test_case_192_6(void)
6020 {
6021         return test_authenticated_decryption(&gcm_test_case_192_6);
6022 }
6023
6024 static int
6025 test_AES_GCM_auth_decryption_test_case_192_7(void)
6026 {
6027         return test_authenticated_decryption(&gcm_test_case_192_7);
6028 }
6029
6030 static int
6031 test_AES_GCM_auth_decryption_test_case_256_1(void)
6032 {
6033         return test_authenticated_decryption(&gcm_test_case_256_1);
6034 }
6035
6036 static int
6037 test_AES_GCM_auth_decryption_test_case_256_2(void)
6038 {
6039         return test_authenticated_decryption(&gcm_test_case_256_2);
6040 }
6041
6042 static int
6043 test_AES_GCM_auth_decryption_test_case_256_3(void)
6044 {
6045         return test_authenticated_decryption(&gcm_test_case_256_3);
6046 }
6047
6048 static int
6049 test_AES_GCM_auth_decryption_test_case_256_4(void)
6050 {
6051         return test_authenticated_decryption(&gcm_test_case_256_4);
6052 }
6053
6054 static int
6055 test_AES_GCM_auth_decryption_test_case_256_5(void)
6056 {
6057         return test_authenticated_decryption(&gcm_test_case_256_5);
6058 }
6059
6060 static int
6061 test_AES_GCM_auth_decryption_test_case_256_6(void)
6062 {
6063         return test_authenticated_decryption(&gcm_test_case_256_6);
6064 }
6065
6066 static int
6067 test_AES_GCM_auth_decryption_test_case_256_7(void)
6068 {
6069         return test_authenticated_decryption(&gcm_test_case_256_7);
6070 }
6071
6072 static int
6073 test_AES_GCM_auth_decryption_test_case_aad_1(void)
6074 {
6075         return test_authenticated_decryption(&gcm_test_case_aad_1);
6076 }
6077
6078 static int
6079 test_AES_GCM_auth_decryption_test_case_aad_2(void)
6080 {
6081         return test_authenticated_decryption(&gcm_test_case_aad_2);
6082 }
6083
6084 static int
6085 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
6086 {
6087         struct crypto_testsuite_params *ts_params = &testsuite_params;
6088         struct crypto_unittest_params *ut_params = &unittest_params;
6089
6090         int retval;
6091         uint8_t *ciphertext, *auth_tag;
6092         uint16_t plaintext_pad_len;
6093
6094         /* Create AEAD session */
6095         retval = create_aead_session(ts_params->valid_devs[0],
6096                         tdata->algo,
6097                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
6098                         tdata->key.data, tdata->key.len,
6099                         tdata->aad.len, tdata->auth_tag.len,
6100                         tdata->iv.len);
6101         if (retval < 0)
6102                 return retval;
6103
6104         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6105         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6106
6107         /* clear mbuf payload */
6108         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6109                         rte_pktmbuf_tailroom(ut_params->ibuf));
6110         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6111                         rte_pktmbuf_tailroom(ut_params->obuf));
6112
6113         /* Create AEAD operation */
6114         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
6115         if (retval < 0)
6116                 return retval;
6117
6118         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6119
6120         ut_params->op->sym->m_src = ut_params->ibuf;
6121         ut_params->op->sym->m_dst = ut_params->obuf;
6122
6123         /* Process crypto operation */
6124         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6125                         ut_params->op), "failed to process sym crypto op");
6126
6127         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6128                         "crypto op processing failed");
6129
6130         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
6131
6132         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
6133                         ut_params->op->sym->cipher.data.offset);
6134         auth_tag = ciphertext + plaintext_pad_len;
6135
6136         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
6137         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
6138
6139         /* Validate obuf */
6140         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6141                         ciphertext,
6142                         tdata->ciphertext.data,
6143                         tdata->ciphertext.len,
6144                         "Ciphertext data not as expected");
6145
6146         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6147                         auth_tag,
6148                         tdata->auth_tag.data,
6149                         tdata->auth_tag.len,
6150                         "Generated auth tag not as expected");
6151
6152         return 0;
6153
6154 }
6155
6156 static int
6157 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
6158 {
6159         return test_authenticated_encryption_oop(&gcm_test_case_5);
6160 }
6161
6162 static int
6163 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
6164 {
6165         struct crypto_testsuite_params *ts_params = &testsuite_params;
6166         struct crypto_unittest_params *ut_params = &unittest_params;
6167
6168         int retval;
6169         uint8_t *plaintext;
6170
6171         /* Create AEAD session */
6172         retval = create_aead_session(ts_params->valid_devs[0],
6173                         tdata->algo,
6174                         RTE_CRYPTO_AEAD_OP_DECRYPT,
6175                         tdata->key.data, tdata->key.len,
6176                         tdata->aad.len, tdata->auth_tag.len,
6177                         tdata->iv.len);
6178         if (retval < 0)
6179                 return retval;
6180
6181         /* alloc mbuf and set payload */
6182         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6183         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6184
6185         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6186                         rte_pktmbuf_tailroom(ut_params->ibuf));
6187         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6188                         rte_pktmbuf_tailroom(ut_params->obuf));
6189
6190         /* Create AEAD operation */
6191         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
6192         if (retval < 0)
6193                 return retval;
6194
6195         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6196
6197         ut_params->op->sym->m_src = ut_params->ibuf;
6198         ut_params->op->sym->m_dst = ut_params->obuf;
6199
6200         /* Process crypto operation */
6201         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6202                         ut_params->op), "failed to process sym crypto op");
6203
6204         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6205                         "crypto op processing failed");
6206
6207         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
6208                         ut_params->op->sym->cipher.data.offset);
6209
6210         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
6211
6212         /* Validate obuf */
6213         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6214                         plaintext,
6215                         tdata->plaintext.data,
6216                         tdata->plaintext.len,
6217                         "Plaintext data not as expected");
6218
6219         TEST_ASSERT_EQUAL(ut_params->op->status,
6220                         RTE_CRYPTO_OP_STATUS_SUCCESS,
6221                         "Authentication failed");
6222         return 0;
6223 }
6224
6225 static int
6226 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
6227 {
6228         return test_authenticated_decryption_oop(&gcm_test_case_5);
6229 }
6230
6231 static int
6232 test_authenticated_encryption_sessionless(
6233                 const struct aead_test_data *tdata)
6234 {
6235         struct crypto_testsuite_params *ts_params = &testsuite_params;
6236         struct crypto_unittest_params *ut_params = &unittest_params;
6237
6238         int retval;
6239         uint8_t *ciphertext, *auth_tag;
6240         uint16_t plaintext_pad_len;
6241         uint8_t key[tdata->key.len + 1];
6242
6243         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6244
6245         /* clear mbuf payload */
6246         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6247                         rte_pktmbuf_tailroom(ut_params->ibuf));
6248
6249         /* Create AEAD operation */
6250         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
6251         if (retval < 0)
6252                 return retval;
6253
6254         /* Create GCM xform */
6255         memcpy(key, tdata->key.data, tdata->key.len);
6256         retval = create_aead_xform(ut_params->op,
6257                         tdata->algo,
6258                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
6259                         key, tdata->key.len,
6260                         tdata->aad.len, tdata->auth_tag.len,
6261                         tdata->iv.len);
6262         if (retval < 0)
6263                 return retval;
6264
6265         ut_params->op->sym->m_src = ut_params->ibuf;
6266
6267         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
6268                         RTE_CRYPTO_OP_SESSIONLESS,
6269                         "crypto op session type not sessionless");
6270
6271         /* Process crypto operation */
6272         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6273                         ut_params->op), "failed to process sym crypto op");
6274
6275         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
6276
6277         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6278                         "crypto op status not success");
6279
6280         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
6281
6282         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
6283                         ut_params->op->sym->cipher.data.offset);
6284         auth_tag = ciphertext + plaintext_pad_len;
6285
6286         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
6287         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
6288
6289         /* Validate obuf */
6290         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6291                         ciphertext,
6292                         tdata->ciphertext.data,
6293                         tdata->ciphertext.len,
6294                         "Ciphertext data not as expected");
6295
6296         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6297                         auth_tag,
6298                         tdata->auth_tag.data,
6299                         tdata->auth_tag.len,
6300                         "Generated auth tag not as expected");
6301
6302         return 0;
6303
6304 }
6305
6306 static int
6307 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
6308 {
6309         return test_authenticated_encryption_sessionless(
6310                         &gcm_test_case_5);
6311 }
6312
6313 static int
6314 test_authenticated_decryption_sessionless(
6315                 const struct aead_test_data *tdata)
6316 {
6317         struct crypto_testsuite_params *ts_params = &testsuite_params;
6318         struct crypto_unittest_params *ut_params = &unittest_params;
6319
6320         int retval;
6321         uint8_t *plaintext;
6322         uint8_t key[tdata->key.len + 1];
6323
6324         /* alloc mbuf and set payload */
6325         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6326
6327         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6328                         rte_pktmbuf_tailroom(ut_params->ibuf));
6329
6330         /* Create AEAD operation */
6331         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
6332         if (retval < 0)
6333                 return retval;
6334
6335         /* Create AEAD xform */
6336         memcpy(key, tdata->key.data, tdata->key.len);
6337         retval = create_aead_xform(ut_params->op,
6338                         tdata->algo,
6339                         RTE_CRYPTO_AEAD_OP_DECRYPT,
6340                         key, tdata->key.len,
6341                         tdata->aad.len, tdata->auth_tag.len,
6342                         tdata->iv.len);
6343         if (retval < 0)
6344                 return retval;
6345
6346         ut_params->op->sym->m_src = ut_params->ibuf;
6347
6348         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
6349                         RTE_CRYPTO_OP_SESSIONLESS,
6350                         "crypto op session type not sessionless");
6351
6352         /* Process crypto operation */
6353         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6354                         ut_params->op), "failed to process sym crypto op");
6355
6356         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
6357
6358         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6359                         "crypto op status not success");
6360
6361         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
6362                         ut_params->op->sym->cipher.data.offset);
6363
6364         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
6365
6366         /* Validate obuf */
6367         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6368                         plaintext,
6369                         tdata->plaintext.data,
6370                         tdata->plaintext.len,
6371                         "Plaintext data not as expected");
6372
6373         TEST_ASSERT_EQUAL(ut_params->op->status,
6374                         RTE_CRYPTO_OP_STATUS_SUCCESS,
6375                         "Authentication failed");
6376         return 0;
6377 }
6378
6379 static int
6380 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
6381 {
6382         return test_authenticated_decryption_sessionless(
6383                         &gcm_test_case_5);
6384 }
6385
6386 static int
6387 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
6388 {
6389         return test_authenticated_encryption(&ccm_test_case_128_1);
6390 }
6391
6392 static int
6393 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
6394 {
6395         return test_authenticated_encryption(&ccm_test_case_128_2);
6396 }
6397
6398 static int
6399 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
6400 {
6401         return test_authenticated_encryption(&ccm_test_case_128_3);
6402 }
6403
6404 static int
6405 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
6406 {
6407         return test_authenticated_decryption(&ccm_test_case_128_1);
6408 }
6409
6410 static int
6411 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
6412 {
6413         return test_authenticated_decryption(&ccm_test_case_128_2);
6414 }
6415
6416 static int
6417 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
6418 {
6419         return test_authenticated_decryption(&ccm_test_case_128_3);
6420 }
6421
6422 static int
6423 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
6424 {
6425         return test_authenticated_encryption(&ccm_test_case_192_1);
6426 }
6427
6428 static int
6429 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
6430 {
6431         return test_authenticated_encryption(&ccm_test_case_192_2);
6432 }
6433
6434 static int
6435 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
6436 {
6437         return test_authenticated_encryption(&ccm_test_case_192_3);
6438 }
6439
6440 static int
6441 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
6442 {
6443         return test_authenticated_decryption(&ccm_test_case_192_1);
6444 }
6445
6446 static int
6447 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
6448 {
6449         return test_authenticated_decryption(&ccm_test_case_192_2);
6450 }
6451
6452 static int
6453 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
6454 {
6455         return test_authenticated_decryption(&ccm_test_case_192_3);
6456 }
6457
6458 static int
6459 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
6460 {
6461         return test_authenticated_encryption(&ccm_test_case_256_1);
6462 }
6463
6464 static int
6465 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
6466 {
6467         return test_authenticated_encryption(&ccm_test_case_256_2);
6468 }
6469
6470 static int
6471 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
6472 {
6473         return test_authenticated_encryption(&ccm_test_case_256_3);
6474 }
6475
6476 static int
6477 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
6478 {
6479         return test_authenticated_decryption(&ccm_test_case_256_1);
6480 }
6481
6482 static int
6483 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
6484 {
6485         return test_authenticated_decryption(&ccm_test_case_256_2);
6486 }
6487
6488 static int
6489 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
6490 {
6491         return test_authenticated_decryption(&ccm_test_case_256_3);
6492 }
6493
6494 static int
6495 test_stats(void)
6496 {
6497         struct crypto_testsuite_params *ts_params = &testsuite_params;
6498         struct rte_cryptodev_stats stats;
6499         struct rte_cryptodev *dev;
6500         cryptodev_stats_get_t temp_pfn;
6501
6502         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
6503         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
6504                         &stats) == -ENODEV),
6505                 "rte_cryptodev_stats_get invalid dev failed");
6506         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
6507                 "rte_cryptodev_stats_get invalid Param failed");
6508         dev = &rte_cryptodevs[ts_params->valid_devs[0]];
6509         temp_pfn = dev->dev_ops->stats_get;
6510         dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
6511         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
6512                         == -ENOTSUP),
6513                 "rte_cryptodev_stats_get invalid Param failed");
6514         dev->dev_ops->stats_get = temp_pfn;
6515
6516         /* Test expected values */
6517         ut_setup();
6518         test_AES_CBC_HMAC_SHA1_encrypt_digest();
6519         ut_teardown();
6520         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
6521                         &stats),
6522                 "rte_cryptodev_stats_get failed");
6523         TEST_ASSERT((stats.enqueued_count == 1),
6524                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
6525         TEST_ASSERT((stats.dequeued_count == 1),
6526                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
6527         TEST_ASSERT((stats.enqueue_err_count == 0),
6528                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
6529         TEST_ASSERT((stats.dequeue_err_count == 0),
6530                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
6531
6532         /* invalid device but should ignore and not reset device stats*/
6533         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
6534         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
6535                         &stats),
6536                 "rte_cryptodev_stats_get failed");
6537         TEST_ASSERT((stats.enqueued_count == 1),
6538                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
6539
6540         /* check that a valid reset clears stats */
6541         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
6542         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
6543                         &stats),
6544                                           "rte_cryptodev_stats_get failed");
6545         TEST_ASSERT((stats.enqueued_count == 0),
6546                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
6547         TEST_ASSERT((stats.dequeued_count == 0),
6548                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
6549
6550         return TEST_SUCCESS;
6551 }
6552
6553 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
6554                                    struct crypto_unittest_params *ut_params,
6555                                    enum rte_crypto_auth_operation op,
6556                                    const struct HMAC_MD5_vector *test_case)
6557 {
6558         uint8_t key[64];
6559
6560         memcpy(key, test_case->key.data, test_case->key.len);
6561
6562         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6563         ut_params->auth_xform.next = NULL;
6564         ut_params->auth_xform.auth.op = op;
6565
6566         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
6567
6568         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
6569         ut_params->auth_xform.auth.key.length = test_case->key.len;
6570         ut_params->auth_xform.auth.key.data = key;
6571
6572         ut_params->sess = rte_cryptodev_sym_session_create(
6573                         ts_params->session_mpool);
6574
6575         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6576                         ut_params->sess, &ut_params->auth_xform,
6577                         ts_params->session_priv_mpool);
6578
6579         if (ut_params->sess == NULL)
6580                 return TEST_FAILED;
6581
6582         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6583
6584         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6585                         rte_pktmbuf_tailroom(ut_params->ibuf));
6586
6587         return 0;
6588 }
6589
6590 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
6591                               const struct HMAC_MD5_vector *test_case,
6592                               uint8_t **plaintext)
6593 {
6594         uint16_t plaintext_pad_len;
6595
6596         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6597
6598         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
6599                                 16);
6600
6601         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6602                         plaintext_pad_len);
6603         memcpy(*plaintext, test_case->plaintext.data,
6604                         test_case->plaintext.len);
6605
6606         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
6607                         ut_params->ibuf, MD5_DIGEST_LEN);
6608         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6609                         "no room to append digest");
6610         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
6611                         ut_params->ibuf, plaintext_pad_len);
6612
6613         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
6614                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
6615                            test_case->auth_tag.len);
6616         }
6617
6618         sym_op->auth.data.offset = 0;
6619         sym_op->auth.data.length = test_case->plaintext.len;
6620
6621         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6622         ut_params->op->sym->m_src = ut_params->ibuf;
6623
6624         return 0;
6625 }
6626
6627 static int
6628 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
6629 {
6630         uint16_t plaintext_pad_len;
6631         uint8_t *plaintext, *auth_tag;
6632
6633         struct crypto_testsuite_params *ts_params = &testsuite_params;
6634         struct crypto_unittest_params *ut_params = &unittest_params;
6635
6636         if (MD5_HMAC_create_session(ts_params, ut_params,
6637                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
6638                 return TEST_FAILED;
6639
6640         /* Generate Crypto op data structure */
6641         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6642                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6643         TEST_ASSERT_NOT_NULL(ut_params->op,
6644                         "Failed to allocate symmetric crypto operation struct");
6645
6646         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
6647                                 16);
6648
6649         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
6650                 return TEST_FAILED;
6651
6652         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6653                         ut_params->op), "failed to process sym crypto op");
6654
6655         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6656                         "crypto op processing failed");
6657
6658         if (ut_params->op->sym->m_dst) {
6659                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
6660                                 uint8_t *, plaintext_pad_len);
6661         } else {
6662                 auth_tag = plaintext + plaintext_pad_len;
6663         }
6664
6665         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6666                         auth_tag,
6667                         test_case->auth_tag.data,
6668                         test_case->auth_tag.len,
6669                         "HMAC_MD5 generated tag not as expected");
6670
6671         return TEST_SUCCESS;
6672 }
6673
6674 static int
6675 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
6676 {
6677         uint8_t *plaintext;
6678
6679         struct crypto_testsuite_params *ts_params = &testsuite_params;
6680         struct crypto_unittest_params *ut_params = &unittest_params;
6681
6682         if (MD5_HMAC_create_session(ts_params, ut_params,
6683                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
6684                 return TEST_FAILED;
6685         }
6686
6687         /* Generate Crypto op data structure */
6688         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6689                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6690         TEST_ASSERT_NOT_NULL(ut_params->op,
6691                         "Failed to allocate symmetric crypto operation struct");
6692
6693         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
6694                 return TEST_FAILED;
6695
6696         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6697                         ut_params->op), "failed to process sym crypto op");
6698
6699         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6700                         "HMAC_MD5 crypto op processing failed");
6701
6702         return TEST_SUCCESS;
6703 }
6704
6705 static int
6706 test_MD5_HMAC_generate_case_1(void)
6707 {
6708         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
6709 }
6710
6711 static int
6712 test_MD5_HMAC_verify_case_1(void)
6713 {
6714         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
6715 }
6716
6717 static int
6718 test_MD5_HMAC_generate_case_2(void)
6719 {
6720         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
6721 }
6722
6723 static int
6724 test_MD5_HMAC_verify_case_2(void)
6725 {
6726         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
6727 }
6728
6729 static int
6730 test_multi_session(void)
6731 {
6732         struct crypto_testsuite_params *ts_params = &testsuite_params;
6733         struct crypto_unittest_params *ut_params = &unittest_params;
6734
6735         struct rte_cryptodev_info dev_info;
6736         struct rte_cryptodev_sym_session **sessions;
6737
6738         uint16_t i;
6739
6740         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
6741                         aes_cbc_key, hmac_sha512_key);
6742
6743
6744         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6745
6746         sessions = rte_malloc(NULL,
6747                         (sizeof(struct rte_cryptodev_sym_session *) *
6748                         MAX_NB_SESSIONS) + 1, 0);
6749
6750         /* Create multiple crypto sessions*/
6751         for (i = 0; i < MAX_NB_SESSIONS; i++) {
6752
6753                 sessions[i] = rte_cryptodev_sym_session_create(
6754                                 ts_params->session_mpool);
6755
6756                 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6757                                 sessions[i], &ut_params->auth_xform,
6758                                 ts_params->session_priv_mpool);
6759                 TEST_ASSERT_NOT_NULL(sessions[i],
6760                                 "Session creation failed at session number %u",
6761                                 i);
6762
6763                 /* Attempt to send a request on each session */
6764                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
6765                         sessions[i],
6766                         ut_params,
6767                         ts_params,
6768                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
6769                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
6770                         aes_cbc_iv),
6771                         "Failed to perform decrypt on request number %u.", i);
6772                 /* free crypto operation structure */
6773                 if (ut_params->op)
6774                         rte_crypto_op_free(ut_params->op);
6775
6776                 /*
6777                  * free mbuf - both obuf and ibuf are usually the same,
6778                  * so check if they point at the same address is necessary,
6779                  * to avoid freeing the mbuf twice.
6780                  */
6781                 if (ut_params->obuf) {
6782                         rte_pktmbuf_free(ut_params->obuf);
6783                         if (ut_params->ibuf == ut_params->obuf)
6784                                 ut_params->ibuf = 0;
6785                         ut_params->obuf = 0;
6786                 }
6787                 if (ut_params->ibuf) {
6788                         rte_pktmbuf_free(ut_params->ibuf);
6789                         ut_params->ibuf = 0;
6790                 }
6791         }
6792
6793         /* Next session create should fail */
6794         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6795                         sessions[i], &ut_params->auth_xform,
6796                         ts_params->session_priv_mpool);
6797         TEST_ASSERT_NULL(sessions[i],
6798                         "Session creation succeeded unexpectedly!");
6799
6800         for (i = 0; i < MAX_NB_SESSIONS; i++) {
6801                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
6802                                 sessions[i]);
6803                 rte_cryptodev_sym_session_free(sessions[i]);
6804         }
6805
6806         rte_free(sessions);
6807
6808         return TEST_SUCCESS;
6809 }
6810
6811 struct multi_session_params {
6812         struct crypto_unittest_params ut_params;
6813         uint8_t *cipher_key;
6814         uint8_t *hmac_key;
6815         const uint8_t *cipher;
6816         const uint8_t *digest;
6817         uint8_t *iv;
6818 };
6819
6820 #define MB_SESSION_NUMBER 3
6821
6822 static int
6823 test_multi_session_random_usage(void)
6824 {
6825         struct crypto_testsuite_params *ts_params = &testsuite_params;
6826         struct rte_cryptodev_info dev_info;
6827         struct rte_cryptodev_sym_session **sessions;
6828         uint32_t i, j;
6829         struct multi_session_params ut_paramz[] = {
6830
6831                 {
6832                         .cipher_key = ms_aes_cbc_key0,
6833                         .hmac_key = ms_hmac_key0,
6834                         .cipher = ms_aes_cbc_cipher0,
6835                         .digest = ms_hmac_digest0,
6836                         .iv = ms_aes_cbc_iv0
6837                 },
6838                 {
6839                         .cipher_key = ms_aes_cbc_key1,
6840                         .hmac_key = ms_hmac_key1,
6841                         .cipher = ms_aes_cbc_cipher1,
6842                         .digest = ms_hmac_digest1,
6843                         .iv = ms_aes_cbc_iv1
6844                 },
6845                 {
6846                         .cipher_key = ms_aes_cbc_key2,
6847                         .hmac_key = ms_hmac_key2,
6848                         .cipher = ms_aes_cbc_cipher2,
6849                         .digest = ms_hmac_digest2,
6850                         .iv = ms_aes_cbc_iv2
6851                 },
6852
6853         };
6854
6855         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6856
6857         sessions = rte_malloc(NULL,
6858                         (sizeof(struct rte_cryptodev_sym_session *)
6859                                         * MAX_NB_SESSIONS) + 1, 0);
6860
6861         for (i = 0; i < MB_SESSION_NUMBER; i++) {
6862                 sessions[i] = rte_cryptodev_sym_session_create(
6863                                 ts_params->session_mpool);
6864
6865                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
6866                                 sizeof(struct crypto_unittest_params));
6867
6868                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
6869                                 &ut_paramz[i].ut_params,
6870                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
6871
6872                 /* Create multiple crypto sessions*/
6873                 rte_cryptodev_sym_session_init(
6874                                 ts_params->valid_devs[0],
6875                                 sessions[i],
6876                                 &ut_paramz[i].ut_params.auth_xform,
6877                                 ts_params->session_priv_mpool);
6878
6879                 TEST_ASSERT_NOT_NULL(sessions[i],
6880                                 "Session creation failed at session number %u",
6881                                 i);
6882
6883         }
6884
6885         srand(time(NULL));
6886         for (i = 0; i < 40000; i++) {
6887
6888                 j = rand() % MB_SESSION_NUMBER;
6889
6890                 TEST_ASSERT_SUCCESS(
6891                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
6892                                         sessions[j],
6893                                         &ut_paramz[j].ut_params,
6894                                         ts_params, ut_paramz[j].cipher,
6895                                         ut_paramz[j].digest,
6896                                         ut_paramz[j].iv),
6897                         "Failed to perform decrypt on request number %u.", i);
6898
6899                 if (ut_paramz[j].ut_params.op)
6900                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
6901
6902                 /*
6903                  * free mbuf - both obuf and ibuf are usually the same,
6904                  * so check if they point at the same address is necessary,
6905                  * to avoid freeing the mbuf twice.
6906                  */
6907                 if (ut_paramz[j].ut_params.obuf) {
6908                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
6909                         if (ut_paramz[j].ut_params.ibuf
6910                                         == ut_paramz[j].ut_params.obuf)
6911                                 ut_paramz[j].ut_params.ibuf = 0;
6912                         ut_paramz[j].ut_params.obuf = 0;
6913                 }
6914                 if (ut_paramz[j].ut_params.ibuf) {
6915                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
6916                         ut_paramz[j].ut_params.ibuf = 0;
6917                 }
6918         }
6919
6920         for (i = 0; i < MB_SESSION_NUMBER; i++) {
6921                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
6922                                 sessions[i]);
6923                 rte_cryptodev_sym_session_free(sessions[i]);
6924         }
6925
6926         rte_free(sessions);
6927
6928         return TEST_SUCCESS;
6929 }
6930
6931 static int
6932 test_null_cipher_only_operation(void)
6933 {
6934         struct crypto_testsuite_params *ts_params = &testsuite_params;
6935         struct crypto_unittest_params *ut_params = &unittest_params;
6936
6937         /* Generate test mbuf data and space for digest */
6938         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
6939                         catch_22_quote, QUOTE_512_BYTES, 0);
6940
6941         /* Setup Cipher Parameters */
6942         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6943         ut_params->cipher_xform.next = NULL;
6944
6945         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
6946         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
6947
6948         ut_params->sess = rte_cryptodev_sym_session_create(
6949                         ts_params->session_mpool);
6950
6951         /* Create Crypto session*/
6952         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
6953                                 ut_params->sess,
6954                                 &ut_params->cipher_xform,
6955                                 ts_params->session_priv_mpool);
6956         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6957
6958         /* Generate Crypto op data structure */
6959         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6960                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6961         TEST_ASSERT_NOT_NULL(ut_params->op,
6962                         "Failed to allocate symmetric crypto operation struct");
6963
6964         /* Set crypto operation data parameters */
6965         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6966
6967         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6968
6969         /* set crypto operation source mbuf */
6970         sym_op->m_src = ut_params->ibuf;
6971
6972         sym_op->cipher.data.offset = 0;
6973         sym_op->cipher.data.length = QUOTE_512_BYTES;
6974
6975         /* Process crypto operation */
6976         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6977                         ut_params->op);
6978         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
6979
6980         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6981                         "crypto operation processing failed");
6982
6983         /* Validate obuf */
6984         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6985                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
6986                         catch_22_quote,
6987                         QUOTE_512_BYTES,
6988                         "Ciphertext data not as expected");
6989
6990         return TEST_SUCCESS;
6991 }
6992 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
6993                         0xab, 0xab, 0xab, 0xab,
6994                         0xab, 0xab, 0xab, 0xab,
6995                         0xab, 0xab, 0xab, 0xab};
6996 static int
6997 test_null_auth_only_operation(void)
6998 {
6999         struct crypto_testsuite_params *ts_params = &testsuite_params;
7000         struct crypto_unittest_params *ut_params = &unittest_params;
7001         uint8_t *digest;
7002
7003         /* Generate test mbuf data and space for digest */
7004         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
7005                         catch_22_quote, QUOTE_512_BYTES, 0);
7006
7007         /* create a pointer for digest, but don't expect anything to be written
7008          * here in a NULL auth algo so no mbuf append done.
7009          */
7010         digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
7011                         QUOTE_512_BYTES);
7012         /* prefill the memory pointed to by digest */
7013         memcpy(digest, orig_data, sizeof(orig_data));
7014
7015         /* Setup HMAC Parameters */
7016         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7017         ut_params->auth_xform.next = NULL;
7018
7019         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
7020         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
7021
7022         ut_params->sess = rte_cryptodev_sym_session_create(
7023                         ts_params->session_mpool);
7024
7025         /* Create Crypto session*/
7026         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
7027                         ut_params->sess, &ut_params->auth_xform,
7028                         ts_params->session_priv_mpool);
7029         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7030
7031         /* Generate Crypto op data structure */
7032         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7033                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7034         TEST_ASSERT_NOT_NULL(ut_params->op,
7035                         "Failed to allocate symmetric crypto operation struct");
7036
7037         /* Set crypto operation data parameters */
7038         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7039
7040         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7041
7042         sym_op->m_src = ut_params->ibuf;
7043
7044         sym_op->auth.data.offset = 0;
7045         sym_op->auth.data.length = QUOTE_512_BYTES;
7046         sym_op->auth.digest.data = digest;
7047         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
7048                         QUOTE_512_BYTES);
7049
7050         /* Process crypto operation */
7051         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7052                         ut_params->op);
7053         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
7054
7055         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7056                         "crypto operation processing failed");
7057         /* Make sure memory pointed to by digest hasn't been overwritten */
7058         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7059                         orig_data,
7060                         digest,
7061                         sizeof(orig_data),
7062                         "Memory at digest ptr overwritten unexpectedly");
7063
7064         return TEST_SUCCESS;
7065 }
7066
7067
7068 static int
7069 test_null_cipher_auth_operation(void)
7070 {
7071         struct crypto_testsuite_params *ts_params = &testsuite_params;
7072         struct crypto_unittest_params *ut_params = &unittest_params;
7073         uint8_t *digest;
7074
7075         /* Generate test mbuf data and space for digest */
7076         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
7077                         catch_22_quote, QUOTE_512_BYTES, 0);
7078
7079         /* create a pointer for digest, but don't expect anything to be written
7080          * here in a NULL auth algo so no mbuf append done.
7081          */
7082         digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
7083                         QUOTE_512_BYTES);
7084         /* prefill the memory pointed to by digest */
7085         memcpy(digest, orig_data, sizeof(orig_data));
7086
7087         /* Setup Cipher Parameters */
7088         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7089         ut_params->cipher_xform.next = &ut_params->auth_xform;
7090
7091         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
7092         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
7093
7094         /* Setup HMAC Parameters */
7095         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7096         ut_params->auth_xform.next = NULL;
7097
7098         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
7099         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
7100
7101         ut_params->sess = rte_cryptodev_sym_session_create(
7102                         ts_params->session_mpool);
7103
7104         /* Create Crypto session*/
7105         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
7106                         ut_params->sess, &ut_params->cipher_xform,
7107                         ts_params->session_priv_mpool);
7108         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7109
7110         /* Generate Crypto op data structure */
7111         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7112                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7113         TEST_ASSERT_NOT_NULL(ut_params->op,
7114                         "Failed to allocate symmetric crypto operation struct");
7115
7116         /* Set crypto operation data parameters */
7117         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7118
7119         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7120
7121         sym_op->m_src = ut_params->ibuf;
7122
7123         sym_op->cipher.data.offset = 0;
7124         sym_op->cipher.data.length = QUOTE_512_BYTES;
7125
7126         sym_op->auth.data.offset = 0;
7127         sym_op->auth.data.length = QUOTE_512_BYTES;
7128         sym_op->auth.digest.data = digest;
7129         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
7130                         QUOTE_512_BYTES);
7131
7132         /* Process crypto operation */
7133         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7134                         ut_params->op);
7135         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
7136
7137         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7138                         "crypto operation processing failed");
7139
7140         /* Validate obuf */
7141         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7142                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
7143                         catch_22_quote,
7144                         QUOTE_512_BYTES,
7145                         "Ciphertext data not as expected");
7146         /* Make sure memory pointed to by digest hasn't been overwritten */
7147         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7148                         orig_data,
7149                         digest,
7150                         sizeof(orig_data),
7151                         "Memory at digest ptr overwritten unexpectedly");
7152
7153         return TEST_SUCCESS;
7154 }
7155
7156 static int
7157 test_null_auth_cipher_operation(void)
7158 {
7159         struct crypto_testsuite_params *ts_params = &testsuite_params;
7160         struct crypto_unittest_params *ut_params = &unittest_params;
7161         uint8_t *digest;
7162
7163         /* Generate test mbuf data */
7164         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
7165                         catch_22_quote, QUOTE_512_BYTES, 0);
7166
7167         /* create a pointer for digest, but don't expect anything to be written
7168          * here in a NULL auth algo so no mbuf append done.
7169          */
7170         digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
7171                                 QUOTE_512_BYTES);
7172         /* prefill the memory pointed to by digest */
7173         memcpy(digest, orig_data, sizeof(orig_data));
7174
7175         /* Setup Cipher Parameters */
7176         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7177         ut_params->cipher_xform.next = NULL;
7178
7179         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
7180         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
7181
7182         /* Setup HMAC Parameters */
7183         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7184         ut_params->auth_xform.next = &ut_params->cipher_xform;
7185
7186         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
7187         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
7188
7189         ut_params->sess = rte_cryptodev_sym_session_create(
7190                         ts_params->session_mpool);
7191
7192         /* Create Crypto session*/
7193         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
7194                         ut_params->sess, &ut_params->cipher_xform,
7195                         ts_params->session_priv_mpool);
7196         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7197
7198         /* Generate Crypto op data structure */
7199         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7200                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7201         TEST_ASSERT_NOT_NULL(ut_params->op,
7202                         "Failed to allocate symmetric crypto operation struct");
7203
7204         /* Set crypto operation data parameters */
7205         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7206
7207         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7208
7209         sym_op->m_src = ut_params->ibuf;
7210
7211         sym_op->cipher.data.offset = 0;
7212         sym_op->cipher.data.length = QUOTE_512_BYTES;
7213
7214         sym_op->auth.data.offset = 0;
7215         sym_op->auth.data.length = QUOTE_512_BYTES;
7216         sym_op->auth.digest.data = digest;
7217         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
7218                                         QUOTE_512_BYTES);
7219
7220         /* Process crypto operation */
7221         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7222                         ut_params->op);
7223         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
7224
7225         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7226                         "crypto operation processing failed");
7227
7228         /* Validate obuf */
7229         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7230                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
7231                         catch_22_quote,
7232                         QUOTE_512_BYTES,
7233                         "Ciphertext data not as expected");
7234         /* Make sure memory pointed to by digest hasn't been overwritten */
7235         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7236                         orig_data,
7237                         digest,
7238                         sizeof(orig_data),
7239                         "Memory at digest ptr overwritten unexpectedly");
7240
7241         return TEST_SUCCESS;
7242 }
7243
7244
7245 static int
7246 test_null_invalid_operation(void)
7247 {
7248         struct crypto_testsuite_params *ts_params = &testsuite_params;
7249         struct crypto_unittest_params *ut_params = &unittest_params;
7250         int ret;
7251
7252         /* Setup Cipher Parameters */
7253         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7254         ut_params->cipher_xform.next = NULL;
7255
7256         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
7257         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
7258
7259         ut_params->sess = rte_cryptodev_sym_session_create(
7260                         ts_params->session_mpool);
7261
7262         /* Create Crypto session*/
7263         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
7264                         ut_params->sess, &ut_params->cipher_xform,
7265                         ts_params->session_priv_mpool);
7266         TEST_ASSERT(ret < 0,
7267                         "Session creation succeeded unexpectedly");
7268
7269
7270         /* Setup HMAC Parameters */
7271         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7272         ut_params->auth_xform.next = NULL;
7273
7274         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
7275         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
7276
7277         ut_params->sess = rte_cryptodev_sym_session_create(
7278                         ts_params->session_mpool);
7279
7280         /* Create Crypto session*/
7281         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
7282                         ut_params->sess, &ut_params->auth_xform,
7283                         ts_params->session_priv_mpool);
7284         TEST_ASSERT(ret < 0,
7285                         "Session creation succeeded unexpectedly");
7286
7287         return TEST_SUCCESS;
7288 }
7289
7290
7291 #define NULL_BURST_LENGTH (32)
7292
7293 static int
7294 test_null_burst_operation(void)
7295 {
7296         struct crypto_testsuite_params *ts_params = &testsuite_params;
7297         struct crypto_unittest_params *ut_params = &unittest_params;
7298
7299         unsigned i, burst_len = NULL_BURST_LENGTH;
7300
7301         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
7302         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
7303
7304         /* Setup Cipher Parameters */
7305         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7306         ut_params->cipher_xform.next = &ut_params->auth_xform;
7307
7308         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
7309         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
7310
7311         /* Setup HMAC Parameters */
7312         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7313         ut_params->auth_xform.next = NULL;
7314
7315         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
7316         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
7317
7318         ut_params->sess = rte_cryptodev_sym_session_create(
7319                         ts_params->session_mpool);
7320
7321         /* Create Crypto session*/
7322         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
7323                         ut_params->sess, &ut_params->cipher_xform,
7324                         ts_params->session_priv_mpool);
7325         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7326
7327         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
7328                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
7329                         burst_len, "failed to generate burst of crypto ops");
7330
7331         /* Generate an operation for each mbuf in burst */
7332         for (i = 0; i < burst_len; i++) {
7333                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7334
7335                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
7336
7337                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
7338                                 sizeof(unsigned));
7339                 *data = i;
7340
7341                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
7342
7343                 burst[i]->sym->m_src = m;
7344         }
7345
7346         /* Process crypto operation */
7347         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
7348                         0, burst, burst_len),
7349                         burst_len,
7350                         "Error enqueuing burst");
7351
7352         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
7353                         0, burst_dequeued, burst_len),
7354                         burst_len,
7355                         "Error dequeuing burst");
7356
7357
7358         for (i = 0; i < burst_len; i++) {
7359                 TEST_ASSERT_EQUAL(
7360                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
7361                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
7362                                         uint32_t *),
7363                         "data not as expected");
7364
7365                 rte_pktmbuf_free(burst[i]->sym->m_src);
7366                 rte_crypto_op_free(burst[i]);
7367         }
7368
7369         return TEST_SUCCESS;
7370 }
7371
7372 static void
7373 generate_gmac_large_plaintext(uint8_t *data)
7374 {
7375         uint16_t i;
7376
7377         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
7378                 memcpy(&data[i], &data[0], 32);
7379 }
7380
7381 static int
7382 create_gmac_operation(enum rte_crypto_auth_operation op,
7383                 const struct gmac_test_data *tdata)
7384 {
7385         struct crypto_testsuite_params *ts_params = &testsuite_params;
7386         struct crypto_unittest_params *ut_params = &unittest_params;
7387         struct rte_crypto_sym_op *sym_op;
7388
7389         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7390
7391         /* Generate Crypto op data structure */
7392         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7393                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7394         TEST_ASSERT_NOT_NULL(ut_params->op,
7395                         "Failed to allocate symmetric crypto operation struct");
7396
7397         sym_op = ut_params->op->sym;
7398
7399         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7400                         ut_params->ibuf, tdata->gmac_tag.len);
7401         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7402                         "no room to append digest");
7403
7404         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
7405                         ut_params->ibuf, plaintext_pad_len);
7406
7407         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
7408                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
7409                                 tdata->gmac_tag.len);
7410                 debug_hexdump(stdout, "digest:",
7411                                 sym_op->auth.digest.data,
7412                                 tdata->gmac_tag.len);
7413         }
7414
7415         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7416                         uint8_t *, IV_OFFSET);
7417
7418         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
7419
7420         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
7421
7422         sym_op->cipher.data.length = 0;
7423         sym_op->cipher.data.offset = 0;
7424
7425         sym_op->auth.data.offset = 0;
7426         sym_op->auth.data.length = tdata->plaintext.len;
7427
7428         return 0;
7429 }
7430
7431 static int create_gmac_session(uint8_t dev_id,
7432                 const struct gmac_test_data *tdata,
7433                 enum rte_crypto_auth_operation auth_op)
7434 {
7435         uint8_t auth_key[tdata->key.len];
7436
7437         struct crypto_testsuite_params *ts_params = &testsuite_params;
7438         struct crypto_unittest_params *ut_params = &unittest_params;
7439
7440         memcpy(auth_key, tdata->key.data, tdata->key.len);
7441
7442         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7443         ut_params->auth_xform.next = NULL;
7444
7445         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
7446         ut_params->auth_xform.auth.op = auth_op;
7447         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
7448         ut_params->auth_xform.auth.key.length = tdata->key.len;
7449         ut_params->auth_xform.auth.key.data = auth_key;
7450         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
7451         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
7452
7453
7454         ut_params->sess = rte_cryptodev_sym_session_create(
7455                         ts_params->session_mpool);
7456
7457         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7458                         &ut_params->auth_xform,
7459                         ts_params->session_priv_mpool);
7460
7461         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7462
7463         return 0;
7464 }
7465
7466 static int
7467 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
7468 {
7469         struct crypto_testsuite_params *ts_params = &testsuite_params;
7470         struct crypto_unittest_params *ut_params = &unittest_params;
7471
7472         int retval;
7473
7474         uint8_t *auth_tag, *plaintext;
7475         uint16_t plaintext_pad_len;
7476
7477         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
7478                               "No GMAC length in the source data");
7479
7480         retval = create_gmac_session(ts_params->valid_devs[0],
7481                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
7482
7483         if (retval < 0)
7484                 return retval;
7485
7486         if (tdata->plaintext.len > MBUF_SIZE)
7487                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
7488         else
7489                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7490         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7491                         "Failed to allocate input buffer in mempool");
7492
7493         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7494                         rte_pktmbuf_tailroom(ut_params->ibuf));
7495
7496         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7497         /*
7498          * Runtime generate the large plain text instead of use hard code
7499          * plain text vector. It is done to avoid create huge source file
7500          * with the test vector.
7501          */
7502         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
7503                 generate_gmac_large_plaintext(tdata->plaintext.data);
7504
7505         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7506                                 plaintext_pad_len);
7507         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7508
7509         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
7510         debug_hexdump(stdout, "plaintext:", plaintext,
7511                         tdata->plaintext.len);
7512
7513         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
7514                         tdata);
7515
7516         if (retval < 0)
7517                 return retval;
7518
7519         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7520
7521         ut_params->op->sym->m_src = ut_params->ibuf;
7522
7523         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7524                         ut_params->op), "failed to process sym crypto op");
7525
7526         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7527                         "crypto op processing failed");
7528
7529         if (ut_params->op->sym->m_dst) {
7530                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7531                                 uint8_t *, plaintext_pad_len);
7532         } else {
7533                 auth_tag = plaintext + plaintext_pad_len;
7534         }
7535
7536         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
7537
7538         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7539                         auth_tag,
7540                         tdata->gmac_tag.data,
7541                         tdata->gmac_tag.len,
7542                         "GMAC Generated auth tag not as expected");
7543
7544         return 0;
7545 }
7546
7547 static int
7548 test_AES_GMAC_authentication_test_case_1(void)
7549 {
7550         return test_AES_GMAC_authentication(&gmac_test_case_1);
7551 }
7552
7553 static int
7554 test_AES_GMAC_authentication_test_case_2(void)
7555 {
7556         return test_AES_GMAC_authentication(&gmac_test_case_2);
7557 }
7558
7559 static int
7560 test_AES_GMAC_authentication_test_case_3(void)
7561 {
7562         return test_AES_GMAC_authentication(&gmac_test_case_3);
7563 }
7564
7565 static int
7566 test_AES_GMAC_authentication_test_case_4(void)
7567 {
7568         return test_AES_GMAC_authentication(&gmac_test_case_4);
7569 }
7570
7571 static int
7572 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
7573 {
7574         struct crypto_testsuite_params *ts_params = &testsuite_params;
7575         struct crypto_unittest_params *ut_params = &unittest_params;
7576         int retval;
7577         uint32_t plaintext_pad_len;
7578         uint8_t *plaintext;
7579
7580         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
7581                               "No GMAC length in the source data");
7582
7583         retval = create_gmac_session(ts_params->valid_devs[0],
7584                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
7585
7586         if (retval < 0)
7587                 return retval;
7588
7589         if (tdata->plaintext.len > MBUF_SIZE)
7590                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
7591         else
7592                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7593         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7594                         "Failed to allocate input buffer in mempool");
7595
7596         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7597                         rte_pktmbuf_tailroom(ut_params->ibuf));
7598
7599         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7600
7601         /*
7602          * Runtime generate the large plain text instead of use hard code
7603          * plain text vector. It is done to avoid create huge source file
7604          * with the test vector.
7605          */
7606         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
7607                 generate_gmac_large_plaintext(tdata->plaintext.data);
7608
7609         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7610                                 plaintext_pad_len);
7611         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7612
7613         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
7614         debug_hexdump(stdout, "plaintext:", plaintext,
7615                         tdata->plaintext.len);
7616
7617         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
7618                         tdata);
7619
7620         if (retval < 0)
7621                 return retval;
7622
7623         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7624
7625         ut_params->op->sym->m_src = ut_params->ibuf;
7626
7627         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7628                         ut_params->op), "failed to process sym crypto op");
7629
7630         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7631                         "crypto op processing failed");
7632
7633         return 0;
7634
7635 }
7636
7637 static int
7638 test_AES_GMAC_authentication_verify_test_case_1(void)
7639 {
7640         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
7641 }
7642
7643 static int
7644 test_AES_GMAC_authentication_verify_test_case_2(void)
7645 {
7646         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
7647 }
7648
7649 static int
7650 test_AES_GMAC_authentication_verify_test_case_3(void)
7651 {
7652         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
7653 }
7654
7655 static int
7656 test_AES_GMAC_authentication_verify_test_case_4(void)
7657 {
7658         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
7659 }
7660
7661 struct test_crypto_vector {
7662         enum rte_crypto_cipher_algorithm crypto_algo;
7663
7664         struct {
7665                 uint8_t data[64];
7666                 unsigned int len;
7667         } cipher_key;
7668
7669         struct {
7670                 uint8_t data[64];
7671                 unsigned int len;
7672         } iv;
7673
7674         struct {
7675                 const uint8_t *data;
7676                 unsigned int len;
7677         } plaintext;
7678
7679         struct {
7680                 const uint8_t *data;
7681                 unsigned int len;
7682         } ciphertext;
7683
7684         enum rte_crypto_auth_algorithm auth_algo;
7685
7686         struct {
7687                 uint8_t data[128];
7688                 unsigned int len;
7689         } auth_key;
7690
7691         struct {
7692                 const uint8_t *data;
7693                 unsigned int len;
7694         } aad;
7695
7696         struct {
7697                 uint8_t data[128];
7698                 unsigned int len;
7699         } digest;
7700 };
7701
7702 static const struct test_crypto_vector
7703 hmac_sha1_test_crypto_vector = {
7704         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
7705         .plaintext = {
7706                 .data = plaintext_hash,
7707                 .len = 512
7708         },
7709         .auth_key = {
7710                 .data = {
7711                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
7712                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
7713                         0xDE, 0xF4, 0xDE, 0xAD
7714                 },
7715                 .len = 20
7716         },
7717         .digest = {
7718                 .data = {
7719                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
7720                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
7721                         0x3F, 0x91, 0x64, 0x59
7722                 },
7723                 .len = 20
7724         }
7725 };
7726
7727 static const struct test_crypto_vector
7728 aes128_gmac_test_vector = {
7729         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
7730         .plaintext = {
7731                 .data = plaintext_hash,
7732                 .len = 512
7733         },
7734         .iv = {
7735                 .data = {
7736                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
7737                         0x08, 0x09, 0x0A, 0x0B
7738                 },
7739                 .len = 12
7740         },
7741         .auth_key = {
7742                 .data = {
7743                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
7744                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
7745                 },
7746                 .len = 16
7747         },
7748         .digest = {
7749                 .data = {
7750                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
7751                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
7752                 },
7753                 .len = 16
7754         }
7755 };
7756
7757 static const struct test_crypto_vector
7758 aes128cbc_hmac_sha1_test_vector = {
7759         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
7760         .cipher_key = {
7761                 .data = {
7762                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
7763                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
7764                 },
7765                 .len = 16
7766         },
7767         .iv = {
7768                 .data = {
7769                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
7770                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
7771                 },
7772                 .len = 16
7773         },
7774         .plaintext = {
7775                 .data = plaintext_hash,
7776                 .len = 512
7777         },
7778         .ciphertext = {
7779                 .data = ciphertext512_aes128cbc,
7780                 .len = 512
7781         },
7782         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
7783         .auth_key = {
7784                 .data = {
7785                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
7786                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
7787                         0xDE, 0xF4, 0xDE, 0xAD
7788                 },
7789                 .len = 20
7790         },
7791         .digest = {
7792                 .data = {
7793                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
7794                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
7795                         0x18, 0x8C, 0x1D, 0x32
7796                 },
7797                 .len = 20
7798         }
7799 };
7800
7801 static void
7802 data_corruption(uint8_t *data)
7803 {
7804         data[0] += 1;
7805 }
7806
7807 static void
7808 tag_corruption(uint8_t *data, unsigned int tag_offset)
7809 {
7810         data[tag_offset] += 1;
7811 }
7812
7813 static int
7814 create_auth_session(struct crypto_unittest_params *ut_params,
7815                 uint8_t dev_id,
7816                 const struct test_crypto_vector *reference,
7817                 enum rte_crypto_auth_operation auth_op)
7818 {
7819         struct crypto_testsuite_params *ts_params = &testsuite_params;
7820         uint8_t auth_key[reference->auth_key.len + 1];
7821
7822         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
7823
7824         /* Setup Authentication Parameters */
7825         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7826         ut_params->auth_xform.auth.op = auth_op;
7827         ut_params->auth_xform.next = NULL;
7828         ut_params->auth_xform.auth.algo = reference->auth_algo;
7829         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
7830         ut_params->auth_xform.auth.key.data = auth_key;
7831         ut_params->auth_xform.auth.digest_length = reference->digest.len;
7832
7833         /* Create Crypto session*/
7834         ut_params->sess = rte_cryptodev_sym_session_create(
7835                         ts_params->session_mpool);
7836
7837         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7838                                 &ut_params->auth_xform,
7839                                 ts_params->session_priv_mpool);
7840
7841         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7842
7843         return 0;
7844 }
7845
7846 static int
7847 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
7848                 uint8_t dev_id,
7849                 const struct test_crypto_vector *reference,
7850                 enum rte_crypto_auth_operation auth_op,
7851                 enum rte_crypto_cipher_operation cipher_op)
7852 {
7853         struct crypto_testsuite_params *ts_params = &testsuite_params;
7854         uint8_t cipher_key[reference->cipher_key.len + 1];
7855         uint8_t auth_key[reference->auth_key.len + 1];
7856
7857         memcpy(cipher_key, reference->cipher_key.data,
7858                         reference->cipher_key.len);
7859         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
7860
7861         /* Setup Authentication Parameters */
7862         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7863         ut_params->auth_xform.auth.op = auth_op;
7864         ut_params->auth_xform.auth.algo = reference->auth_algo;
7865         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
7866         ut_params->auth_xform.auth.key.data = auth_key;
7867         ut_params->auth_xform.auth.digest_length = reference->digest.len;
7868
7869         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
7870                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
7871                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
7872         } else {
7873                 ut_params->auth_xform.next = &ut_params->cipher_xform;
7874
7875                 /* Setup Cipher Parameters */
7876                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7877                 ut_params->cipher_xform.next = NULL;
7878                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
7879                 ut_params->cipher_xform.cipher.op = cipher_op;
7880                 ut_params->cipher_xform.cipher.key.data = cipher_key;
7881                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
7882                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
7883                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
7884         }
7885
7886         /* Create Crypto session*/
7887         ut_params->sess = rte_cryptodev_sym_session_create(
7888                         ts_params->session_mpool);
7889
7890         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7891                                 &ut_params->auth_xform,
7892                                 ts_params->session_priv_mpool);
7893
7894         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7895
7896         return 0;
7897 }
7898
7899 static int
7900 create_auth_operation(struct crypto_testsuite_params *ts_params,
7901                 struct crypto_unittest_params *ut_params,
7902                 const struct test_crypto_vector *reference,
7903                 unsigned int auth_generate)
7904 {
7905         /* Generate Crypto op data structure */
7906         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7907                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7908         TEST_ASSERT_NOT_NULL(ut_params->op,
7909                         "Failed to allocate pktmbuf offload");
7910
7911         /* Set crypto operation data parameters */
7912         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7913
7914         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7915
7916         /* set crypto operation source mbuf */
7917         sym_op->m_src = ut_params->ibuf;
7918
7919         /* digest */
7920         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7921                         ut_params->ibuf, reference->digest.len);
7922
7923         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7924                         "no room to append auth tag");
7925
7926         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
7927                         ut_params->ibuf, reference->plaintext.len);
7928
7929         if (auth_generate)
7930                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7931         else
7932                 memcpy(sym_op->auth.digest.data,
7933                                 reference->digest.data,
7934                                 reference->digest.len);
7935
7936         debug_hexdump(stdout, "digest:",
7937                         sym_op->auth.digest.data,
7938                         reference->digest.len);
7939
7940         sym_op->auth.data.length = reference->plaintext.len;
7941         sym_op->auth.data.offset = 0;
7942
7943         return 0;
7944 }
7945
7946 static int
7947 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
7948                 struct crypto_unittest_params *ut_params,
7949                 const struct test_crypto_vector *reference,
7950                 unsigned int auth_generate)
7951 {
7952         /* Generate Crypto op data structure */
7953         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7954                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7955         TEST_ASSERT_NOT_NULL(ut_params->op,
7956                         "Failed to allocate pktmbuf offload");
7957
7958         /* Set crypto operation data parameters */
7959         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7960
7961         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7962
7963         /* set crypto operation source mbuf */
7964         sym_op->m_src = ut_params->ibuf;
7965
7966         /* digest */
7967         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
7968                         ut_params->ibuf, reference->digest.len);
7969
7970         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
7971                         "no room to append auth tag");
7972
7973         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
7974                         ut_params->ibuf, reference->ciphertext.len);
7975
7976         if (auth_generate)
7977                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
7978         else
7979                 memcpy(sym_op->auth.digest.data,
7980                                 reference->digest.data,
7981                                 reference->digest.len);
7982
7983         debug_hexdump(stdout, "digest:",
7984                         sym_op->auth.digest.data,
7985                         reference->digest.len);
7986
7987         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
7988                         reference->iv.data, reference->iv.len);
7989
7990         sym_op->cipher.data.length = 0;
7991         sym_op->cipher.data.offset = 0;
7992
7993         sym_op->auth.data.length = reference->plaintext.len;
7994         sym_op->auth.data.offset = 0;
7995
7996         return 0;
7997 }
7998
7999 static int
8000 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
8001                 struct crypto_unittest_params *ut_params,
8002                 const struct test_crypto_vector *reference,
8003                 unsigned int auth_generate)
8004 {
8005         /* Generate Crypto op data structure */
8006         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8007                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8008         TEST_ASSERT_NOT_NULL(ut_params->op,
8009                         "Failed to allocate pktmbuf offload");
8010
8011         /* Set crypto operation data parameters */
8012         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8013
8014         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8015
8016         /* set crypto operation source mbuf */
8017         sym_op->m_src = ut_params->ibuf;
8018
8019         /* digest */
8020         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
8021                         ut_params->ibuf, reference->digest.len);
8022
8023         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
8024                         "no room to append auth tag");
8025
8026         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
8027                         ut_params->ibuf, reference->ciphertext.len);
8028
8029         if (auth_generate)
8030                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
8031         else
8032                 memcpy(sym_op->auth.digest.data,
8033                                 reference->digest.data,
8034                                 reference->digest.len);
8035
8036         debug_hexdump(stdout, "digest:",
8037                         sym_op->auth.digest.data,
8038                         reference->digest.len);
8039
8040         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
8041                         reference->iv.data, reference->iv.len);
8042
8043         sym_op->cipher.data.length = reference->ciphertext.len;
8044         sym_op->cipher.data.offset = 0;
8045
8046         sym_op->auth.data.length = reference->ciphertext.len;
8047         sym_op->auth.data.offset = 0;
8048
8049         return 0;
8050 }
8051
8052 static int
8053 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
8054                 struct crypto_unittest_params *ut_params,
8055                 const struct test_crypto_vector *reference)
8056 {
8057         return create_auth_operation(ts_params, ut_params, reference, 0);
8058 }
8059
8060 static int
8061 create_auth_verify_GMAC_operation(
8062                 struct crypto_testsuite_params *ts_params,
8063                 struct crypto_unittest_params *ut_params,
8064                 const struct test_crypto_vector *reference)
8065 {
8066         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
8067 }
8068
8069 static int
8070 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
8071                 struct crypto_unittest_params *ut_params,
8072                 const struct test_crypto_vector *reference)
8073 {
8074         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
8075 }
8076
8077 static int
8078 test_authentication_verify_fail_when_data_corruption(
8079                 struct crypto_testsuite_params *ts_params,
8080                 struct crypto_unittest_params *ut_params,
8081                 const struct test_crypto_vector *reference,
8082                 unsigned int data_corrupted)
8083 {
8084         int retval;
8085
8086         uint8_t *plaintext;
8087
8088         /* Create session */
8089         retval = create_auth_session(ut_params,
8090                         ts_params->valid_devs[0],
8091                         reference,
8092                         RTE_CRYPTO_AUTH_OP_VERIFY);
8093         if (retval < 0)
8094                 return retval;
8095
8096         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8097         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
8098                         "Failed to allocate input buffer in mempool");
8099
8100         /* clear mbuf payload */
8101         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8102                         rte_pktmbuf_tailroom(ut_params->ibuf));
8103
8104         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8105                         reference->plaintext.len);
8106         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8107         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
8108
8109         debug_hexdump(stdout, "plaintext:", plaintext,
8110                 reference->plaintext.len);
8111
8112         /* Create operation */
8113         retval = create_auth_verify_operation(ts_params, ut_params, reference);
8114
8115         if (retval < 0)
8116                 return retval;
8117
8118         if (data_corrupted)
8119                 data_corruption(plaintext);
8120         else
8121                 tag_corruption(plaintext, reference->plaintext.len);
8122
8123         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8124                         ut_params->op);
8125         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
8126         TEST_ASSERT_EQUAL(ut_params->op->status,
8127                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
8128                         "authentication not failed");
8129
8130         ut_params->obuf = ut_params->op->sym->m_src;
8131         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
8132
8133         return 0;
8134 }
8135
8136 static int
8137 test_authentication_verify_GMAC_fail_when_corruption(
8138                 struct crypto_testsuite_params *ts_params,
8139                 struct crypto_unittest_params *ut_params,
8140                 const struct test_crypto_vector *reference,
8141                 unsigned int data_corrupted)
8142 {
8143         int retval;
8144         uint8_t *plaintext;
8145
8146         /* Create session */
8147         retval = create_auth_cipher_session(ut_params,
8148                         ts_params->valid_devs[0],
8149                         reference,
8150                         RTE_CRYPTO_AUTH_OP_VERIFY,
8151                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
8152         if (retval < 0)
8153                 return retval;
8154
8155         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8156         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
8157                         "Failed to allocate input buffer in mempool");
8158
8159         /* clear mbuf payload */
8160         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8161                         rte_pktmbuf_tailroom(ut_params->ibuf));
8162
8163         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8164                         reference->plaintext.len);
8165         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8166         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
8167
8168         debug_hexdump(stdout, "plaintext:", plaintext,
8169                 reference->plaintext.len);
8170
8171         /* Create operation */
8172         retval = create_auth_verify_GMAC_operation(ts_params,
8173                         ut_params,
8174                         reference);
8175
8176         if (retval < 0)
8177                 return retval;
8178
8179         if (data_corrupted)
8180                 data_corruption(plaintext);
8181         else
8182                 tag_corruption(plaintext, reference->aad.len);
8183
8184         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8185                         ut_params->op);
8186         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
8187         TEST_ASSERT_EQUAL(ut_params->op->status,
8188                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
8189                         "authentication not failed");
8190
8191         ut_params->obuf = ut_params->op->sym->m_src;
8192         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
8193
8194         return 0;
8195 }
8196
8197 static int
8198 test_authenticated_decryption_fail_when_corruption(
8199                 struct crypto_testsuite_params *ts_params,
8200                 struct crypto_unittest_params *ut_params,
8201                 const struct test_crypto_vector *reference,
8202                 unsigned int data_corrupted)
8203 {
8204         int retval;
8205
8206         uint8_t *ciphertext;
8207
8208         /* Create session */
8209         retval = create_auth_cipher_session(ut_params,
8210                         ts_params->valid_devs[0],
8211                         reference,
8212                         RTE_CRYPTO_AUTH_OP_VERIFY,
8213                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
8214         if (retval < 0)
8215                 return retval;
8216
8217         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8218         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
8219                         "Failed to allocate input buffer in mempool");
8220
8221         /* clear mbuf payload */
8222         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8223                         rte_pktmbuf_tailroom(ut_params->ibuf));
8224
8225         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8226                         reference->ciphertext.len);
8227         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
8228         memcpy(ciphertext, reference->ciphertext.data,
8229                         reference->ciphertext.len);
8230
8231         /* Create operation */
8232         retval = create_cipher_auth_verify_operation(ts_params,
8233                         ut_params,
8234                         reference);
8235
8236         if (retval < 0)
8237                 return retval;
8238
8239         if (data_corrupted)
8240                 data_corruption(ciphertext);
8241         else
8242                 tag_corruption(ciphertext, reference->ciphertext.len);
8243
8244         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8245                         ut_params->op);
8246
8247         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
8248         TEST_ASSERT_EQUAL(ut_params->op->status,
8249                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
8250                         "authentication not failed");
8251
8252         ut_params->obuf = ut_params->op->sym->m_src;
8253         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
8254
8255         return 0;
8256 }
8257
8258 static int
8259 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
8260                 const struct aead_test_data *tdata,
8261                 void *digest_mem, uint64_t digest_phys)
8262 {
8263         struct crypto_testsuite_params *ts_params = &testsuite_params;
8264         struct crypto_unittest_params *ut_params = &unittest_params;
8265
8266         const unsigned int auth_tag_len = tdata->auth_tag.len;
8267         const unsigned int iv_len = tdata->iv.len;
8268         unsigned int aad_len = tdata->aad.len;
8269
8270         /* Generate Crypto op data structure */
8271         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8272                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8273         TEST_ASSERT_NOT_NULL(ut_params->op,
8274                 "Failed to allocate symmetric crypto operation struct");
8275
8276         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8277
8278         sym_op->aead.digest.data = digest_mem;
8279
8280         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8281                         "no room to append digest");
8282
8283         sym_op->aead.digest.phys_addr = digest_phys;
8284
8285         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
8286                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8287                                 auth_tag_len);
8288                 debug_hexdump(stdout, "digest:",
8289                                 sym_op->aead.digest.data,
8290                                 auth_tag_len);
8291         }
8292
8293         /* Append aad data */
8294         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
8295                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8296                                 uint8_t *, IV_OFFSET);
8297
8298                 /* Copy IV 1 byte after the IV pointer, according to the API */
8299                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
8300
8301                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
8302
8303                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
8304                                 ut_params->ibuf, aad_len);
8305                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8306                                 "no room to prepend aad");
8307                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
8308                                 ut_params->ibuf);
8309
8310                 memset(sym_op->aead.aad.data, 0, aad_len);
8311                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
8312                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
8313
8314                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
8315                 debug_hexdump(stdout, "aad:",
8316                                 sym_op->aead.aad.data, aad_len);
8317         } else {
8318                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8319                                 uint8_t *, IV_OFFSET);
8320
8321                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
8322
8323                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
8324                                 ut_params->ibuf, aad_len);
8325                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8326                                 "no room to prepend aad");
8327                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
8328                                 ut_params->ibuf);
8329
8330                 memset(sym_op->aead.aad.data, 0, aad_len);
8331                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
8332
8333                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
8334                 debug_hexdump(stdout, "aad:",
8335                                 sym_op->aead.aad.data, aad_len);
8336         }
8337
8338         sym_op->aead.data.length = tdata->plaintext.len;
8339         sym_op->aead.data.offset = aad_len;
8340
8341         return 0;
8342 }
8343
8344 #define SGL_MAX_NO      16
8345
8346 static int
8347 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
8348                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
8349 {
8350         struct crypto_testsuite_params *ts_params = &testsuite_params;
8351         struct crypto_unittest_params *ut_params = &unittest_params;
8352         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
8353         int retval;
8354         int to_trn = 0;
8355         int to_trn_tbl[SGL_MAX_NO];
8356         int segs = 1;
8357         unsigned int trn_data = 0;
8358         uint8_t *plaintext, *ciphertext, *auth_tag;
8359
8360         if (fragsz > tdata->plaintext.len)
8361                 fragsz = tdata->plaintext.len;
8362
8363         uint16_t plaintext_len = fragsz;
8364         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8365
8366         if (fragsz_oop > tdata->plaintext.len)
8367                 frag_size_oop = tdata->plaintext.len;
8368
8369         int ecx = 0;
8370         void *digest_mem = NULL;
8371
8372         uint32_t prepend_len = tdata->aad.len;
8373
8374         if (tdata->plaintext.len % fragsz != 0) {
8375                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
8376                         return 1;
8377         }       else {
8378                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
8379                         return 1;
8380         }
8381
8382         /*
8383          * For out-op-place we need to alloc another mbuf
8384          */
8385         if (oop) {
8386                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8387                 rte_pktmbuf_append(ut_params->obuf,
8388                                 frag_size_oop + prepend_len);
8389                 buf_oop = ut_params->obuf;
8390         }
8391
8392         /* Create AEAD session */
8393         retval = create_aead_session(ts_params->valid_devs[0],
8394                         tdata->algo,
8395                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8396                         tdata->key.data, tdata->key.len,
8397                         tdata->aad.len, tdata->auth_tag.len,
8398                         tdata->iv.len);
8399         if (retval < 0)
8400                 return retval;
8401
8402         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8403
8404         /* clear mbuf payload */
8405         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8406                         rte_pktmbuf_tailroom(ut_params->ibuf));
8407
8408         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8409                         plaintext_len);
8410
8411         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
8412
8413         trn_data += plaintext_len;
8414
8415         buf = ut_params->ibuf;
8416
8417         /*
8418          * Loop until no more fragments
8419          */
8420
8421         while (trn_data < tdata->plaintext.len) {
8422                 ++segs;
8423                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
8424                                 (tdata->plaintext.len - trn_data) : fragsz;
8425
8426                 to_trn_tbl[ecx++] = to_trn;
8427
8428                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8429                 buf = buf->next;
8430
8431                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8432                                 rte_pktmbuf_tailroom(buf));
8433
8434                 /* OOP */
8435                 if (oop && !fragsz_oop) {
8436                         buf_last_oop = buf_oop->next =
8437                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8438                         buf_oop = buf_oop->next;
8439                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8440                                         0, rte_pktmbuf_tailroom(buf_oop));
8441                         rte_pktmbuf_append(buf_oop, to_trn);
8442                 }
8443
8444                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8445                                 to_trn);
8446
8447                 memcpy(plaintext, tdata->plaintext.data + trn_data,
8448                                 to_trn);
8449                 trn_data += to_trn;
8450                 if (trn_data  == tdata->plaintext.len) {
8451                         if (oop) {
8452                                 if (!fragsz_oop)
8453                                         digest_mem = rte_pktmbuf_append(buf_oop,
8454                                                 tdata->auth_tag.len);
8455                         } else
8456                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
8457                                         tdata->auth_tag.len);
8458                 }
8459         }
8460
8461         uint64_t digest_phys = 0;
8462
8463         ut_params->ibuf->nb_segs = segs;
8464
8465         segs = 1;
8466         if (fragsz_oop && oop) {
8467                 to_trn = 0;
8468                 ecx = 0;
8469
8470                 if (frag_size_oop == tdata->plaintext.len) {
8471                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
8472                                 tdata->auth_tag.len);
8473
8474                         digest_phys = rte_pktmbuf_iova_offset(
8475                                         ut_params->obuf,
8476                                         tdata->plaintext.len + prepend_len);
8477                 }
8478
8479                 trn_data = frag_size_oop;
8480                 while (trn_data < tdata->plaintext.len) {
8481                         ++segs;
8482                         to_trn =
8483                                 (tdata->plaintext.len - trn_data <
8484                                                 frag_size_oop) ?
8485                                 (tdata->plaintext.len - trn_data) :
8486                                                 frag_size_oop;
8487
8488                         to_trn_tbl[ecx++] = to_trn;
8489
8490                         buf_last_oop = buf_oop->next =
8491                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8492                         buf_oop = buf_oop->next;
8493                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8494                                         0, rte_pktmbuf_tailroom(buf_oop));
8495                         rte_pktmbuf_append(buf_oop, to_trn);
8496
8497                         trn_data += to_trn;
8498
8499                         if (trn_data  == tdata->plaintext.len) {
8500                                 digest_mem = rte_pktmbuf_append(buf_oop,
8501                                         tdata->auth_tag.len);
8502                         }
8503                 }
8504
8505                 ut_params->obuf->nb_segs = segs;
8506         }
8507
8508         /*
8509          * Place digest at the end of the last buffer
8510          */
8511         if (!digest_phys)
8512                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
8513         if (oop && buf_last_oop)
8514                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
8515
8516         if (!digest_mem && !oop) {
8517                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8518                                 + tdata->auth_tag.len);
8519                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
8520                                 tdata->plaintext.len);
8521         }
8522
8523         /* Create AEAD operation */
8524         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
8525                         tdata, digest_mem, digest_phys);
8526
8527         if (retval < 0)
8528                 return retval;
8529
8530         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8531
8532         ut_params->op->sym->m_src = ut_params->ibuf;
8533         if (oop)
8534                 ut_params->op->sym->m_dst = ut_params->obuf;
8535
8536         /* Process crypto operation */
8537         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8538                         ut_params->op), "failed to process sym crypto op");
8539
8540         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8541                         "crypto op processing failed");
8542
8543
8544         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8545                         uint8_t *, prepend_len);
8546         if (oop) {
8547                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8548                                 uint8_t *, prepend_len);
8549         }
8550
8551         if (fragsz_oop)
8552                 fragsz = fragsz_oop;
8553
8554         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8555                         ciphertext,
8556                         tdata->ciphertext.data,
8557                         fragsz,
8558                         "Ciphertext data not as expected");
8559
8560         buf = ut_params->op->sym->m_src->next;
8561         if (oop)
8562                 buf = ut_params->op->sym->m_dst->next;
8563
8564         unsigned int off = fragsz;
8565
8566         ecx = 0;
8567         while (buf) {
8568                 ciphertext = rte_pktmbuf_mtod(buf,
8569                                 uint8_t *);
8570
8571                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8572                                 ciphertext,
8573                                 tdata->ciphertext.data + off,
8574                                 to_trn_tbl[ecx],
8575                                 "Ciphertext data not as expected");
8576
8577                 off += to_trn_tbl[ecx++];
8578                 buf = buf->next;
8579         }
8580
8581         auth_tag = digest_mem;
8582         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8583                         auth_tag,
8584                         tdata->auth_tag.data,
8585                         tdata->auth_tag.len,
8586                         "Generated auth tag not as expected");
8587
8588         return 0;
8589 }
8590
8591 #define IN_PLACE        0
8592 #define OUT_OF_PLACE    1
8593
8594 static int
8595 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
8596 {
8597         return test_authenticated_encryption_SGL(
8598                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
8599 }
8600
8601 static int
8602 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
8603 {
8604         return test_authenticated_encryption_SGL(
8605                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
8606 }
8607
8608 static int
8609 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
8610 {
8611         return test_authenticated_encryption_SGL(
8612                         &gcm_test_case_8, OUT_OF_PLACE, 400,
8613                         gcm_test_case_8.plaintext.len);
8614 }
8615
8616 static int
8617 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
8618 {
8619
8620         return test_authenticated_encryption_SGL(
8621                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
8622 }
8623
8624 static int
8625 test_authentication_verify_fail_when_data_corrupted(
8626                 struct crypto_testsuite_params *ts_params,
8627                 struct crypto_unittest_params *ut_params,
8628                 const struct test_crypto_vector *reference)
8629 {
8630         return test_authentication_verify_fail_when_data_corruption(
8631                         ts_params, ut_params, reference, 1);
8632 }
8633
8634 static int
8635 test_authentication_verify_fail_when_tag_corrupted(
8636                 struct crypto_testsuite_params *ts_params,
8637                 struct crypto_unittest_params *ut_params,
8638                 const struct test_crypto_vector *reference)
8639 {
8640         return test_authentication_verify_fail_when_data_corruption(
8641                         ts_params, ut_params, reference, 0);
8642 }
8643
8644 static int
8645 test_authentication_verify_GMAC_fail_when_data_corrupted(
8646                 struct crypto_testsuite_params *ts_params,
8647                 struct crypto_unittest_params *ut_params,
8648                 const struct test_crypto_vector *reference)
8649 {
8650         return test_authentication_verify_GMAC_fail_when_corruption(
8651                         ts_params, ut_params, reference, 1);
8652 }
8653
8654 static int
8655 test_authentication_verify_GMAC_fail_when_tag_corrupted(
8656                 struct crypto_testsuite_params *ts_params,
8657                 struct crypto_unittest_params *ut_params,
8658                 const struct test_crypto_vector *reference)
8659 {
8660         return test_authentication_verify_GMAC_fail_when_corruption(
8661                         ts_params, ut_params, reference, 0);
8662 }
8663
8664 static int
8665 test_authenticated_decryption_fail_when_data_corrupted(
8666                 struct crypto_testsuite_params *ts_params,
8667                 struct crypto_unittest_params *ut_params,
8668                 const struct test_crypto_vector *reference)
8669 {
8670         return test_authenticated_decryption_fail_when_corruption(
8671                         ts_params, ut_params, reference, 1);
8672 }
8673
8674 static int
8675 test_authenticated_decryption_fail_when_tag_corrupted(
8676                 struct crypto_testsuite_params *ts_params,
8677                 struct crypto_unittest_params *ut_params,
8678                 const struct test_crypto_vector *reference)
8679 {
8680         return test_authenticated_decryption_fail_when_corruption(
8681                         ts_params, ut_params, reference, 0);
8682 }
8683
8684 static int
8685 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
8686 {
8687         return test_authentication_verify_fail_when_data_corrupted(
8688                         &testsuite_params, &unittest_params,
8689                         &hmac_sha1_test_crypto_vector);
8690 }
8691
8692 static int
8693 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
8694 {
8695         return test_authentication_verify_fail_when_tag_corrupted(
8696                         &testsuite_params, &unittest_params,
8697                         &hmac_sha1_test_crypto_vector);
8698 }
8699
8700 static int
8701 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
8702 {
8703         return test_authentication_verify_GMAC_fail_when_data_corrupted(
8704                         &testsuite_params, &unittest_params,
8705                         &aes128_gmac_test_vector);
8706 }
8707
8708 static int
8709 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
8710 {
8711         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
8712                         &testsuite_params, &unittest_params,
8713                         &aes128_gmac_test_vector);
8714 }
8715
8716 static int
8717 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
8718 {
8719         return test_authenticated_decryption_fail_when_data_corrupted(
8720                         &testsuite_params,
8721                         &unittest_params,
8722                         &aes128cbc_hmac_sha1_test_vector);
8723 }
8724
8725 static int
8726 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
8727 {
8728         return test_authenticated_decryption_fail_when_tag_corrupted(
8729                         &testsuite_params,
8730                         &unittest_params,
8731                         &aes128cbc_hmac_sha1_test_vector);
8732 }
8733
8734 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
8735
8736 /* global AESNI slave IDs for the scheduler test */
8737 uint8_t aesni_ids[2];
8738
8739 static int
8740 test_scheduler_attach_slave_op(void)
8741 {
8742         struct crypto_testsuite_params *ts_params = &testsuite_params;
8743         uint8_t sched_id = ts_params->valid_devs[0];
8744         uint32_t nb_devs, i, nb_devs_attached = 0;
8745         int ret;
8746         char vdev_name[32];
8747
8748         /* create 2 AESNI_MB if necessary */
8749         nb_devs = rte_cryptodev_device_count_by_driver(
8750                         rte_cryptodev_driver_id_get(
8751                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
8752         if (nb_devs < 2) {
8753                 for (i = nb_devs; i < 2; i++) {
8754                         snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
8755                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
8756                                         i);
8757                         ret = rte_vdev_init(vdev_name, NULL);
8758
8759                         TEST_ASSERT(ret == 0,
8760                                 "Failed to create instance %u of"
8761                                 " pmd : %s",
8762                                 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
8763                 }
8764         }
8765
8766         /* attach 2 AESNI_MB cdevs */
8767         for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
8768                         i++) {
8769                 struct rte_cryptodev_info info;
8770                 unsigned int session_size;
8771
8772                 rte_cryptodev_info_get(i, &info);
8773                 if (info.driver_id != rte_cryptodev_driver_id_get(
8774                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
8775                         continue;
8776
8777                 session_size = rte_cryptodev_sym_get_private_session_size(i);
8778                 /*
8779                  * Create the session mempool again, since now there are new devices
8780                  * to use the mempool.
8781                  */
8782                 if (ts_params->session_mpool) {
8783                         rte_mempool_free(ts_params->session_mpool);
8784                         ts_params->session_mpool = NULL;
8785                 }
8786                 if (ts_params->session_priv_mpool) {
8787                         rte_mempool_free(ts_params->session_priv_mpool);
8788                         ts_params->session_priv_mpool = NULL;
8789                 }
8790
8791                 if (info.sym.max_nb_sessions != 0 &&
8792                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
8793                         RTE_LOG(ERR, USER1,
8794                                         "Device does not support "
8795                                         "at least %u sessions\n",
8796                                         MAX_NB_SESSIONS);
8797                         return TEST_FAILED;
8798                 }
8799                 /*
8800                  * Create mempool with maximum number of sessions,
8801                  * to include the session headers
8802                  */
8803                 if (ts_params->session_mpool == NULL) {
8804                         ts_params->session_mpool =
8805                                 rte_cryptodev_sym_session_pool_create(
8806                                                 "test_sess_mp",
8807                                                 MAX_NB_SESSIONS, 0, 0, 0,
8808                                                 SOCKET_ID_ANY);
8809                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
8810                                         "session mempool allocation failed");
8811                 }
8812
8813                 /*
8814                  * Create mempool with maximum number of sessions,
8815                  * to include device specific session private data
8816                  */
8817                 if (ts_params->session_priv_mpool == NULL) {
8818                         ts_params->session_priv_mpool = rte_mempool_create(
8819                                         "test_sess_mp_priv",
8820                                         MAX_NB_SESSIONS,
8821                                         session_size,
8822                                         0, 0, NULL, NULL, NULL,
8823                                         NULL, SOCKET_ID_ANY,
8824                                         0);
8825
8826                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
8827                                         "session mempool allocation failed");
8828                 }
8829
8830                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
8831                 ts_params->qp_conf.mp_session_private =
8832                                 ts_params->session_priv_mpool;
8833
8834                 ret = rte_cryptodev_scheduler_slave_attach(sched_id,
8835                                 (uint8_t)i);
8836
8837                 TEST_ASSERT(ret == 0,
8838                         "Failed to attach device %u of pmd : %s", i,
8839                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
8840
8841                 aesni_ids[nb_devs_attached] = (uint8_t)i;
8842
8843                 nb_devs_attached++;
8844         }
8845
8846         return 0;
8847 }
8848
8849 static int
8850 test_scheduler_detach_slave_op(void)
8851 {
8852         struct crypto_testsuite_params *ts_params = &testsuite_params;
8853         uint8_t sched_id = ts_params->valid_devs[0];
8854         uint32_t i;
8855         int ret;
8856
8857         for (i = 0; i < 2; i++) {
8858                 ret = rte_cryptodev_scheduler_slave_detach(sched_id,
8859                                 aesni_ids[i]);
8860                 TEST_ASSERT(ret == 0,
8861                         "Failed to detach device %u", aesni_ids[i]);
8862         }
8863
8864         return 0;
8865 }
8866
8867 static int
8868 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
8869 {
8870         struct crypto_testsuite_params *ts_params = &testsuite_params;
8871         uint8_t sched_id = ts_params->valid_devs[0];
8872         /* set mode */
8873         return rte_cryptodev_scheduler_mode_set(sched_id,
8874                 scheduler_mode);
8875 }
8876
8877 static int
8878 test_scheduler_mode_roundrobin_op(void)
8879 {
8880         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
8881                         0, "Failed to set roundrobin mode");
8882         return 0;
8883
8884 }
8885
8886 static int
8887 test_scheduler_mode_multicore_op(void)
8888 {
8889         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
8890                         0, "Failed to set multicore mode");
8891
8892         return 0;
8893 }
8894
8895 static int
8896 test_scheduler_mode_failover_op(void)
8897 {
8898         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
8899                         0, "Failed to set failover mode");
8900
8901         return 0;
8902 }
8903
8904 static int
8905 test_scheduler_mode_pkt_size_distr_op(void)
8906 {
8907         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
8908                         0, "Failed to set pktsize mode");
8909
8910         return 0;
8911 }
8912
8913 static struct unit_test_suite cryptodev_scheduler_testsuite  = {
8914         .suite_name = "Crypto Device Scheduler Unit Test Suite",
8915         .setup = testsuite_setup,
8916         .teardown = testsuite_teardown,
8917         .unit_test_cases = {
8918                 /* Multi Core */
8919                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
8920                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
8921                 TEST_CASE_ST(ut_setup, ut_teardown,
8922                                         test_AES_chain_scheduler_all),
8923                 TEST_CASE_ST(ut_setup, ut_teardown,
8924                                         test_AES_cipheronly_scheduler_all),
8925                 TEST_CASE_ST(ut_setup, ut_teardown,
8926                                         test_authonly_scheduler_all),
8927                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
8928
8929                 /* Round Robin */
8930                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
8931                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
8932                 TEST_CASE_ST(ut_setup, ut_teardown,
8933                                 test_AES_chain_scheduler_all),
8934                 TEST_CASE_ST(ut_setup, ut_teardown,
8935                                 test_AES_cipheronly_scheduler_all),
8936                 TEST_CASE_ST(ut_setup, ut_teardown,
8937                                 test_authonly_scheduler_all),
8938                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
8939
8940                 /* Fail over */
8941                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
8942                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
8943                 TEST_CASE_ST(ut_setup, ut_teardown,
8944                                         test_AES_chain_scheduler_all),
8945                 TEST_CASE_ST(ut_setup, ut_teardown,
8946                                         test_AES_cipheronly_scheduler_all),
8947                 TEST_CASE_ST(ut_setup, ut_teardown,
8948                                         test_authonly_scheduler_all),
8949                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
8950
8951                 /* PKT SIZE */
8952                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
8953                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
8954                 TEST_CASE_ST(ut_setup, ut_teardown,
8955                                         test_AES_chain_scheduler_all),
8956                 TEST_CASE_ST(ut_setup, ut_teardown,
8957                                         test_AES_cipheronly_scheduler_all),
8958                 TEST_CASE_ST(ut_setup, ut_teardown,
8959                                         test_authonly_scheduler_all),
8960                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
8961
8962                 TEST_CASES_END() /**< NULL terminate unit test array */
8963         }
8964 };
8965
8966 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
8967
8968 static struct unit_test_suite cryptodev_qat_testsuite  = {
8969         .suite_name = "Crypto QAT Unit Test Suite",
8970         .setup = testsuite_setup,
8971         .teardown = testsuite_teardown,
8972         .unit_test_cases = {
8973                 TEST_CASE_ST(ut_setup, ut_teardown,
8974                                 test_device_configure_invalid_dev_id),
8975                 TEST_CASE_ST(ut_setup, ut_teardown,
8976                                 test_device_configure_invalid_queue_pair_ids),
8977                 TEST_CASE_ST(ut_setup, ut_teardown,
8978                                 test_queue_pair_descriptor_setup),
8979                 TEST_CASE_ST(ut_setup, ut_teardown,
8980                                 test_multi_session),
8981
8982                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
8983                 TEST_CASE_ST(ut_setup, ut_teardown,
8984                                                 test_AES_cipheronly_qat_all),
8985                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
8986                 TEST_CASE_ST(ut_setup, ut_teardown,
8987                                                 test_3DES_cipheronly_qat_all),
8988                 TEST_CASE_ST(ut_setup, ut_teardown,
8989                                                 test_DES_cipheronly_qat_all),
8990                 TEST_CASE_ST(ut_setup, ut_teardown,
8991                                                 test_AES_docsis_qat_all),
8992                 TEST_CASE_ST(ut_setup, ut_teardown,
8993                                                 test_DES_docsis_qat_all),
8994                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_qat_all),
8995                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
8996
8997                 /** AES CCM Authenticated Encryption 128 bits key */
8998                 TEST_CASE_ST(ut_setup, ut_teardown,
8999                         test_AES_CCM_authenticated_encryption_test_case_128_1),
9000                 TEST_CASE_ST(ut_setup, ut_teardown,
9001                         test_AES_CCM_authenticated_encryption_test_case_128_2),
9002                 TEST_CASE_ST(ut_setup, ut_teardown,
9003                         test_AES_CCM_authenticated_encryption_test_case_128_3),
9004
9005                 /** AES CCM Authenticated Decryption 128 bits key*/
9006                 TEST_CASE_ST(ut_setup, ut_teardown,
9007                         test_AES_CCM_authenticated_decryption_test_case_128_1),
9008                 TEST_CASE_ST(ut_setup, ut_teardown,
9009                         test_AES_CCM_authenticated_decryption_test_case_128_2),
9010                 TEST_CASE_ST(ut_setup, ut_teardown,
9011                         test_AES_CCM_authenticated_decryption_test_case_128_3),
9012
9013                 /** AES GCM Authenticated Encryption */
9014                 TEST_CASE_ST(ut_setup, ut_teardown,
9015                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
9016                 TEST_CASE_ST(ut_setup, ut_teardown,
9017                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
9018                 TEST_CASE_ST(ut_setup, ut_teardown,
9019                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
9020                 TEST_CASE_ST(ut_setup, ut_teardown,
9021                         test_AES_GCM_authenticated_encryption_test_case_1),
9022                 TEST_CASE_ST(ut_setup, ut_teardown,
9023                         test_AES_GCM_authenticated_encryption_test_case_2),
9024                 TEST_CASE_ST(ut_setup, ut_teardown,
9025                         test_AES_GCM_authenticated_encryption_test_case_3),
9026                 TEST_CASE_ST(ut_setup, ut_teardown,
9027                         test_AES_GCM_authenticated_encryption_test_case_4),
9028                 TEST_CASE_ST(ut_setup, ut_teardown,
9029                         test_AES_GCM_authenticated_encryption_test_case_5),
9030                 TEST_CASE_ST(ut_setup, ut_teardown,
9031                         test_AES_GCM_authenticated_encryption_test_case_6),
9032                 TEST_CASE_ST(ut_setup, ut_teardown,
9033                         test_AES_GCM_authenticated_encryption_test_case_7),
9034
9035                 /** AES GCM Authenticated Decryption */
9036                 TEST_CASE_ST(ut_setup, ut_teardown,
9037                         test_AES_GCM_authenticated_decryption_test_case_1),
9038                 TEST_CASE_ST(ut_setup, ut_teardown,
9039                         test_AES_GCM_authenticated_decryption_test_case_2),
9040                 TEST_CASE_ST(ut_setup, ut_teardown,
9041                         test_AES_GCM_authenticated_decryption_test_case_3),
9042                 TEST_CASE_ST(ut_setup, ut_teardown,
9043                         test_AES_GCM_authenticated_decryption_test_case_4),
9044                 TEST_CASE_ST(ut_setup, ut_teardown,
9045                         test_AES_GCM_authenticated_decryption_test_case_5),
9046                 TEST_CASE_ST(ut_setup, ut_teardown,
9047                         test_AES_GCM_authenticated_decryption_test_case_6),
9048                 TEST_CASE_ST(ut_setup, ut_teardown,
9049                         test_AES_GCM_authenticated_decryption_test_case_7),
9050
9051                 /** AES GCM Authenticated Encryption 192 bits key */
9052                 TEST_CASE_ST(ut_setup, ut_teardown,
9053                         test_AES_GCM_auth_encryption_test_case_192_1),
9054                 TEST_CASE_ST(ut_setup, ut_teardown,
9055                         test_AES_GCM_auth_encryption_test_case_192_2),
9056                 TEST_CASE_ST(ut_setup, ut_teardown,
9057                         test_AES_GCM_auth_encryption_test_case_192_3),
9058                 TEST_CASE_ST(ut_setup, ut_teardown,
9059                         test_AES_GCM_auth_encryption_test_case_192_4),
9060                 TEST_CASE_ST(ut_setup, ut_teardown,
9061                         test_AES_GCM_auth_encryption_test_case_192_5),
9062                 TEST_CASE_ST(ut_setup, ut_teardown,
9063                         test_AES_GCM_auth_encryption_test_case_192_6),
9064                 TEST_CASE_ST(ut_setup, ut_teardown,
9065                         test_AES_GCM_auth_encryption_test_case_192_7),
9066
9067                 /** AES GCM Authenticated Decryption 192 bits key */
9068                 TEST_CASE_ST(ut_setup, ut_teardown,
9069                         test_AES_GCM_auth_decryption_test_case_192_1),
9070                 TEST_CASE_ST(ut_setup, ut_teardown,
9071                         test_AES_GCM_auth_decryption_test_case_192_2),
9072                 TEST_CASE_ST(ut_setup, ut_teardown,
9073                         test_AES_GCM_auth_decryption_test_case_192_3),
9074                 TEST_CASE_ST(ut_setup, ut_teardown,
9075                         test_AES_GCM_auth_decryption_test_case_192_4),
9076                 TEST_CASE_ST(ut_setup, ut_teardown,
9077                         test_AES_GCM_auth_decryption_test_case_192_5),
9078                 TEST_CASE_ST(ut_setup, ut_teardown,
9079                         test_AES_GCM_auth_decryption_test_case_192_6),
9080                 TEST_CASE_ST(ut_setup, ut_teardown,
9081                         test_AES_GCM_auth_decryption_test_case_192_7),
9082
9083                 /** AES GCM Authenticated Encryption 256 bits key */
9084                 TEST_CASE_ST(ut_setup, ut_teardown,
9085                         test_AES_GCM_auth_encryption_test_case_256_1),
9086                 TEST_CASE_ST(ut_setup, ut_teardown,
9087                         test_AES_GCM_auth_encryption_test_case_256_2),
9088                 TEST_CASE_ST(ut_setup, ut_teardown,
9089                         test_AES_GCM_auth_encryption_test_case_256_3),
9090                 TEST_CASE_ST(ut_setup, ut_teardown,
9091                         test_AES_GCM_auth_encryption_test_case_256_4),
9092                 TEST_CASE_ST(ut_setup, ut_teardown,
9093                         test_AES_GCM_auth_encryption_test_case_256_5),
9094                 TEST_CASE_ST(ut_setup, ut_teardown,
9095                         test_AES_GCM_auth_encryption_test_case_256_6),
9096                 TEST_CASE_ST(ut_setup, ut_teardown,
9097                         test_AES_GCM_auth_encryption_test_case_256_7),
9098
9099                 /** AES GMAC Authentication */
9100                 TEST_CASE_ST(ut_setup, ut_teardown,
9101                         test_AES_GMAC_authentication_test_case_1),
9102                 TEST_CASE_ST(ut_setup, ut_teardown,
9103                         test_AES_GMAC_authentication_verify_test_case_1),
9104                 TEST_CASE_ST(ut_setup, ut_teardown,
9105                         test_AES_GMAC_authentication_test_case_2),
9106                 TEST_CASE_ST(ut_setup, ut_teardown,
9107                         test_AES_GMAC_authentication_verify_test_case_2),
9108                 TEST_CASE_ST(ut_setup, ut_teardown,
9109                         test_AES_GMAC_authentication_test_case_3),
9110                 TEST_CASE_ST(ut_setup, ut_teardown,
9111                         test_AES_GMAC_authentication_verify_test_case_3),
9112
9113                 /** SNOW 3G encrypt only (UEA2) */
9114                 TEST_CASE_ST(ut_setup, ut_teardown,
9115                         test_snow3g_encryption_test_case_1),
9116                 TEST_CASE_ST(ut_setup, ut_teardown,
9117                         test_snow3g_encryption_test_case_2),
9118                 TEST_CASE_ST(ut_setup, ut_teardown,
9119                         test_snow3g_encryption_test_case_3),
9120                 TEST_CASE_ST(ut_setup, ut_teardown,
9121                         test_snow3g_encryption_test_case_4),
9122                 TEST_CASE_ST(ut_setup, ut_teardown,
9123                         test_snow3g_encryption_test_case_5),
9124
9125                 TEST_CASE_ST(ut_setup, ut_teardown,
9126                         test_snow3g_encryption_test_case_1_oop),
9127                 TEST_CASE_ST(ut_setup, ut_teardown,
9128                         test_snow3g_decryption_test_case_1_oop),
9129
9130                 /** SNOW 3G decrypt only (UEA2) */
9131                 TEST_CASE_ST(ut_setup, ut_teardown,
9132                         test_snow3g_decryption_test_case_1),
9133                 TEST_CASE_ST(ut_setup, ut_teardown,
9134                         test_snow3g_decryption_test_case_2),
9135                 TEST_CASE_ST(ut_setup, ut_teardown,
9136                         test_snow3g_decryption_test_case_3),
9137                 TEST_CASE_ST(ut_setup, ut_teardown,
9138                         test_snow3g_decryption_test_case_4),
9139                 TEST_CASE_ST(ut_setup, ut_teardown,
9140                         test_snow3g_decryption_test_case_5),
9141                 TEST_CASE_ST(ut_setup, ut_teardown,
9142                         test_snow3g_hash_generate_test_case_1),
9143                 TEST_CASE_ST(ut_setup, ut_teardown,
9144                         test_snow3g_hash_generate_test_case_2),
9145                 TEST_CASE_ST(ut_setup, ut_teardown,
9146                         test_snow3g_hash_generate_test_case_3),
9147                 TEST_CASE_ST(ut_setup, ut_teardown,
9148                         test_snow3g_hash_verify_test_case_1),
9149                 TEST_CASE_ST(ut_setup, ut_teardown,
9150                         test_snow3g_hash_verify_test_case_2),
9151                 TEST_CASE_ST(ut_setup, ut_teardown,
9152                         test_snow3g_hash_verify_test_case_3),
9153                 TEST_CASE_ST(ut_setup, ut_teardown,
9154                         test_snow3g_cipher_auth_test_case_1),
9155                 TEST_CASE_ST(ut_setup, ut_teardown,
9156                         test_snow3g_auth_cipher_test_case_1),
9157
9158                 /** ZUC encrypt only (EEA3) */
9159                 TEST_CASE_ST(ut_setup, ut_teardown,
9160                         test_zuc_encryption_test_case_1),
9161                 TEST_CASE_ST(ut_setup, ut_teardown,
9162                         test_zuc_encryption_test_case_2),
9163                 TEST_CASE_ST(ut_setup, ut_teardown,
9164                         test_zuc_encryption_test_case_3),
9165                 TEST_CASE_ST(ut_setup, ut_teardown,
9166                         test_zuc_encryption_test_case_4),
9167                 TEST_CASE_ST(ut_setup, ut_teardown,
9168                         test_zuc_encryption_test_case_5),
9169
9170                 /** ZUC authenticate (EIA3) */
9171                 TEST_CASE_ST(ut_setup, ut_teardown,
9172                         test_zuc_hash_generate_test_case_6),
9173                 TEST_CASE_ST(ut_setup, ut_teardown,
9174                         test_zuc_hash_generate_test_case_7),
9175                 TEST_CASE_ST(ut_setup, ut_teardown,
9176                         test_zuc_hash_generate_test_case_8),
9177
9178                 /** ZUC alg-chain (EEA3/EIA3) */
9179                 TEST_CASE_ST(ut_setup, ut_teardown,
9180                         test_zuc_cipher_auth_test_case_1),
9181                 TEST_CASE_ST(ut_setup, ut_teardown,
9182                         test_zuc_cipher_auth_test_case_2),
9183
9184                 /** HMAC_MD5 Authentication */
9185                 TEST_CASE_ST(ut_setup, ut_teardown,
9186                         test_MD5_HMAC_generate_case_1),
9187                 TEST_CASE_ST(ut_setup, ut_teardown,
9188                         test_MD5_HMAC_verify_case_1),
9189                 TEST_CASE_ST(ut_setup, ut_teardown,
9190                         test_MD5_HMAC_generate_case_2),
9191                 TEST_CASE_ST(ut_setup, ut_teardown,
9192                         test_MD5_HMAC_verify_case_2),
9193
9194                 /** NULL tests */
9195                 TEST_CASE_ST(ut_setup, ut_teardown,
9196                         test_null_auth_only_operation),
9197                 TEST_CASE_ST(ut_setup, ut_teardown,
9198                         test_null_cipher_only_operation),
9199                 TEST_CASE_ST(ut_setup, ut_teardown,
9200                         test_null_cipher_auth_operation),
9201                 TEST_CASE_ST(ut_setup, ut_teardown,
9202                         test_null_auth_cipher_operation),
9203
9204                 /** KASUMI tests */
9205                 TEST_CASE_ST(ut_setup, ut_teardown,
9206                         test_kasumi_hash_generate_test_case_1),
9207                 TEST_CASE_ST(ut_setup, ut_teardown,
9208                         test_kasumi_hash_generate_test_case_2),
9209                 TEST_CASE_ST(ut_setup, ut_teardown,
9210                         test_kasumi_hash_generate_test_case_3),
9211                 TEST_CASE_ST(ut_setup, ut_teardown,
9212                         test_kasumi_hash_generate_test_case_4),
9213                 TEST_CASE_ST(ut_setup, ut_teardown,
9214                         test_kasumi_hash_generate_test_case_5),
9215                 TEST_CASE_ST(ut_setup, ut_teardown,
9216                         test_kasumi_hash_generate_test_case_6),
9217
9218                 TEST_CASE_ST(ut_setup, ut_teardown,
9219                         test_kasumi_hash_verify_test_case_1),
9220                 TEST_CASE_ST(ut_setup, ut_teardown,
9221                         test_kasumi_hash_verify_test_case_2),
9222                 TEST_CASE_ST(ut_setup, ut_teardown,
9223                         test_kasumi_hash_verify_test_case_3),
9224                 TEST_CASE_ST(ut_setup, ut_teardown,
9225                         test_kasumi_hash_verify_test_case_4),
9226                 TEST_CASE_ST(ut_setup, ut_teardown,
9227                         test_kasumi_hash_verify_test_case_5),
9228
9229                 TEST_CASE_ST(ut_setup, ut_teardown,
9230                         test_kasumi_encryption_test_case_1),
9231                 TEST_CASE_ST(ut_setup, ut_teardown,
9232                         test_kasumi_encryption_test_case_3),
9233                 TEST_CASE_ST(ut_setup, ut_teardown,
9234                         test_kasumi_auth_cipher_test_case_1),
9235                 TEST_CASE_ST(ut_setup, ut_teardown,
9236                         test_kasumi_cipher_auth_test_case_1),
9237
9238                 /** Negative tests */
9239                 TEST_CASE_ST(ut_setup, ut_teardown,
9240                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
9241                 TEST_CASE_ST(ut_setup, ut_teardown,
9242                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
9243                 TEST_CASE_ST(ut_setup, ut_teardown,
9244                         authentication_verify_AES128_GMAC_fail_data_corrupt),
9245                 TEST_CASE_ST(ut_setup, ut_teardown,
9246                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
9247                 TEST_CASE_ST(ut_setup, ut_teardown,
9248                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
9249                 TEST_CASE_ST(ut_setup, ut_teardown,
9250                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
9251
9252                 TEST_CASES_END() /**< NULL terminate unit test array */
9253         }
9254 };
9255
9256 static struct unit_test_suite cryptodev_virtio_testsuite = {
9257         .suite_name = "Crypto VIRTIO Unit Test Suite",
9258         .setup = testsuite_setup,
9259         .teardown = testsuite_teardown,
9260         .unit_test_cases = {
9261                 TEST_CASE_ST(ut_setup, ut_teardown,
9262                                 test_AES_cipheronly_virtio_all),
9263
9264                 TEST_CASES_END() /**< NULL terminate unit test array */
9265         }
9266 };
9267
9268 static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
9269         .suite_name = "Crypto Device AESNI MB Unit Test Suite",
9270         .setup = testsuite_setup,
9271         .teardown = testsuite_teardown,
9272         .unit_test_cases = {
9273 #if IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0)
9274                 TEST_CASE_ST(ut_setup, ut_teardown,
9275                         test_AES_GCM_authenticated_encryption_test_case_1),
9276                 TEST_CASE_ST(ut_setup, ut_teardown,
9277                         test_AES_GCM_authenticated_encryption_test_case_2),
9278                 TEST_CASE_ST(ut_setup, ut_teardown,
9279                         test_AES_GCM_authenticated_encryption_test_case_3),
9280                 TEST_CASE_ST(ut_setup, ut_teardown,
9281                         test_AES_GCM_authenticated_encryption_test_case_4),
9282                 TEST_CASE_ST(ut_setup, ut_teardown,
9283                         test_AES_GCM_authenticated_encryption_test_case_5),
9284                 TEST_CASE_ST(ut_setup, ut_teardown,
9285                         test_AES_GCM_authenticated_encryption_test_case_6),
9286                 TEST_CASE_ST(ut_setup, ut_teardown,
9287                         test_AES_GCM_authenticated_encryption_test_case_7),
9288
9289                 /** AES GCM Authenticated Decryption */
9290                 TEST_CASE_ST(ut_setup, ut_teardown,
9291                         test_AES_GCM_authenticated_decryption_test_case_1),
9292                 TEST_CASE_ST(ut_setup, ut_teardown,
9293                         test_AES_GCM_authenticated_decryption_test_case_2),
9294                 TEST_CASE_ST(ut_setup, ut_teardown,
9295                         test_AES_GCM_authenticated_decryption_test_case_3),
9296                 TEST_CASE_ST(ut_setup, ut_teardown,
9297                         test_AES_GCM_authenticated_decryption_test_case_4),
9298                 TEST_CASE_ST(ut_setup, ut_teardown,
9299                         test_AES_GCM_authenticated_decryption_test_case_5),
9300                 TEST_CASE_ST(ut_setup, ut_teardown,
9301                         test_AES_GCM_authenticated_decryption_test_case_6),
9302                 TEST_CASE_ST(ut_setup, ut_teardown,
9303                         test_AES_GCM_authenticated_decryption_test_case_7),
9304
9305                 /** AES GCM Authenticated Encryption 192 bits key */
9306                 TEST_CASE_ST(ut_setup, ut_teardown,
9307                         test_AES_GCM_auth_encryption_test_case_192_1),
9308                 TEST_CASE_ST(ut_setup, ut_teardown,
9309                         test_AES_GCM_auth_encryption_test_case_192_2),
9310                 TEST_CASE_ST(ut_setup, ut_teardown,
9311                         test_AES_GCM_auth_encryption_test_case_192_3),
9312                 TEST_CASE_ST(ut_setup, ut_teardown,
9313                         test_AES_GCM_auth_encryption_test_case_192_4),
9314                 TEST_CASE_ST(ut_setup, ut_teardown,
9315                         test_AES_GCM_auth_encryption_test_case_192_5),
9316                 TEST_CASE_ST(ut_setup, ut_teardown,
9317                         test_AES_GCM_auth_encryption_test_case_192_6),
9318                 TEST_CASE_ST(ut_setup, ut_teardown,
9319                         test_AES_GCM_auth_encryption_test_case_192_7),
9320
9321                 /** AES GCM Authenticated Decryption 192 bits key */
9322                 TEST_CASE_ST(ut_setup, ut_teardown,
9323                         test_AES_GCM_auth_decryption_test_case_192_1),
9324                 TEST_CASE_ST(ut_setup, ut_teardown,
9325                         test_AES_GCM_auth_decryption_test_case_192_2),
9326                 TEST_CASE_ST(ut_setup, ut_teardown,
9327                         test_AES_GCM_auth_decryption_test_case_192_3),
9328                 TEST_CASE_ST(ut_setup, ut_teardown,
9329                         test_AES_GCM_auth_decryption_test_case_192_4),
9330                 TEST_CASE_ST(ut_setup, ut_teardown,
9331                         test_AES_GCM_auth_decryption_test_case_192_5),
9332                 TEST_CASE_ST(ut_setup, ut_teardown,
9333                         test_AES_GCM_auth_decryption_test_case_192_6),
9334                 TEST_CASE_ST(ut_setup, ut_teardown,
9335                         test_AES_GCM_auth_decryption_test_case_192_7),
9336
9337                 /** AES GCM Authenticated Encryption 256 bits key */
9338                 TEST_CASE_ST(ut_setup, ut_teardown,
9339                         test_AES_GCM_auth_encryption_test_case_256_1),
9340                 TEST_CASE_ST(ut_setup, ut_teardown,
9341                         test_AES_GCM_auth_encryption_test_case_256_2),
9342                 TEST_CASE_ST(ut_setup, ut_teardown,
9343                         test_AES_GCM_auth_encryption_test_case_256_3),
9344                 TEST_CASE_ST(ut_setup, ut_teardown,
9345                         test_AES_GCM_auth_encryption_test_case_256_4),
9346                 TEST_CASE_ST(ut_setup, ut_teardown,
9347                         test_AES_GCM_auth_encryption_test_case_256_5),
9348                 TEST_CASE_ST(ut_setup, ut_teardown,
9349                         test_AES_GCM_auth_encryption_test_case_256_6),
9350                 TEST_CASE_ST(ut_setup, ut_teardown,
9351                         test_AES_GCM_auth_encryption_test_case_256_7),
9352
9353                 /** AES GCM Authenticated Decryption 256 bits key */
9354                 TEST_CASE_ST(ut_setup, ut_teardown,
9355                         test_AES_GCM_auth_decryption_test_case_256_1),
9356                 TEST_CASE_ST(ut_setup, ut_teardown,
9357                         test_AES_GCM_auth_decryption_test_case_256_2),
9358                 TEST_CASE_ST(ut_setup, ut_teardown,
9359                         test_AES_GCM_auth_decryption_test_case_256_3),
9360                 TEST_CASE_ST(ut_setup, ut_teardown,
9361                         test_AES_GCM_auth_decryption_test_case_256_4),
9362                 TEST_CASE_ST(ut_setup, ut_teardown,
9363                         test_AES_GCM_auth_decryption_test_case_256_5),
9364                 TEST_CASE_ST(ut_setup, ut_teardown,
9365                         test_AES_GCM_auth_decryption_test_case_256_6),
9366                 TEST_CASE_ST(ut_setup, ut_teardown,
9367                         test_AES_GCM_auth_decryption_test_case_256_7),
9368
9369                 /** AES GCM Authenticated Encryption big aad size */
9370                 TEST_CASE_ST(ut_setup, ut_teardown,
9371                         test_AES_GCM_auth_encryption_test_case_aad_1),
9372                 TEST_CASE_ST(ut_setup, ut_teardown,
9373                         test_AES_GCM_auth_encryption_test_case_aad_2),
9374
9375                 /** AES GCM Authenticated Decryption big aad size */
9376                 TEST_CASE_ST(ut_setup, ut_teardown,
9377                         test_AES_GCM_auth_decryption_test_case_aad_1),
9378                 TEST_CASE_ST(ut_setup, ut_teardown,
9379                         test_AES_GCM_auth_decryption_test_case_aad_2),
9380
9381                 /** Session-less tests */
9382                 TEST_CASE_ST(ut_setup, ut_teardown,
9383                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
9384                 TEST_CASE_ST(ut_setup, ut_teardown,
9385                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
9386
9387                 /** AES GMAC Authentication */
9388                 TEST_CASE_ST(ut_setup, ut_teardown,
9389                         test_AES_GMAC_authentication_test_case_1),
9390                 TEST_CASE_ST(ut_setup, ut_teardown,
9391                         test_AES_GMAC_authentication_verify_test_case_1),
9392                 TEST_CASE_ST(ut_setup, ut_teardown,
9393                         test_AES_GMAC_authentication_test_case_2),
9394                 TEST_CASE_ST(ut_setup, ut_teardown,
9395                         test_AES_GMAC_authentication_verify_test_case_2),
9396                 TEST_CASE_ST(ut_setup, ut_teardown,
9397                         test_AES_GMAC_authentication_test_case_3),
9398                 TEST_CASE_ST(ut_setup, ut_teardown,
9399                         test_AES_GMAC_authentication_verify_test_case_3),
9400 #endif /* IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0) */
9401
9402                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
9403                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all),
9404                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all),
9405                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all),
9406                 TEST_CASE_ST(ut_setup, ut_teardown,
9407                                                 test_DES_cipheronly_mb_all),
9408                 TEST_CASE_ST(ut_setup, ut_teardown,
9409                                                 test_DES_docsis_mb_all),
9410                 TEST_CASE_ST(ut_setup, ut_teardown,
9411                                                 test_3DES_cipheronly_mb_all),
9412                 TEST_CASE_ST(ut_setup, ut_teardown,
9413                         test_AES_CCM_authenticated_encryption_test_case_128_1),
9414                 TEST_CASE_ST(ut_setup, ut_teardown,
9415                         test_AES_CCM_authenticated_decryption_test_case_128_1),
9416                 TEST_CASE_ST(ut_setup, ut_teardown,
9417                         test_AES_CCM_authenticated_encryption_test_case_128_2),
9418                 TEST_CASE_ST(ut_setup, ut_teardown,
9419                         test_AES_CCM_authenticated_decryption_test_case_128_2),
9420                 TEST_CASE_ST(ut_setup, ut_teardown,
9421                         test_AES_CCM_authenticated_encryption_test_case_128_3),
9422                 TEST_CASE_ST(ut_setup, ut_teardown,
9423                         test_AES_CCM_authenticated_decryption_test_case_128_3),
9424
9425                 TEST_CASES_END() /**< NULL terminate unit test array */
9426         }
9427 };
9428
9429 static struct unit_test_suite cryptodev_openssl_testsuite  = {
9430         .suite_name = "Crypto Device OPENSSL Unit Test Suite",
9431         .setup = testsuite_setup,
9432         .teardown = testsuite_teardown,
9433         .unit_test_cases = {
9434                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
9435                 TEST_CASE_ST(ut_setup, ut_teardown,
9436                                 test_multi_session_random_usage),
9437                 TEST_CASE_ST(ut_setup, ut_teardown,
9438                                 test_AES_chain_openssl_all),
9439                 TEST_CASE_ST(ut_setup, ut_teardown,
9440                                 test_AES_cipheronly_openssl_all),
9441                 TEST_CASE_ST(ut_setup, ut_teardown,
9442                                 test_3DES_chain_openssl_all),
9443                 TEST_CASE_ST(ut_setup, ut_teardown,
9444                                 test_3DES_cipheronly_openssl_all),
9445                 TEST_CASE_ST(ut_setup, ut_teardown,
9446                                 test_DES_cipheronly_openssl_all),
9447                 TEST_CASE_ST(ut_setup, ut_teardown,
9448                                 test_DES_docsis_openssl_all),
9449                 TEST_CASE_ST(ut_setup, ut_teardown,
9450                                 test_authonly_openssl_all),
9451
9452                 /** AES GCM Authenticated Encryption */
9453                 TEST_CASE_ST(ut_setup, ut_teardown,
9454                         test_AES_GCM_authenticated_encryption_test_case_1),
9455                 TEST_CASE_ST(ut_setup, ut_teardown,
9456                         test_AES_GCM_authenticated_encryption_test_case_2),
9457                 TEST_CASE_ST(ut_setup, ut_teardown,
9458                         test_AES_GCM_authenticated_encryption_test_case_3),
9459                 TEST_CASE_ST(ut_setup, ut_teardown,
9460                         test_AES_GCM_authenticated_encryption_test_case_4),
9461                 TEST_CASE_ST(ut_setup, ut_teardown,
9462                         test_AES_GCM_authenticated_encryption_test_case_5),
9463                 TEST_CASE_ST(ut_setup, ut_teardown,
9464                         test_AES_GCM_authenticated_encryption_test_case_6),
9465                 TEST_CASE_ST(ut_setup, ut_teardown,
9466                         test_AES_GCM_authenticated_encryption_test_case_7),
9467
9468                 /** AES GCM Authenticated Decryption */
9469                 TEST_CASE_ST(ut_setup, ut_teardown,
9470                         test_AES_GCM_authenticated_decryption_test_case_1),
9471                 TEST_CASE_ST(ut_setup, ut_teardown,
9472                         test_AES_GCM_authenticated_decryption_test_case_2),
9473                 TEST_CASE_ST(ut_setup, ut_teardown,
9474                         test_AES_GCM_authenticated_decryption_test_case_3),
9475                 TEST_CASE_ST(ut_setup, ut_teardown,
9476                         test_AES_GCM_authenticated_decryption_test_case_4),
9477                 TEST_CASE_ST(ut_setup, ut_teardown,
9478                         test_AES_GCM_authenticated_decryption_test_case_5),
9479                 TEST_CASE_ST(ut_setup, ut_teardown,
9480                         test_AES_GCM_authenticated_decryption_test_case_6),
9481                 TEST_CASE_ST(ut_setup, ut_teardown,
9482                         test_AES_GCM_authenticated_decryption_test_case_7),
9483
9484
9485                 /** AES GCM Authenticated Encryption 192 bits key */
9486                 TEST_CASE_ST(ut_setup, ut_teardown,
9487                         test_AES_GCM_auth_encryption_test_case_192_1),
9488                 TEST_CASE_ST(ut_setup, ut_teardown,
9489                         test_AES_GCM_auth_encryption_test_case_192_2),
9490                 TEST_CASE_ST(ut_setup, ut_teardown,
9491                         test_AES_GCM_auth_encryption_test_case_192_3),
9492                 TEST_CASE_ST(ut_setup, ut_teardown,
9493                         test_AES_GCM_auth_encryption_test_case_192_4),
9494                 TEST_CASE_ST(ut_setup, ut_teardown,
9495                         test_AES_GCM_auth_encryption_test_case_192_5),
9496                 TEST_CASE_ST(ut_setup, ut_teardown,
9497                         test_AES_GCM_auth_encryption_test_case_192_6),
9498                 TEST_CASE_ST(ut_setup, ut_teardown,
9499                         test_AES_GCM_auth_encryption_test_case_192_7),
9500
9501                 /** AES GCM Authenticated Decryption 192 bits key */
9502                 TEST_CASE_ST(ut_setup, ut_teardown,
9503                         test_AES_GCM_auth_decryption_test_case_192_1),
9504                 TEST_CASE_ST(ut_setup, ut_teardown,
9505                         test_AES_GCM_auth_decryption_test_case_192_2),
9506                 TEST_CASE_ST(ut_setup, ut_teardown,
9507                         test_AES_GCM_auth_decryption_test_case_192_3),
9508                 TEST_CASE_ST(ut_setup, ut_teardown,
9509                         test_AES_GCM_auth_decryption_test_case_192_4),
9510                 TEST_CASE_ST(ut_setup, ut_teardown,
9511                         test_AES_GCM_auth_decryption_test_case_192_5),
9512                 TEST_CASE_ST(ut_setup, ut_teardown,
9513                         test_AES_GCM_auth_decryption_test_case_192_6),
9514                 TEST_CASE_ST(ut_setup, ut_teardown,
9515                         test_AES_GCM_auth_decryption_test_case_192_7),
9516
9517                 /** AES GCM Authenticated Encryption 256 bits key */
9518                 TEST_CASE_ST(ut_setup, ut_teardown,
9519                         test_AES_GCM_auth_encryption_test_case_256_1),
9520                 TEST_CASE_ST(ut_setup, ut_teardown,
9521                         test_AES_GCM_auth_encryption_test_case_256_2),
9522                 TEST_CASE_ST(ut_setup, ut_teardown,
9523                         test_AES_GCM_auth_encryption_test_case_256_3),
9524                 TEST_CASE_ST(ut_setup, ut_teardown,
9525                         test_AES_GCM_auth_encryption_test_case_256_4),
9526                 TEST_CASE_ST(ut_setup, ut_teardown,
9527                         test_AES_GCM_auth_encryption_test_case_256_5),
9528                 TEST_CASE_ST(ut_setup, ut_teardown,
9529                         test_AES_GCM_auth_encryption_test_case_256_6),
9530                 TEST_CASE_ST(ut_setup, ut_teardown,
9531                         test_AES_GCM_auth_encryption_test_case_256_7),
9532
9533                 /** AES GCM Authenticated Decryption 256 bits key */
9534                 TEST_CASE_ST(ut_setup, ut_teardown,
9535                         test_AES_GCM_auth_decryption_test_case_256_1),
9536                 TEST_CASE_ST(ut_setup, ut_teardown,
9537                         test_AES_GCM_auth_decryption_test_case_256_2),
9538                 TEST_CASE_ST(ut_setup, ut_teardown,
9539                         test_AES_GCM_auth_decryption_test_case_256_3),
9540                 TEST_CASE_ST(ut_setup, ut_teardown,
9541                         test_AES_GCM_auth_decryption_test_case_256_4),
9542                 TEST_CASE_ST(ut_setup, ut_teardown,
9543                         test_AES_GCM_auth_decryption_test_case_256_5),
9544                 TEST_CASE_ST(ut_setup, ut_teardown,
9545                         test_AES_GCM_auth_decryption_test_case_256_6),
9546                 TEST_CASE_ST(ut_setup, ut_teardown,
9547                         test_AES_GCM_auth_decryption_test_case_256_7),
9548
9549                 /** AES GMAC Authentication */
9550                 TEST_CASE_ST(ut_setup, ut_teardown,
9551                         test_AES_GMAC_authentication_test_case_1),
9552                 TEST_CASE_ST(ut_setup, ut_teardown,
9553                         test_AES_GMAC_authentication_verify_test_case_1),
9554                 TEST_CASE_ST(ut_setup, ut_teardown,
9555                         test_AES_GMAC_authentication_test_case_2),
9556                 TEST_CASE_ST(ut_setup, ut_teardown,
9557                         test_AES_GMAC_authentication_verify_test_case_2),
9558                 TEST_CASE_ST(ut_setup, ut_teardown,
9559                         test_AES_GMAC_authentication_test_case_3),
9560                 TEST_CASE_ST(ut_setup, ut_teardown,
9561                         test_AES_GMAC_authentication_verify_test_case_3),
9562                 TEST_CASE_ST(ut_setup, ut_teardown,
9563                         test_AES_GMAC_authentication_test_case_4),
9564                 TEST_CASE_ST(ut_setup, ut_teardown,
9565                         test_AES_GMAC_authentication_verify_test_case_4),
9566
9567                 /** AES CCM Authenticated Encryption 128 bits key */
9568                 TEST_CASE_ST(ut_setup, ut_teardown,
9569                         test_AES_CCM_authenticated_encryption_test_case_128_1),
9570                 TEST_CASE_ST(ut_setup, ut_teardown,
9571                         test_AES_CCM_authenticated_encryption_test_case_128_2),
9572                 TEST_CASE_ST(ut_setup, ut_teardown,
9573                         test_AES_CCM_authenticated_encryption_test_case_128_3),
9574
9575                 /** AES CCM Authenticated Decryption 128 bits key*/
9576                 TEST_CASE_ST(ut_setup, ut_teardown,
9577                         test_AES_CCM_authenticated_decryption_test_case_128_1),
9578                 TEST_CASE_ST(ut_setup, ut_teardown,
9579                         test_AES_CCM_authenticated_decryption_test_case_128_2),
9580                 TEST_CASE_ST(ut_setup, ut_teardown,
9581                         test_AES_CCM_authenticated_decryption_test_case_128_3),
9582
9583                 /** AES CCM Authenticated Encryption 192 bits key */
9584                 TEST_CASE_ST(ut_setup, ut_teardown,
9585                         test_AES_CCM_authenticated_encryption_test_case_192_1),
9586                 TEST_CASE_ST(ut_setup, ut_teardown,
9587                         test_AES_CCM_authenticated_encryption_test_case_192_2),
9588                 TEST_CASE_ST(ut_setup, ut_teardown,
9589                         test_AES_CCM_authenticated_encryption_test_case_192_3),
9590
9591                 /** AES CCM Authenticated Decryption 192 bits key*/
9592                 TEST_CASE_ST(ut_setup, ut_teardown,
9593                         test_AES_CCM_authenticated_decryption_test_case_192_1),
9594                 TEST_CASE_ST(ut_setup, ut_teardown,
9595                         test_AES_CCM_authenticated_decryption_test_case_192_2),
9596                 TEST_CASE_ST(ut_setup, ut_teardown,
9597                         test_AES_CCM_authenticated_decryption_test_case_192_3),
9598
9599                 /** AES CCM Authenticated Encryption 256 bits key */
9600                 TEST_CASE_ST(ut_setup, ut_teardown,
9601                         test_AES_CCM_authenticated_encryption_test_case_256_1),
9602                 TEST_CASE_ST(ut_setup, ut_teardown,
9603                         test_AES_CCM_authenticated_encryption_test_case_256_2),
9604                 TEST_CASE_ST(ut_setup, ut_teardown,
9605                         test_AES_CCM_authenticated_encryption_test_case_256_3),
9606
9607                 /** AES CCM Authenticated Decryption 256 bits key*/
9608                 TEST_CASE_ST(ut_setup, ut_teardown,
9609                         test_AES_CCM_authenticated_decryption_test_case_256_1),
9610                 TEST_CASE_ST(ut_setup, ut_teardown,
9611                         test_AES_CCM_authenticated_decryption_test_case_256_2),
9612                 TEST_CASE_ST(ut_setup, ut_teardown,
9613                         test_AES_CCM_authenticated_decryption_test_case_256_3),
9614
9615                 /** Scatter-Gather */
9616                 TEST_CASE_ST(ut_setup, ut_teardown,
9617                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
9618
9619                 /** Negative tests */
9620                 TEST_CASE_ST(ut_setup, ut_teardown,
9621                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
9622                 TEST_CASE_ST(ut_setup, ut_teardown,
9623                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
9624                 TEST_CASE_ST(ut_setup, ut_teardown,
9625                         authentication_verify_AES128_GMAC_fail_data_corrupt),
9626                 TEST_CASE_ST(ut_setup, ut_teardown,
9627                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
9628                 TEST_CASE_ST(ut_setup, ut_teardown,
9629                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
9630                 TEST_CASE_ST(ut_setup, ut_teardown,
9631                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
9632
9633                 TEST_CASES_END() /**< NULL terminate unit test array */
9634         }
9635 };
9636
9637 static struct unit_test_suite cryptodev_aesni_gcm_testsuite  = {
9638         .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
9639         .setup = testsuite_setup,
9640         .teardown = testsuite_teardown,
9641         .unit_test_cases = {
9642                 /** AES GCM Authenticated Encryption */
9643                 TEST_CASE_ST(ut_setup, ut_teardown,
9644                         test_AES_GCM_authenticated_encryption_test_case_1),
9645                 TEST_CASE_ST(ut_setup, ut_teardown,
9646                         test_AES_GCM_authenticated_encryption_test_case_2),
9647                 TEST_CASE_ST(ut_setup, ut_teardown,
9648                         test_AES_GCM_authenticated_encryption_test_case_3),
9649                 TEST_CASE_ST(ut_setup, ut_teardown,
9650                         test_AES_GCM_authenticated_encryption_test_case_4),
9651                 TEST_CASE_ST(ut_setup, ut_teardown,
9652                         test_AES_GCM_authenticated_encryption_test_case_5),
9653                 TEST_CASE_ST(ut_setup, ut_teardown,
9654                         test_AES_GCM_authenticated_encryption_test_case_6),
9655                 TEST_CASE_ST(ut_setup, ut_teardown,
9656                         test_AES_GCM_authenticated_encryption_test_case_7),
9657
9658                 /** AES GCM Authenticated Decryption */
9659                 TEST_CASE_ST(ut_setup, ut_teardown,
9660                         test_AES_GCM_authenticated_decryption_test_case_1),
9661                 TEST_CASE_ST(ut_setup, ut_teardown,
9662                         test_AES_GCM_authenticated_decryption_test_case_2),
9663                 TEST_CASE_ST(ut_setup, ut_teardown,
9664                         test_AES_GCM_authenticated_decryption_test_case_3),
9665                 TEST_CASE_ST(ut_setup, ut_teardown,
9666                         test_AES_GCM_authenticated_decryption_test_case_4),
9667                 TEST_CASE_ST(ut_setup, ut_teardown,
9668                         test_AES_GCM_authenticated_decryption_test_case_5),
9669                 TEST_CASE_ST(ut_setup, ut_teardown,
9670                         test_AES_GCM_authenticated_decryption_test_case_6),
9671                 TEST_CASE_ST(ut_setup, ut_teardown,
9672                         test_AES_GCM_authenticated_decryption_test_case_7),
9673
9674                 /** AES GCM Authenticated Encryption 192 bits key */
9675                 TEST_CASE_ST(ut_setup, ut_teardown,
9676                         test_AES_GCM_auth_encryption_test_case_192_1),
9677                 TEST_CASE_ST(ut_setup, ut_teardown,
9678                         test_AES_GCM_auth_encryption_test_case_192_2),
9679                 TEST_CASE_ST(ut_setup, ut_teardown,
9680                         test_AES_GCM_auth_encryption_test_case_192_3),
9681                 TEST_CASE_ST(ut_setup, ut_teardown,
9682                         test_AES_GCM_auth_encryption_test_case_192_4),
9683                 TEST_CASE_ST(ut_setup, ut_teardown,
9684                         test_AES_GCM_auth_encryption_test_case_192_5),
9685                 TEST_CASE_ST(ut_setup, ut_teardown,
9686                         test_AES_GCM_auth_encryption_test_case_192_6),
9687                 TEST_CASE_ST(ut_setup, ut_teardown,
9688                         test_AES_GCM_auth_encryption_test_case_192_7),
9689
9690                 /** AES GCM Authenticated Decryption 192 bits key */
9691                 TEST_CASE_ST(ut_setup, ut_teardown,
9692                         test_AES_GCM_auth_decryption_test_case_192_1),
9693                 TEST_CASE_ST(ut_setup, ut_teardown,
9694                         test_AES_GCM_auth_decryption_test_case_192_2),
9695                 TEST_CASE_ST(ut_setup, ut_teardown,
9696                         test_AES_GCM_auth_decryption_test_case_192_3),
9697                 TEST_CASE_ST(ut_setup, ut_teardown,
9698                         test_AES_GCM_auth_decryption_test_case_192_4),
9699                 TEST_CASE_ST(ut_setup, ut_teardown,
9700                         test_AES_GCM_auth_decryption_test_case_192_5),
9701                 TEST_CASE_ST(ut_setup, ut_teardown,
9702                         test_AES_GCM_auth_decryption_test_case_192_6),
9703                 TEST_CASE_ST(ut_setup, ut_teardown,
9704                         test_AES_GCM_auth_decryption_test_case_192_7),
9705
9706                 /** AES GCM Authenticated Encryption 256 bits key */
9707                 TEST_CASE_ST(ut_setup, ut_teardown,
9708                         test_AES_GCM_auth_encryption_test_case_256_1),
9709                 TEST_CASE_ST(ut_setup, ut_teardown,
9710                         test_AES_GCM_auth_encryption_test_case_256_2),
9711                 TEST_CASE_ST(ut_setup, ut_teardown,
9712                         test_AES_GCM_auth_encryption_test_case_256_3),
9713                 TEST_CASE_ST(ut_setup, ut_teardown,
9714                         test_AES_GCM_auth_encryption_test_case_256_4),
9715                 TEST_CASE_ST(ut_setup, ut_teardown,
9716                         test_AES_GCM_auth_encryption_test_case_256_5),
9717                 TEST_CASE_ST(ut_setup, ut_teardown,
9718                         test_AES_GCM_auth_encryption_test_case_256_6),
9719                 TEST_CASE_ST(ut_setup, ut_teardown,
9720                         test_AES_GCM_auth_encryption_test_case_256_7),
9721
9722                 /** AES GCM Authenticated Decryption 256 bits key */
9723                 TEST_CASE_ST(ut_setup, ut_teardown,
9724                         test_AES_GCM_auth_decryption_test_case_256_1),
9725                 TEST_CASE_ST(ut_setup, ut_teardown,
9726                         test_AES_GCM_auth_decryption_test_case_256_2),
9727                 TEST_CASE_ST(ut_setup, ut_teardown,
9728                         test_AES_GCM_auth_decryption_test_case_256_3),
9729                 TEST_CASE_ST(ut_setup, ut_teardown,
9730                         test_AES_GCM_auth_decryption_test_case_256_4),
9731                 TEST_CASE_ST(ut_setup, ut_teardown,
9732                         test_AES_GCM_auth_decryption_test_case_256_5),
9733                 TEST_CASE_ST(ut_setup, ut_teardown,
9734                         test_AES_GCM_auth_decryption_test_case_256_6),
9735                 TEST_CASE_ST(ut_setup, ut_teardown,
9736                         test_AES_GCM_auth_decryption_test_case_256_7),
9737
9738                 /** AES GCM Authenticated Encryption big aad size */
9739                 TEST_CASE_ST(ut_setup, ut_teardown,
9740                         test_AES_GCM_auth_encryption_test_case_aad_1),
9741                 TEST_CASE_ST(ut_setup, ut_teardown,
9742                         test_AES_GCM_auth_encryption_test_case_aad_2),
9743
9744                 /** AES GCM Authenticated Decryption big aad size */
9745                 TEST_CASE_ST(ut_setup, ut_teardown,
9746                         test_AES_GCM_auth_decryption_test_case_aad_1),
9747                 TEST_CASE_ST(ut_setup, ut_teardown,
9748                         test_AES_GCM_auth_decryption_test_case_aad_2),
9749
9750                 /** AES GMAC Authentication */
9751                 TEST_CASE_ST(ut_setup, ut_teardown,
9752                         test_AES_GMAC_authentication_test_case_1),
9753                 TEST_CASE_ST(ut_setup, ut_teardown,
9754                         test_AES_GMAC_authentication_verify_test_case_1),
9755                 TEST_CASE_ST(ut_setup, ut_teardown,
9756                         test_AES_GMAC_authentication_test_case_3),
9757                 TEST_CASE_ST(ut_setup, ut_teardown,
9758                         test_AES_GMAC_authentication_verify_test_case_3),
9759                 TEST_CASE_ST(ut_setup, ut_teardown,
9760                         test_AES_GMAC_authentication_test_case_4),
9761                 TEST_CASE_ST(ut_setup, ut_teardown,
9762                         test_AES_GMAC_authentication_verify_test_case_4),
9763
9764                 /** Negative tests */
9765                 TEST_CASE_ST(ut_setup, ut_teardown,
9766                         authentication_verify_AES128_GMAC_fail_data_corrupt),
9767                 TEST_CASE_ST(ut_setup, ut_teardown,
9768                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
9769
9770                 /** Out of place tests */
9771                 TEST_CASE_ST(ut_setup, ut_teardown,
9772                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
9773                 TEST_CASE_ST(ut_setup, ut_teardown,
9774                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
9775
9776                 /** Session-less tests */
9777                 TEST_CASE_ST(ut_setup, ut_teardown,
9778                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
9779                 TEST_CASE_ST(ut_setup, ut_teardown,
9780                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
9781
9782                 /** Scatter-Gather */
9783                 TEST_CASE_ST(ut_setup, ut_teardown,
9784                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
9785
9786                 TEST_CASES_END() /**< NULL terminate unit test array */
9787         }
9788 };
9789
9790 static struct unit_test_suite cryptodev_sw_kasumi_testsuite  = {
9791         .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
9792         .setup = testsuite_setup,
9793         .teardown = testsuite_teardown,
9794         .unit_test_cases = {
9795                 /** KASUMI encrypt only (UEA1) */
9796                 TEST_CASE_ST(ut_setup, ut_teardown,
9797                         test_kasumi_encryption_test_case_1),
9798                 TEST_CASE_ST(ut_setup, ut_teardown,
9799                         test_kasumi_encryption_test_case_1_sgl),
9800                 TEST_CASE_ST(ut_setup, ut_teardown,
9801                         test_kasumi_encryption_test_case_2),
9802                 TEST_CASE_ST(ut_setup, ut_teardown,
9803                         test_kasumi_encryption_test_case_3),
9804                 TEST_CASE_ST(ut_setup, ut_teardown,
9805                         test_kasumi_encryption_test_case_4),
9806                 TEST_CASE_ST(ut_setup, ut_teardown,
9807                         test_kasumi_encryption_test_case_5),
9808                 /** KASUMI decrypt only (UEA1) */
9809                 TEST_CASE_ST(ut_setup, ut_teardown,
9810                         test_kasumi_decryption_test_case_1),
9811                 TEST_CASE_ST(ut_setup, ut_teardown,
9812                         test_kasumi_decryption_test_case_2),
9813                 TEST_CASE_ST(ut_setup, ut_teardown,
9814                         test_kasumi_decryption_test_case_3),
9815                 TEST_CASE_ST(ut_setup, ut_teardown,
9816                         test_kasumi_decryption_test_case_4),
9817                 TEST_CASE_ST(ut_setup, ut_teardown,
9818                         test_kasumi_decryption_test_case_5),
9819
9820                 TEST_CASE_ST(ut_setup, ut_teardown,
9821                         test_kasumi_encryption_test_case_1_oop),
9822                 TEST_CASE_ST(ut_setup, ut_teardown,
9823                         test_kasumi_encryption_test_case_1_oop_sgl),
9824
9825
9826                 TEST_CASE_ST(ut_setup, ut_teardown,
9827                         test_kasumi_decryption_test_case_1_oop),
9828
9829                 /** KASUMI hash only (UIA1) */
9830                 TEST_CASE_ST(ut_setup, ut_teardown,
9831                         test_kasumi_hash_generate_test_case_1),
9832                 TEST_CASE_ST(ut_setup, ut_teardown,
9833                         test_kasumi_hash_generate_test_case_2),
9834                 TEST_CASE_ST(ut_setup, ut_teardown,
9835                         test_kasumi_hash_generate_test_case_3),
9836                 TEST_CASE_ST(ut_setup, ut_teardown,
9837                         test_kasumi_hash_generate_test_case_4),
9838                 TEST_CASE_ST(ut_setup, ut_teardown,
9839                         test_kasumi_hash_generate_test_case_5),
9840                 TEST_CASE_ST(ut_setup, ut_teardown,
9841                         test_kasumi_hash_generate_test_case_6),
9842                 TEST_CASE_ST(ut_setup, ut_teardown,
9843                         test_kasumi_hash_verify_test_case_1),
9844                 TEST_CASE_ST(ut_setup, ut_teardown,
9845                         test_kasumi_hash_verify_test_case_2),
9846                 TEST_CASE_ST(ut_setup, ut_teardown,
9847                         test_kasumi_hash_verify_test_case_3),
9848                 TEST_CASE_ST(ut_setup, ut_teardown,
9849                         test_kasumi_hash_verify_test_case_4),
9850                 TEST_CASE_ST(ut_setup, ut_teardown,
9851                         test_kasumi_hash_verify_test_case_5),
9852                 TEST_CASE_ST(ut_setup, ut_teardown,
9853                         test_kasumi_auth_cipher_test_case_1),
9854                 TEST_CASE_ST(ut_setup, ut_teardown,
9855                         test_kasumi_cipher_auth_test_case_1),
9856                 TEST_CASES_END() /**< NULL terminate unit test array */
9857         }
9858 };
9859 static struct unit_test_suite cryptodev_sw_snow3g_testsuite  = {
9860         .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
9861         .setup = testsuite_setup,
9862         .teardown = testsuite_teardown,
9863         .unit_test_cases = {
9864                 /** SNOW 3G encrypt only (UEA2) */
9865                 TEST_CASE_ST(ut_setup, ut_teardown,
9866                         test_snow3g_encryption_test_case_1),
9867                 TEST_CASE_ST(ut_setup, ut_teardown,
9868                         test_snow3g_encryption_test_case_2),
9869                 TEST_CASE_ST(ut_setup, ut_teardown,
9870                         test_snow3g_encryption_test_case_3),
9871                 TEST_CASE_ST(ut_setup, ut_teardown,
9872                         test_snow3g_encryption_test_case_4),
9873                 TEST_CASE_ST(ut_setup, ut_teardown,
9874                         test_snow3g_encryption_test_case_5),
9875
9876                 TEST_CASE_ST(ut_setup, ut_teardown,
9877                         test_snow3g_encryption_test_case_1_oop),
9878                 TEST_CASE_ST(ut_setup, ut_teardown,
9879                                 test_snow3g_encryption_test_case_1_oop_sgl),
9880                 TEST_CASE_ST(ut_setup, ut_teardown,
9881                         test_snow3g_decryption_test_case_1_oop),
9882
9883                 TEST_CASE_ST(ut_setup, ut_teardown,
9884                         test_snow3g_encryption_test_case_1_offset_oop),
9885
9886                 /** SNOW 3G decrypt only (UEA2) */
9887                 TEST_CASE_ST(ut_setup, ut_teardown,
9888                         test_snow3g_decryption_test_case_1),
9889                 TEST_CASE_ST(ut_setup, ut_teardown,
9890                         test_snow3g_decryption_test_case_2),
9891                 TEST_CASE_ST(ut_setup, ut_teardown,
9892                         test_snow3g_decryption_test_case_3),
9893                 TEST_CASE_ST(ut_setup, ut_teardown,
9894                         test_snow3g_decryption_test_case_4),
9895                 TEST_CASE_ST(ut_setup, ut_teardown,
9896                         test_snow3g_decryption_test_case_5),
9897                 TEST_CASE_ST(ut_setup, ut_teardown,
9898                         test_snow3g_hash_generate_test_case_1),
9899                 TEST_CASE_ST(ut_setup, ut_teardown,
9900                         test_snow3g_hash_generate_test_case_2),
9901                 TEST_CASE_ST(ut_setup, ut_teardown,
9902                         test_snow3g_hash_generate_test_case_3),
9903                 /* Tests with buffers which length is not byte-aligned */
9904                 TEST_CASE_ST(ut_setup, ut_teardown,
9905                         test_snow3g_hash_generate_test_case_4),
9906                 TEST_CASE_ST(ut_setup, ut_teardown,
9907                         test_snow3g_hash_generate_test_case_5),
9908                 TEST_CASE_ST(ut_setup, ut_teardown,
9909                         test_snow3g_hash_generate_test_case_6),
9910                 TEST_CASE_ST(ut_setup, ut_teardown,
9911                         test_snow3g_hash_verify_test_case_1),
9912                 TEST_CASE_ST(ut_setup, ut_teardown,
9913                         test_snow3g_hash_verify_test_case_2),
9914                 TEST_CASE_ST(ut_setup, ut_teardown,
9915                         test_snow3g_hash_verify_test_case_3),
9916                 /* Tests with buffers which length is not byte-aligned */
9917                 TEST_CASE_ST(ut_setup, ut_teardown,
9918                         test_snow3g_hash_verify_test_case_4),
9919                 TEST_CASE_ST(ut_setup, ut_teardown,
9920                         test_snow3g_hash_verify_test_case_5),
9921                 TEST_CASE_ST(ut_setup, ut_teardown,
9922                         test_snow3g_hash_verify_test_case_6),
9923                 TEST_CASE_ST(ut_setup, ut_teardown,
9924                         test_snow3g_cipher_auth_test_case_1),
9925                 TEST_CASE_ST(ut_setup, ut_teardown,
9926                         test_snow3g_auth_cipher_test_case_1),
9927
9928                 TEST_CASES_END() /**< NULL terminate unit test array */
9929         }
9930 };
9931
9932 static struct unit_test_suite cryptodev_sw_zuc_testsuite  = {
9933         .suite_name = "Crypto Device SW ZUC Unit Test Suite",
9934         .setup = testsuite_setup,
9935         .teardown = testsuite_teardown,
9936         .unit_test_cases = {
9937                 /** ZUC encrypt only (EEA3) */
9938                 TEST_CASE_ST(ut_setup, ut_teardown,
9939                         test_zuc_encryption_test_case_1),
9940                 TEST_CASE_ST(ut_setup, ut_teardown,
9941                         test_zuc_encryption_test_case_2),
9942                 TEST_CASE_ST(ut_setup, ut_teardown,
9943                         test_zuc_encryption_test_case_3),
9944                 TEST_CASE_ST(ut_setup, ut_teardown,
9945                         test_zuc_encryption_test_case_4),
9946                 TEST_CASE_ST(ut_setup, ut_teardown,
9947                         test_zuc_encryption_test_case_5),
9948                 TEST_CASE_ST(ut_setup, ut_teardown,
9949                         test_zuc_hash_generate_test_case_1),
9950                 TEST_CASE_ST(ut_setup, ut_teardown,
9951                         test_zuc_hash_generate_test_case_2),
9952                 TEST_CASE_ST(ut_setup, ut_teardown,
9953                         test_zuc_hash_generate_test_case_3),
9954                 TEST_CASE_ST(ut_setup, ut_teardown,
9955                         test_zuc_hash_generate_test_case_4),
9956                 TEST_CASE_ST(ut_setup, ut_teardown,
9957                         test_zuc_hash_generate_test_case_5),
9958                 TEST_CASE_ST(ut_setup, ut_teardown,
9959                         test_zuc_encryption_test_case_6_sgl),
9960                 TEST_CASES_END() /**< NULL terminate unit test array */
9961         }
9962 };
9963
9964 static struct unit_test_suite cryptodev_caam_jr_testsuite  = {
9965         .suite_name = "Crypto CAAM JR Unit Test Suite",
9966         .setup = testsuite_setup,
9967         .teardown = testsuite_teardown,
9968         .unit_test_cases = {
9969                 TEST_CASE_ST(ut_setup, ut_teardown,
9970                              test_device_configure_invalid_dev_id),
9971                 TEST_CASE_ST(ut_setup, ut_teardown,
9972                              test_multi_session),
9973
9974                 TEST_CASE_ST(ut_setup, ut_teardown,
9975                              test_AES_chain_caam_jr_all),
9976                 TEST_CASE_ST(ut_setup, ut_teardown,
9977                              test_3DES_chain_caam_jr_all),
9978                 TEST_CASE_ST(ut_setup, ut_teardown,
9979                              test_AES_cipheronly_caam_jr_all),
9980                 TEST_CASE_ST(ut_setup, ut_teardown,
9981                              test_3DES_cipheronly_caam_jr_all),
9982                 TEST_CASE_ST(ut_setup, ut_teardown,
9983                              test_authonly_caam_jr_all),
9984
9985                 TEST_CASES_END() /**< NULL terminate unit test array */
9986         }
9987 };
9988
9989 static struct unit_test_suite cryptodev_dpaa_sec_testsuite  = {
9990         .suite_name = "Crypto DPAA_SEC Unit Test Suite",
9991         .setup = testsuite_setup,
9992         .teardown = testsuite_teardown,
9993         .unit_test_cases = {
9994                 TEST_CASE_ST(ut_setup, ut_teardown,
9995                              test_device_configure_invalid_dev_id),
9996                 TEST_CASE_ST(ut_setup, ut_teardown,
9997                              test_multi_session),
9998
9999                 TEST_CASE_ST(ut_setup, ut_teardown,
10000                              test_AES_chain_dpaa_sec_all),
10001                 TEST_CASE_ST(ut_setup, ut_teardown,
10002                              test_3DES_chain_dpaa_sec_all),
10003                 TEST_CASE_ST(ut_setup, ut_teardown,
10004                              test_AES_cipheronly_dpaa_sec_all),
10005                 TEST_CASE_ST(ut_setup, ut_teardown,
10006                              test_3DES_cipheronly_dpaa_sec_all),
10007                 TEST_CASE_ST(ut_setup, ut_teardown,
10008                              test_authonly_dpaa_sec_all),
10009
10010                 /** AES GCM Authenticated Encryption */
10011                 TEST_CASE_ST(ut_setup, ut_teardown,
10012                         test_AES_GCM_authenticated_encryption_test_case_1),
10013                 TEST_CASE_ST(ut_setup, ut_teardown,
10014                         test_AES_GCM_authenticated_encryption_test_case_2),
10015                 TEST_CASE_ST(ut_setup, ut_teardown,
10016                         test_AES_GCM_authenticated_encryption_test_case_3),
10017                 TEST_CASE_ST(ut_setup, ut_teardown,
10018                         test_AES_GCM_authenticated_encryption_test_case_4),
10019                 TEST_CASE_ST(ut_setup, ut_teardown,
10020                         test_AES_GCM_authenticated_encryption_test_case_5),
10021                 TEST_CASE_ST(ut_setup, ut_teardown,
10022                         test_AES_GCM_authenticated_encryption_test_case_6),
10023                 TEST_CASE_ST(ut_setup, ut_teardown,
10024                         test_AES_GCM_authenticated_encryption_test_case_7),
10025
10026                 /** AES GCM Authenticated Decryption */
10027                 TEST_CASE_ST(ut_setup, ut_teardown,
10028                         test_AES_GCM_authenticated_decryption_test_case_1),
10029                 TEST_CASE_ST(ut_setup, ut_teardown,
10030                         test_AES_GCM_authenticated_decryption_test_case_2),
10031                 TEST_CASE_ST(ut_setup, ut_teardown,
10032                         test_AES_GCM_authenticated_decryption_test_case_3),
10033                 TEST_CASE_ST(ut_setup, ut_teardown,
10034                         test_AES_GCM_authenticated_decryption_test_case_4),
10035                 TEST_CASE_ST(ut_setup, ut_teardown,
10036                         test_AES_GCM_authenticated_decryption_test_case_5),
10037                 TEST_CASE_ST(ut_setup, ut_teardown,
10038                         test_AES_GCM_authenticated_decryption_test_case_6),
10039                 TEST_CASE_ST(ut_setup, ut_teardown,
10040                         test_AES_GCM_authenticated_decryption_test_case_7),
10041
10042                 /** AES GCM Authenticated Encryption 256 bits key */
10043                 TEST_CASE_ST(ut_setup, ut_teardown,
10044                         test_AES_GCM_auth_encryption_test_case_256_1),
10045                 TEST_CASE_ST(ut_setup, ut_teardown,
10046                         test_AES_GCM_auth_encryption_test_case_256_2),
10047                 TEST_CASE_ST(ut_setup, ut_teardown,
10048                         test_AES_GCM_auth_encryption_test_case_256_3),
10049                 TEST_CASE_ST(ut_setup, ut_teardown,
10050                         test_AES_GCM_auth_encryption_test_case_256_4),
10051                 TEST_CASE_ST(ut_setup, ut_teardown,
10052                         test_AES_GCM_auth_encryption_test_case_256_5),
10053                 TEST_CASE_ST(ut_setup, ut_teardown,
10054                         test_AES_GCM_auth_encryption_test_case_256_6),
10055                 TEST_CASE_ST(ut_setup, ut_teardown,
10056                         test_AES_GCM_auth_encryption_test_case_256_7),
10057
10058                 /** AES GCM Authenticated Decryption 256 bits key */
10059                 TEST_CASE_ST(ut_setup, ut_teardown,
10060                         test_AES_GCM_auth_decryption_test_case_256_1),
10061                 TEST_CASE_ST(ut_setup, ut_teardown,
10062                         test_AES_GCM_auth_decryption_test_case_256_2),
10063                 TEST_CASE_ST(ut_setup, ut_teardown,
10064                         test_AES_GCM_auth_decryption_test_case_256_3),
10065                 TEST_CASE_ST(ut_setup, ut_teardown,
10066                         test_AES_GCM_auth_decryption_test_case_256_4),
10067                 TEST_CASE_ST(ut_setup, ut_teardown,
10068                         test_AES_GCM_auth_decryption_test_case_256_5),
10069                 TEST_CASE_ST(ut_setup, ut_teardown,
10070                         test_AES_GCM_auth_decryption_test_case_256_6),
10071                 TEST_CASE_ST(ut_setup, ut_teardown,
10072                         test_AES_GCM_auth_decryption_test_case_256_7),
10073
10074                 /** Out of place tests */
10075                 TEST_CASE_ST(ut_setup, ut_teardown,
10076                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
10077                 TEST_CASE_ST(ut_setup, ut_teardown,
10078                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
10079
10080                 /** Scatter-Gather */
10081                 TEST_CASE_ST(ut_setup, ut_teardown,
10082                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
10083                 TEST_CASE_ST(ut_setup, ut_teardown,
10084                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
10085                 TEST_CASE_ST(ut_setup, ut_teardown,
10086                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
10087                 TEST_CASE_ST(ut_setup, ut_teardown,
10088                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
10089
10090                 TEST_CASES_END() /**< NULL terminate unit test array */
10091         }
10092 };
10093
10094 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite  = {
10095         .suite_name = "Crypto DPAA2_SEC Unit Test Suite",
10096         .setup = testsuite_setup,
10097         .teardown = testsuite_teardown,
10098         .unit_test_cases = {
10099                 TEST_CASE_ST(ut_setup, ut_teardown,
10100                         test_device_configure_invalid_dev_id),
10101                 TEST_CASE_ST(ut_setup, ut_teardown,
10102                         test_multi_session),
10103
10104                 TEST_CASE_ST(ut_setup, ut_teardown,
10105                         test_AES_chain_dpaa2_sec_all),
10106                 TEST_CASE_ST(ut_setup, ut_teardown,
10107                         test_3DES_chain_dpaa2_sec_all),
10108                 TEST_CASE_ST(ut_setup, ut_teardown,
10109                         test_AES_cipheronly_dpaa2_sec_all),
10110                 TEST_CASE_ST(ut_setup, ut_teardown,
10111                         test_3DES_cipheronly_dpaa2_sec_all),
10112                 TEST_CASE_ST(ut_setup, ut_teardown,
10113                         test_authonly_dpaa2_sec_all),
10114
10115                 /** AES GCM Authenticated Encryption */
10116                 TEST_CASE_ST(ut_setup, ut_teardown,
10117                         test_AES_GCM_authenticated_encryption_test_case_1),
10118                 TEST_CASE_ST(ut_setup, ut_teardown,
10119                         test_AES_GCM_authenticated_encryption_test_case_2),
10120                 TEST_CASE_ST(ut_setup, ut_teardown,
10121                         test_AES_GCM_authenticated_encryption_test_case_3),
10122                 TEST_CASE_ST(ut_setup, ut_teardown,
10123                         test_AES_GCM_authenticated_encryption_test_case_4),
10124                 TEST_CASE_ST(ut_setup, ut_teardown,
10125                         test_AES_GCM_authenticated_encryption_test_case_5),
10126                 TEST_CASE_ST(ut_setup, ut_teardown,
10127                         test_AES_GCM_authenticated_encryption_test_case_6),
10128                 TEST_CASE_ST(ut_setup, ut_teardown,
10129                         test_AES_GCM_authenticated_encryption_test_case_7),
10130
10131                 /** AES GCM Authenticated Decryption */
10132                 TEST_CASE_ST(ut_setup, ut_teardown,
10133                         test_AES_GCM_authenticated_decryption_test_case_1),
10134                 TEST_CASE_ST(ut_setup, ut_teardown,
10135                         test_AES_GCM_authenticated_decryption_test_case_2),
10136                 TEST_CASE_ST(ut_setup, ut_teardown,
10137                         test_AES_GCM_authenticated_decryption_test_case_3),
10138                 TEST_CASE_ST(ut_setup, ut_teardown,
10139                         test_AES_GCM_authenticated_decryption_test_case_4),
10140                 TEST_CASE_ST(ut_setup, ut_teardown,
10141                         test_AES_GCM_authenticated_decryption_test_case_5),
10142                 TEST_CASE_ST(ut_setup, ut_teardown,
10143                         test_AES_GCM_authenticated_decryption_test_case_6),
10144                 TEST_CASE_ST(ut_setup, ut_teardown,
10145                         test_AES_GCM_authenticated_decryption_test_case_7),
10146
10147                 /** AES GCM Authenticated Encryption 192 bits key */
10148                 TEST_CASE_ST(ut_setup, ut_teardown,
10149                         test_AES_GCM_auth_encryption_test_case_192_1),
10150                 TEST_CASE_ST(ut_setup, ut_teardown,
10151                         test_AES_GCM_auth_encryption_test_case_192_2),
10152                 TEST_CASE_ST(ut_setup, ut_teardown,
10153                         test_AES_GCM_auth_encryption_test_case_192_3),
10154                 TEST_CASE_ST(ut_setup, ut_teardown,
10155                         test_AES_GCM_auth_encryption_test_case_192_4),
10156                 TEST_CASE_ST(ut_setup, ut_teardown,
10157                         test_AES_GCM_auth_encryption_test_case_192_5),
10158                 TEST_CASE_ST(ut_setup, ut_teardown,
10159                         test_AES_GCM_auth_encryption_test_case_192_6),
10160                 TEST_CASE_ST(ut_setup, ut_teardown,
10161                         test_AES_GCM_auth_encryption_test_case_192_7),
10162
10163                 /** AES GCM Authenticated Decryption 192 bits key */
10164                 TEST_CASE_ST(ut_setup, ut_teardown,
10165                         test_AES_GCM_auth_decryption_test_case_192_1),
10166                 TEST_CASE_ST(ut_setup, ut_teardown,
10167                         test_AES_GCM_auth_decryption_test_case_192_2),
10168                 TEST_CASE_ST(ut_setup, ut_teardown,
10169                         test_AES_GCM_auth_decryption_test_case_192_3),
10170                 TEST_CASE_ST(ut_setup, ut_teardown,
10171                         test_AES_GCM_auth_decryption_test_case_192_4),
10172                 TEST_CASE_ST(ut_setup, ut_teardown,
10173                         test_AES_GCM_auth_decryption_test_case_192_5),
10174                 TEST_CASE_ST(ut_setup, ut_teardown,
10175                         test_AES_GCM_auth_decryption_test_case_192_6),
10176                 TEST_CASE_ST(ut_setup, ut_teardown,
10177                         test_AES_GCM_auth_decryption_test_case_192_7),
10178
10179                 /** AES GCM Authenticated Encryption 256 bits key */
10180                 TEST_CASE_ST(ut_setup, ut_teardown,
10181                         test_AES_GCM_auth_encryption_test_case_256_1),
10182                 TEST_CASE_ST(ut_setup, ut_teardown,
10183                         test_AES_GCM_auth_encryption_test_case_256_2),
10184                 TEST_CASE_ST(ut_setup, ut_teardown,
10185                         test_AES_GCM_auth_encryption_test_case_256_3),
10186                 TEST_CASE_ST(ut_setup, ut_teardown,
10187                         test_AES_GCM_auth_encryption_test_case_256_4),
10188                 TEST_CASE_ST(ut_setup, ut_teardown,
10189                         test_AES_GCM_auth_encryption_test_case_256_5),
10190                 TEST_CASE_ST(ut_setup, ut_teardown,
10191                         test_AES_GCM_auth_encryption_test_case_256_6),
10192                 TEST_CASE_ST(ut_setup, ut_teardown,
10193                         test_AES_GCM_auth_encryption_test_case_256_7),
10194
10195                 /** AES GCM Authenticated Decryption 256 bits key */
10196                 TEST_CASE_ST(ut_setup, ut_teardown,
10197                         test_AES_GCM_auth_decryption_test_case_256_1),
10198                 TEST_CASE_ST(ut_setup, ut_teardown,
10199                         test_AES_GCM_auth_decryption_test_case_256_2),
10200                 TEST_CASE_ST(ut_setup, ut_teardown,
10201                         test_AES_GCM_auth_decryption_test_case_256_3),
10202                 TEST_CASE_ST(ut_setup, ut_teardown,
10203                         test_AES_GCM_auth_decryption_test_case_256_4),
10204                 TEST_CASE_ST(ut_setup, ut_teardown,
10205                         test_AES_GCM_auth_decryption_test_case_256_5),
10206                 TEST_CASE_ST(ut_setup, ut_teardown,
10207                         test_AES_GCM_auth_decryption_test_case_256_6),
10208                 TEST_CASE_ST(ut_setup, ut_teardown,
10209                         test_AES_GCM_auth_decryption_test_case_256_7),
10210
10211                 /** Out of place tests */
10212                 TEST_CASE_ST(ut_setup, ut_teardown,
10213                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
10214                 TEST_CASE_ST(ut_setup, ut_teardown,
10215                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
10216
10217                 /** Scatter-Gather */
10218                 TEST_CASE_ST(ut_setup, ut_teardown,
10219                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
10220                 TEST_CASE_ST(ut_setup, ut_teardown,
10221                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
10222                 TEST_CASE_ST(ut_setup, ut_teardown,
10223                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
10224                 TEST_CASE_ST(ut_setup, ut_teardown,
10225                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
10226
10227                 TEST_CASES_END() /**< NULL terminate unit test array */
10228         }
10229 };
10230
10231 static struct unit_test_suite cryptodev_null_testsuite  = {
10232         .suite_name = "Crypto Device NULL Unit Test Suite",
10233         .setup = testsuite_setup,
10234         .teardown = testsuite_teardown,
10235         .unit_test_cases = {
10236                 TEST_CASE_ST(ut_setup, ut_teardown,
10237                         test_null_auth_only_operation),
10238                 TEST_CASE_ST(ut_setup, ut_teardown,
10239                         test_null_cipher_only_operation),
10240                 TEST_CASE_ST(ut_setup, ut_teardown,
10241                         test_null_cipher_auth_operation),
10242                 TEST_CASE_ST(ut_setup, ut_teardown,
10243                         test_null_auth_cipher_operation),
10244                 TEST_CASE_ST(ut_setup, ut_teardown,
10245                         test_null_invalid_operation),
10246                 TEST_CASE_ST(ut_setup, ut_teardown,
10247                         test_null_burst_operation),
10248
10249                 TEST_CASES_END() /**< NULL terminate unit test array */
10250         }
10251 };
10252
10253 static struct unit_test_suite cryptodev_armv8_testsuite  = {
10254         .suite_name = "Crypto Device ARMv8 Unit Test Suite",
10255         .setup = testsuite_setup,
10256         .teardown = testsuite_teardown,
10257         .unit_test_cases = {
10258                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_armv8_all),
10259
10260                 /** Negative tests */
10261                 TEST_CASE_ST(ut_setup, ut_teardown,
10262                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
10263                 TEST_CASE_ST(ut_setup, ut_teardown,
10264                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
10265
10266                 TEST_CASES_END() /**< NULL terminate unit test array */
10267         }
10268 };
10269
10270 static struct unit_test_suite cryptodev_mrvl_testsuite  = {
10271         .suite_name = "Crypto Device Marvell Component Test Suite",
10272         .setup = testsuite_setup,
10273         .teardown = testsuite_teardown,
10274         .unit_test_cases = {
10275                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
10276                 TEST_CASE_ST(ut_setup, ut_teardown,
10277                                 test_multi_session_random_usage),
10278                 TEST_CASE_ST(ut_setup, ut_teardown,
10279                                 test_AES_chain_mrvl_all),
10280                 TEST_CASE_ST(ut_setup, ut_teardown,
10281                                 test_AES_cipheronly_mrvl_all),
10282                 TEST_CASE_ST(ut_setup, ut_teardown,
10283                                 test_authonly_mrvl_all),
10284                 TEST_CASE_ST(ut_setup, ut_teardown,
10285                                 test_3DES_chain_mrvl_all),
10286                 TEST_CASE_ST(ut_setup, ut_teardown,
10287                                 test_3DES_cipheronly_mrvl_all),
10288
10289                 /** Negative tests */
10290                 TEST_CASE_ST(ut_setup, ut_teardown,
10291                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
10292                 TEST_CASE_ST(ut_setup, ut_teardown,
10293                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
10294                 TEST_CASE_ST(ut_setup, ut_teardown,
10295                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
10296                 TEST_CASE_ST(ut_setup, ut_teardown,
10297                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
10298
10299                 TEST_CASES_END() /**< NULL terminate unit test array */
10300         }
10301 };
10302
10303 static struct unit_test_suite cryptodev_ccp_testsuite  = {
10304         .suite_name = "Crypto Device CCP Unit Test Suite",
10305         .setup = testsuite_setup,
10306         .teardown = testsuite_teardown,
10307         .unit_test_cases = {
10308                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
10309                 TEST_CASE_ST(ut_setup, ut_teardown,
10310                                 test_multi_session_random_usage),
10311                 TEST_CASE_ST(ut_setup, ut_teardown,
10312                                 test_AES_chain_ccp_all),
10313                 TEST_CASE_ST(ut_setup, ut_teardown,
10314                                 test_AES_cipheronly_ccp_all),
10315                 TEST_CASE_ST(ut_setup, ut_teardown,
10316                                 test_3DES_chain_ccp_all),
10317                 TEST_CASE_ST(ut_setup, ut_teardown,
10318                                 test_3DES_cipheronly_ccp_all),
10319                 TEST_CASE_ST(ut_setup, ut_teardown,
10320                                 test_authonly_ccp_all),
10321
10322                 /** Negative tests */
10323                 TEST_CASE_ST(ut_setup, ut_teardown,
10324                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
10325                 TEST_CASE_ST(ut_setup, ut_teardown,
10326                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
10327                 TEST_CASE_ST(ut_setup, ut_teardown,
10328                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
10329                 TEST_CASE_ST(ut_setup, ut_teardown,
10330                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
10331
10332                 TEST_CASES_END() /**< NULL terminate unit test array */
10333         }
10334 };
10335
10336 static struct unit_test_suite cryptodev_octeontx_testsuite  = {
10337         .suite_name = "Crypto Device OCTEONTX Unit Test Suite",
10338         .setup = testsuite_setup,
10339         .teardown = testsuite_teardown,
10340         .unit_test_cases = {
10341                 TEST_CASE_ST(ut_setup, ut_teardown,
10342                         test_AES_chain_octeontx_all),
10343                 TEST_CASE_ST(ut_setup, ut_teardown,
10344                         test_AES_cipheronly_octeontx_all),
10345                 TEST_CASE_ST(ut_setup, ut_teardown,
10346                         test_3DES_chain_octeontx_all),
10347                 TEST_CASE_ST(ut_setup, ut_teardown,
10348                         test_3DES_cipheronly_octeontx_all),
10349                 TEST_CASE_ST(ut_setup, ut_teardown,
10350                         test_authonly_octeontx_all),
10351
10352                 /** AES GCM Authenticated Encryption */
10353                 TEST_CASE_ST(ut_setup, ut_teardown,
10354                         test_AES_GCM_authenticated_encryption_test_case_1),
10355                 TEST_CASE_ST(ut_setup, ut_teardown,
10356                         test_AES_GCM_authenticated_encryption_test_case_2),
10357                 TEST_CASE_ST(ut_setup, ut_teardown,
10358                         test_AES_GCM_authenticated_encryption_test_case_3),
10359                 TEST_CASE_ST(ut_setup, ut_teardown,
10360                         test_AES_GCM_authenticated_encryption_test_case_4),
10361                 TEST_CASE_ST(ut_setup, ut_teardown,
10362                         test_AES_GCM_authenticated_encryption_test_case_5),
10363                 TEST_CASE_ST(ut_setup, ut_teardown,
10364                         test_AES_GCM_authenticated_encryption_test_case_6),
10365                 TEST_CASE_ST(ut_setup, ut_teardown,
10366                         test_AES_GCM_authenticated_encryption_test_case_7),
10367
10368                 /** AES GCM Authenticated Decryption */
10369                 TEST_CASE_ST(ut_setup, ut_teardown,
10370                         test_AES_GCM_authenticated_decryption_test_case_1),
10371                 TEST_CASE_ST(ut_setup, ut_teardown,
10372                         test_AES_GCM_authenticated_decryption_test_case_2),
10373                 TEST_CASE_ST(ut_setup, ut_teardown,
10374                         test_AES_GCM_authenticated_decryption_test_case_3),
10375                 TEST_CASE_ST(ut_setup, ut_teardown,
10376                         test_AES_GCM_authenticated_decryption_test_case_4),
10377                 TEST_CASE_ST(ut_setup, ut_teardown,
10378                         test_AES_GCM_authenticated_decryption_test_case_5),
10379                 TEST_CASE_ST(ut_setup, ut_teardown,
10380                         test_AES_GCM_authenticated_decryption_test_case_6),
10381                 TEST_CASE_ST(ut_setup, ut_teardown,
10382                         test_AES_GCM_authenticated_decryption_test_case_7),
10383                 /** AES GMAC Authentication */
10384                 TEST_CASE_ST(ut_setup, ut_teardown,
10385                         test_AES_GMAC_authentication_test_case_1),
10386                 TEST_CASE_ST(ut_setup, ut_teardown,
10387                         test_AES_GMAC_authentication_verify_test_case_1),
10388                 TEST_CASE_ST(ut_setup, ut_teardown,
10389                         test_AES_GMAC_authentication_test_case_2),
10390                 TEST_CASE_ST(ut_setup, ut_teardown,
10391                         test_AES_GMAC_authentication_verify_test_case_2),
10392                 TEST_CASE_ST(ut_setup, ut_teardown,
10393                         test_AES_GMAC_authentication_test_case_3),
10394                 TEST_CASE_ST(ut_setup, ut_teardown,
10395                         test_AES_GMAC_authentication_verify_test_case_3),
10396
10397                 /** SNOW 3G encrypt only (UEA2) */
10398                 TEST_CASE_ST(ut_setup, ut_teardown,
10399                         test_snow3g_encryption_test_case_1),
10400                 TEST_CASE_ST(ut_setup, ut_teardown,
10401                         test_snow3g_encryption_test_case_2),
10402                 TEST_CASE_ST(ut_setup, ut_teardown,
10403                         test_snow3g_encryption_test_case_3),
10404                 TEST_CASE_ST(ut_setup, ut_teardown,
10405                         test_snow3g_encryption_test_case_4),
10406                 TEST_CASE_ST(ut_setup, ut_teardown,
10407                         test_snow3g_encryption_test_case_5),
10408
10409                 TEST_CASE_ST(ut_setup, ut_teardown,
10410                         test_snow3g_encryption_test_case_1_oop),
10411                 TEST_CASE_ST(ut_setup, ut_teardown,
10412                         test_snow3g_decryption_test_case_1_oop),
10413                 TEST_CASE_ST(ut_setup, ut_teardown,
10414                         test_snow3g_encryption_test_case_1_oop_sgl),
10415
10416                 /** SNOW 3G decrypt only (UEA2) */
10417                 TEST_CASE_ST(ut_setup, ut_teardown,
10418                         test_snow3g_decryption_test_case_1),
10419                 TEST_CASE_ST(ut_setup, ut_teardown,
10420                         test_snow3g_decryption_test_case_2),
10421                 TEST_CASE_ST(ut_setup, ut_teardown,
10422                         test_snow3g_decryption_test_case_3),
10423                 TEST_CASE_ST(ut_setup, ut_teardown,
10424                         test_snow3g_decryption_test_case_4),
10425                 TEST_CASE_ST(ut_setup, ut_teardown,
10426                         test_snow3g_decryption_test_case_5),
10427
10428                 TEST_CASE_ST(ut_setup, ut_teardown,
10429                         test_snow3g_hash_generate_test_case_1),
10430                 TEST_CASE_ST(ut_setup, ut_teardown,
10431                         test_snow3g_hash_generate_test_case_2),
10432                 TEST_CASE_ST(ut_setup, ut_teardown,
10433                         test_snow3g_hash_generate_test_case_3),
10434                 TEST_CASE_ST(ut_setup, ut_teardown,
10435                         test_snow3g_hash_verify_test_case_1),
10436                 TEST_CASE_ST(ut_setup, ut_teardown,
10437                         test_snow3g_hash_verify_test_case_2),
10438                 TEST_CASE_ST(ut_setup, ut_teardown,
10439                         test_snow3g_hash_verify_test_case_3),
10440
10441                 /** ZUC encrypt only (EEA3) */
10442                 TEST_CASE_ST(ut_setup, ut_teardown,
10443                         test_zuc_encryption_test_case_1),
10444                 TEST_CASE_ST(ut_setup, ut_teardown,
10445                         test_zuc_encryption_test_case_2),
10446                 TEST_CASE_ST(ut_setup, ut_teardown,
10447                         test_zuc_encryption_test_case_3),
10448                 TEST_CASE_ST(ut_setup, ut_teardown,
10449                         test_zuc_encryption_test_case_4),
10450                 TEST_CASE_ST(ut_setup, ut_teardown,
10451                         test_zuc_encryption_test_case_5),
10452                 TEST_CASE_ST(ut_setup, ut_teardown,
10453                         test_zuc_hash_generate_test_case_1),
10454                 TEST_CASE_ST(ut_setup, ut_teardown,
10455                         test_zuc_hash_generate_test_case_2),
10456                 TEST_CASE_ST(ut_setup, ut_teardown,
10457                         test_zuc_hash_generate_test_case_3),
10458                 TEST_CASE_ST(ut_setup, ut_teardown,
10459                         test_zuc_hash_generate_test_case_4),
10460                 TEST_CASE_ST(ut_setup, ut_teardown,
10461                         test_zuc_hash_generate_test_case_5),
10462                 TEST_CASE_ST(ut_setup, ut_teardown,
10463                         test_zuc_encryption_test_case_6_sgl),
10464
10465                 /** KASUMI encrypt only (UEA1) */
10466                 TEST_CASE_ST(ut_setup, ut_teardown,
10467                         test_kasumi_encryption_test_case_1),
10468                 TEST_CASE_ST(ut_setup, ut_teardown,
10469                         test_kasumi_encryption_test_case_2),
10470                 TEST_CASE_ST(ut_setup, ut_teardown,
10471                         test_kasumi_encryption_test_case_3),
10472                 TEST_CASE_ST(ut_setup, ut_teardown,
10473                         test_kasumi_encryption_test_case_4),
10474                 TEST_CASE_ST(ut_setup, ut_teardown,
10475                         test_kasumi_encryption_test_case_5),
10476                 TEST_CASE_ST(ut_setup, ut_teardown,
10477                         test_kasumi_encryption_test_case_1_sgl),
10478                 TEST_CASE_ST(ut_setup, ut_teardown,
10479                         test_kasumi_encryption_test_case_1_oop_sgl),
10480                 /** KASUMI decrypt only (UEA1) */
10481                 TEST_CASE_ST(ut_setup, ut_teardown,
10482                         test_kasumi_decryption_test_case_1),
10483                 TEST_CASE_ST(ut_setup, ut_teardown,
10484                         test_kasumi_decryption_test_case_2),
10485                 TEST_CASE_ST(ut_setup, ut_teardown,
10486                         test_kasumi_decryption_test_case_3),
10487                 TEST_CASE_ST(ut_setup, ut_teardown,
10488                         test_kasumi_decryption_test_case_4),
10489                 TEST_CASE_ST(ut_setup, ut_teardown,
10490                         test_kasumi_decryption_test_case_5),
10491
10492                 TEST_CASE_ST(ut_setup, ut_teardown,
10493                         test_kasumi_encryption_test_case_1_oop),
10494                 TEST_CASE_ST(ut_setup, ut_teardown,
10495                         test_kasumi_decryption_test_case_1_oop),
10496
10497                 /** KASUMI hash only (UIA1) */
10498                 TEST_CASE_ST(ut_setup, ut_teardown,
10499                         test_kasumi_hash_generate_test_case_1),
10500                 TEST_CASE_ST(ut_setup, ut_teardown,
10501                         test_kasumi_hash_generate_test_case_2),
10502                 TEST_CASE_ST(ut_setup, ut_teardown,
10503                         test_kasumi_hash_generate_test_case_3),
10504                 TEST_CASE_ST(ut_setup, ut_teardown,
10505                         test_kasumi_hash_generate_test_case_4),
10506                 TEST_CASE_ST(ut_setup, ut_teardown,
10507                         test_kasumi_hash_generate_test_case_5),
10508                 TEST_CASE_ST(ut_setup, ut_teardown,
10509                         test_kasumi_hash_generate_test_case_6),
10510                 TEST_CASE_ST(ut_setup, ut_teardown,
10511                         test_kasumi_hash_verify_test_case_1),
10512                 TEST_CASE_ST(ut_setup, ut_teardown,
10513                         test_kasumi_hash_verify_test_case_2),
10514                 TEST_CASE_ST(ut_setup, ut_teardown,
10515                         test_kasumi_hash_verify_test_case_3),
10516                 TEST_CASE_ST(ut_setup, ut_teardown,
10517                         test_kasumi_hash_verify_test_case_4),
10518                 TEST_CASE_ST(ut_setup, ut_teardown,
10519                         test_kasumi_hash_verify_test_case_5),
10520
10521                 /** NULL tests */
10522                 TEST_CASE_ST(ut_setup, ut_teardown,
10523                         test_null_cipher_only_operation),
10524                 TEST_CASE_ST(ut_setup, ut_teardown,
10525                         test_null_auth_only_operation),
10526                 TEST_CASE_ST(ut_setup, ut_teardown,
10527                         test_null_cipher_auth_operation),
10528                 TEST_CASE_ST(ut_setup, ut_teardown,
10529                         test_null_auth_cipher_operation),
10530
10531                 /** Negative tests */
10532                 TEST_CASE_ST(ut_setup, ut_teardown,
10533                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
10534                 TEST_CASE_ST(ut_setup, ut_teardown,
10535                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
10536                 TEST_CASE_ST(ut_setup, ut_teardown,
10537                         authentication_verify_AES128_GMAC_fail_data_corrupt),
10538                 TEST_CASE_ST(ut_setup, ut_teardown,
10539                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
10540                 TEST_CASE_ST(ut_setup, ut_teardown,
10541                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
10542                 TEST_CASE_ST(ut_setup, ut_teardown,
10543                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
10544                 TEST_CASES_END() /**< NULL terminate unit test array */
10545         }
10546 };
10547
10548 static int
10549 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
10550 {
10551         gbl_driver_id = rte_cryptodev_driver_id_get(
10552                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
10553
10554         if (gbl_driver_id == -1) {
10555                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check that both "
10556                 "CONFIG_RTE_LIBRTE_PMD_QAT and CONFIG_RTE_LIBRTE_PMD_QAT_SYM "
10557                 "are enabled in config file to run this testsuite.\n");
10558                 return TEST_SKIPPED;
10559         }
10560
10561         return unit_test_suite_runner(&cryptodev_qat_testsuite);
10562 }
10563
10564 static int
10565 test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
10566 {
10567         gbl_driver_id = rte_cryptodev_driver_id_get(
10568                         RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
10569
10570         if (gbl_driver_id == -1) {
10571                 RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded. Check if "
10572                                 "CONFIG_RTE_LIBRTE_PMD_VIRTIO_CRYPTO is enabled "
10573                                 "in config file to run this testsuite.\n");
10574                 return TEST_FAILED;
10575         }
10576
10577         return unit_test_suite_runner(&cryptodev_virtio_testsuite);
10578 }
10579
10580 static int
10581 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
10582 {
10583         gbl_driver_id = rte_cryptodev_driver_id_get(
10584                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
10585
10586         if (gbl_driver_id == -1) {
10587                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
10588                                 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
10589                                 "in config file to run this testsuite.\n");
10590                 return TEST_SKIPPED;
10591         }
10592
10593         return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
10594 }
10595
10596 static int
10597 test_cryptodev_openssl(void)
10598 {
10599         gbl_driver_id = rte_cryptodev_driver_id_get(
10600                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
10601
10602         if (gbl_driver_id == -1) {
10603                 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
10604                                 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
10605                                 "in config file to run this testsuite.\n");
10606                 return TEST_SKIPPED;
10607         }
10608
10609         return unit_test_suite_runner(&cryptodev_openssl_testsuite);
10610 }
10611
10612 static int
10613 test_cryptodev_aesni_gcm(void)
10614 {
10615         gbl_driver_id = rte_cryptodev_driver_id_get(
10616                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
10617
10618         if (gbl_driver_id == -1) {
10619                 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
10620                                 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
10621                                 "in config file to run this testsuite.\n");
10622                 return TEST_SKIPPED;
10623         }
10624
10625         return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
10626 }
10627
10628 static int
10629 test_cryptodev_null(void)
10630 {
10631         gbl_driver_id = rte_cryptodev_driver_id_get(
10632                         RTE_STR(CRYPTODEV_NAME_NULL_PMD));
10633
10634         if (gbl_driver_id == -1) {
10635                 RTE_LOG(ERR, USER1, "NULL PMD must be loaded. Check if "
10636                                 "CONFIG_RTE_LIBRTE_PMD_NULL is enabled "
10637                                 "in config file to run this testsuite.\n");
10638                 return TEST_SKIPPED;
10639         }
10640
10641         return unit_test_suite_runner(&cryptodev_null_testsuite);
10642 }
10643
10644 static int
10645 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
10646 {
10647         gbl_driver_id = rte_cryptodev_driver_id_get(
10648                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
10649
10650         if (gbl_driver_id == -1) {
10651                 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
10652                                 "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
10653                                 "in config file to run this testsuite.\n");
10654                 return TEST_SKIPPED;
10655         }
10656
10657         return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
10658 }
10659
10660 static int
10661 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
10662 {
10663         gbl_driver_id = rte_cryptodev_driver_id_get(
10664                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
10665
10666         if (gbl_driver_id == -1) {
10667                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
10668                                 "CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled "
10669                                 "in config file to run this testsuite.\n");
10670                 return TEST_SKIPPED;
10671         }
10672
10673         return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
10674 }
10675
10676 static int
10677 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
10678 {
10679         gbl_driver_id = rte_cryptodev_driver_id_get(
10680                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
10681
10682         if (gbl_driver_id == -1) {
10683                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
10684                                 "CONFIG_RTE_LIBRTE_PMD_ZUC is enabled "
10685                                 "in config file to run this testsuite.\n");
10686                 return TEST_SKIPPED;
10687         }
10688
10689         return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
10690 }
10691
10692 static int
10693 test_cryptodev_armv8(void)
10694 {
10695         gbl_driver_id = rte_cryptodev_driver_id_get(
10696                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
10697
10698         if (gbl_driver_id == -1) {
10699                 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
10700                                 "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
10701                                 "in config file to run this testsuite.\n");
10702                 return TEST_SKIPPED;
10703         }
10704
10705         return unit_test_suite_runner(&cryptodev_armv8_testsuite);
10706 }
10707
10708 static int
10709 test_cryptodev_mrvl(void)
10710 {
10711         gbl_driver_id = rte_cryptodev_driver_id_get(
10712                         RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
10713
10714         if (gbl_driver_id == -1) {
10715                 RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded. Check if "
10716                                 "CONFIG_RTE_LIBRTE_PMD_MVSAM_CRYPTO is enabled "
10717                                 "in config file to run this testsuite.\n");
10718                 return TEST_SKIPPED;
10719         }
10720
10721         return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
10722 }
10723
10724 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
10725
10726 static int
10727 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
10728 {
10729         gbl_driver_id = rte_cryptodev_driver_id_get(
10730                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
10731
10732         if (gbl_driver_id == -1) {
10733                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if "
10734                                 "CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled "
10735                                 "in config file to run this testsuite.\n");
10736                 return TEST_SKIPPED;
10737         }
10738
10739         if (rte_cryptodev_driver_id_get(
10740                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
10741                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
10742                         " enabled in config file to run this testsuite.\n");
10743                 return TEST_SKIPPED;
10744 }
10745         return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
10746 }
10747
10748 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
10749
10750 #endif
10751
10752 static int
10753 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
10754 {
10755         gbl_driver_id = rte_cryptodev_driver_id_get(
10756                         RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
10757
10758         if (gbl_driver_id == -1) {
10759                 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
10760                                 "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
10761                                 "in config file to run this testsuite.\n");
10762                 return TEST_SKIPPED;
10763         }
10764
10765         return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
10766 }
10767
10768 static int
10769 test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
10770 {
10771         gbl_driver_id = rte_cryptodev_driver_id_get(
10772                         RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
10773
10774         if (gbl_driver_id == -1) {
10775                 RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded. Check if "
10776                                 "CONFIG_RTE_LIBRTE_PMD_DPAA_SEC is enabled "
10777                                 "in config file to run this testsuite.\n");
10778                 return TEST_SKIPPED;
10779         }
10780
10781         return unit_test_suite_runner(&cryptodev_dpaa_sec_testsuite);
10782 }
10783
10784 static int
10785 test_cryptodev_ccp(void)
10786 {
10787         gbl_driver_id = rte_cryptodev_driver_id_get(
10788                         RTE_STR(CRYPTODEV_NAME_CCP_PMD));
10789
10790         if (gbl_driver_id == -1) {
10791                 RTE_LOG(ERR, USER1, "CCP PMD must be loaded. Check if "
10792                                 "CONFIG_RTE_LIBRTE_PMD_CCP is enabled "
10793                                 "in config file to run this testsuite.\n");
10794                 return TEST_FAILED;
10795         }
10796
10797         return unit_test_suite_runner(&cryptodev_ccp_testsuite);
10798 }
10799
10800 static int
10801 test_cryptodev_octeontx(void)
10802 {
10803         gbl_driver_id = rte_cryptodev_driver_id_get(
10804                         RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
10805         if (gbl_driver_id == -1) {
10806                 RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded. Check if "
10807                                 "CONFIG_RTE_LIBRTE_PMD_OCTEONTX_CRYPTO is "
10808                                 "enabled in config file to run this "
10809                                 "testsuite.\n");
10810                 return TEST_FAILED;
10811         }
10812         return unit_test_suite_runner(&cryptodev_octeontx_testsuite);
10813 }
10814
10815 static int
10816 test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
10817 {
10818         gbl_driver_id = rte_cryptodev_driver_id_get(
10819                         RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
10820
10821         if (gbl_driver_id == -1) {
10822                 RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded. Check if "
10823                                 "CONFIG_RTE_LIBRTE_PMD_CAAM_JR is enabled "
10824                                 "in config file to run this testsuite.\n");
10825                 return TEST_FAILED;
10826         }
10827
10828         return unit_test_suite_runner(&cryptodev_caam_jr_testsuite);
10829 }
10830
10831 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
10832 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
10833 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
10834 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
10835 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
10836 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
10837 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
10838 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
10839 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
10840 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
10841 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
10842 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
10843 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
10844 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
10845 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
10846 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);