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