app/test/test_cryptodev.c

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