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