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 #include "test_cryptodev_mixed_test_vectors.h"
  42 #ifdef RTE_LIBRTE_SECURITY
  43 #include "test_cryptodev_security_pdcp_test_vectors.h"
  44 #include "test_cryptodev_security_pdcp_test_func.h"
  45 #endif
  46
  47 #define VDEV_ARGS_SIZE 100
  48 #define MAX_NB_SESSIONS 4
  49
  50 #define IN_PLACE 0
  51 #define OUT_OF_PLACE 1
  52
  53 static int gbl_driver_id;
  54
  55 struct crypto_testsuite_params {
  56         struct rte_mempool *mbuf_pool;
  57         struct rte_mempool *large_mbuf_pool;
  58         struct rte_mempool *op_mpool;
  59         struct rte_mempool *session_mpool;
  60         struct rte_mempool *session_priv_mpool;
  61         struct rte_cryptodev_config conf;
  62         struct rte_cryptodev_qp_conf qp_conf;
  63
  64         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  65         uint8_t valid_dev_count;
  66 };
  67
  68 struct crypto_unittest_params {
  69         struct rte_crypto_sym_xform cipher_xform;
  70         struct rte_crypto_sym_xform auth_xform;
  71         struct rte_crypto_sym_xform aead_xform;
  72
  73         union {
  74                 struct rte_cryptodev_sym_session *sess;
  75 #ifdef RTE_LIBRTE_SECURITY
  76                 struct rte_security_session *sec_session;
  77 #endif
  78         };
  79 #ifdef RTE_LIBRTE_SECURITY
  80         enum rte_security_session_action_type type;
  81 #endif
  82         struct rte_crypto_op *op;
  83
  84         struct rte_mbuf *obuf, *ibuf;
  85
  86         uint8_t *digest;
  87 };
  88
  89 #define ALIGN_POW2_ROUNDUP(num, align) \
  90         (((num) + (align) - 1) & ~((align) - 1))
  91
  92 /*
  93  * Forward declarations.
  94  */
  95 static int
  96 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
  97                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
  98                 uint8_t *hmac_key);
  99
 100 static int
 101 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 102                 struct crypto_unittest_params *ut_params,
 103                 struct crypto_testsuite_params *ts_param,
 104                 const uint8_t *cipher,
 105                 const uint8_t *digest,
 106                 const uint8_t *iv);
 107
 108 static struct rte_mbuf *
 109 setup_test_string(struct rte_mempool *mpool,
 110                 const char *string, size_t len, uint8_t blocksize)
 111 {
 112         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 113         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 114
 115         memset(m->buf_addr, 0, m->buf_len);
 116         if (m) {
 117                 char *dst = rte_pktmbuf_append(m, t_len);
 118
 119                 if (!dst) {
 120                         rte_pktmbuf_free(m);
 121                         return NULL;
 122                 }
 123                 if (string != NULL)
 124                         rte_memcpy(dst, string, t_len);
 125                 else
 126                         memset(dst, 0, t_len);
 127         }
 128
 129         return m;
 130 }
 131
 132 /* Get number of bytes in X bits (rounding up) */
 133 static uint32_t
 134 ceil_byte_length(uint32_t num_bits)
 135 {
 136         if (num_bits % 8)
 137                 return ((num_bits >> 3) + 1);
 138         else
 139                 return (num_bits >> 3);
 140 }
 141
 142 static struct rte_crypto_op *
 143 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 144 {
 145         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 146                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 147                 return NULL;
 148         }
 149
 150         op = NULL;
 151
 152         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 153                 rte_pause();
 154
 155         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 156                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 157                 return NULL;
 158         }
 159
 160         return op;
 161 }
 162
 163 static struct crypto_testsuite_params testsuite_params = { NULL };
 164 static struct crypto_unittest_params unittest_params;
 165
 166 static int
 167 testsuite_setup(void)
 168 {
 169         struct crypto_testsuite_params *ts_params = &testsuite_params;
 170         struct rte_cryptodev_info info;
 171         uint32_t i = 0, nb_devs, dev_id;
 172         int ret;
 173         uint16_t qp_id;
 174
 175         memset(ts_params, 0, sizeof(*ts_params));
 176
 177         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 178         if (ts_params->mbuf_pool == NULL) {
 179                 /* Not already created so create */
 180                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 181                                 "CRYPTO_MBUFPOOL",
 182                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 183                                 rte_socket_id());
 184                 if (ts_params->mbuf_pool == NULL) {
 185                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 186                         return TEST_FAILED;
 187                 }
 188         }
 189
 190         ts_params->large_mbuf_pool = rte_mempool_lookup(
 191                         "CRYPTO_LARGE_MBUFPOOL");
 192         if (ts_params->large_mbuf_pool == NULL) {
 193                 /* Not already created so create */
 194                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 195                                 "CRYPTO_LARGE_MBUFPOOL",
 196                                 1, 0, 0, UINT16_MAX,
 197                                 rte_socket_id());
 198                 if (ts_params->large_mbuf_pool == NULL) {
 199                         RTE_LOG(ERR, USER1,
 200                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 201                         return TEST_FAILED;
 202                 }
 203         }
 204
 205         ts_params->op_mpool = rte_crypto_op_pool_create(
 206                         "MBUF_CRYPTO_SYM_OP_POOL",
 207                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 208                         NUM_MBUFS, MBUF_CACHE_SIZE,
 209                         DEFAULT_NUM_XFORMS *
 210                         sizeof(struct rte_crypto_sym_xform) +
 211                         MAXIMUM_IV_LENGTH,
 212                         rte_socket_id());
 213         if (ts_params->op_mpool == NULL) {
 214                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 215                 return TEST_FAILED;
 216         }
 217
 218         /* Create an AESNI MB device if required */
 219         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 220                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
 221                 nb_devs = rte_cryptodev_device_count_by_driver(
 222                                 rte_cryptodev_driver_id_get(
 223                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
 224                 if (nb_devs < 1) {
 225                         ret = rte_vdev_init(
 226                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
 227
 228                         TEST_ASSERT(ret == 0,
 229                                 "Failed to create instance of"
 230                                 " pmd : %s",
 231                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
 232                 }
 233         }
 234
 235         /* Create an AESNI GCM device if required */
 236         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 237                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
 238                 nb_devs = rte_cryptodev_device_count_by_driver(
 239                                 rte_cryptodev_driver_id_get(
 240                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
 241                 if (nb_devs < 1) {
 242                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 243                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
 244                                 "Failed to create instance of"
 245                                 " pmd : %s",
 246                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
 247                 }
 248         }
 249
 250         /* Create a SNOW 3G device if required */
 251         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 252                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
 253                 nb_devs = rte_cryptodev_device_count_by_driver(
 254                                 rte_cryptodev_driver_id_get(
 255                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
 256                 if (nb_devs < 1) {
 257                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 258                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
 259                                 "Failed to create instance of"
 260                                 " pmd : %s",
 261                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
 262                 }
 263         }
 264
 265         /* Create a KASUMI device if required */
 266         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 267                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) {
 268                 nb_devs = rte_cryptodev_device_count_by_driver(
 269                                 rte_cryptodev_driver_id_get(
 270                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)));
 271                 if (nb_devs < 1) {
 272                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 273                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
 274                                 "Failed to create instance of"
 275                                 " pmd : %s",
 276                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
 277                 }
 278         }
 279
 280         /* Create a ZUC device if required */
 281         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 282                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) {
 283                 nb_devs = rte_cryptodev_device_count_by_driver(
 284                                 rte_cryptodev_driver_id_get(
 285                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD)));
 286                 if (nb_devs < 1) {
 287                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 288                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
 289                                 "Failed to create instance of"
 290                                 " pmd : %s",
 291                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
 292                 }
 293         }
 294
 295         /* Create a NULL device if required */
 296         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 297                         RTE_STR(CRYPTODEV_NAME_NULL_PMD))) {
 298                 nb_devs = rte_cryptodev_device_count_by_driver(
 299                                 rte_cryptodev_driver_id_get(
 300                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD)));
 301                 if (nb_devs < 1) {
 302                         ret = rte_vdev_init(
 303                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
 304
 305                         TEST_ASSERT(ret == 0,
 306                                 "Failed to create instance of"
 307                                 " pmd : %s",
 308                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
 309                 }
 310         }
 311
 312         /* Create an OPENSSL device if required */
 313         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 314                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
 315                 nb_devs = rte_cryptodev_device_count_by_driver(
 316                                 rte_cryptodev_driver_id_get(
 317                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
 318                 if (nb_devs < 1) {
 319                         ret = rte_vdev_init(
 320                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
 321                                 NULL);
 322
 323                         TEST_ASSERT(ret == 0, "Failed to create "
 324                                 "instance of pmd : %s",
 325                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
 326                 }
 327         }
 328
 329         /* Create a ARMv8 device if required */
 330         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 331                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
 332                 nb_devs = rte_cryptodev_device_count_by_driver(
 333                                 rte_cryptodev_driver_id_get(
 334                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
 335                 if (nb_devs < 1) {
 336                         ret = rte_vdev_init(
 337                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
 338                                 NULL);
 339
 340                         TEST_ASSERT(ret == 0, "Failed to create "
 341                                 "instance of pmd : %s",
 342                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
 343                 }
 344         }
 345
 346         /* Create a MVSAM device if required */
 347         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 348                         RTE_STR(CRYPTODEV_NAME_MVSAM_PMD))) {
 349                 nb_devs = rte_cryptodev_device_count_by_driver(
 350                                 rte_cryptodev_driver_id_get(
 351                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)));
 352                 if (nb_devs < 1) {
 353                         ret = rte_vdev_init(
 354                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD),
 355                                 NULL);
 356
 357                         TEST_ASSERT(ret == 0, "Failed to create "
 358                                 "instance of pmd : %s",
 359                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
 360                 }
 361         }
 362
 363         /* Create an CCP device if required */
 364         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 365                         RTE_STR(CRYPTODEV_NAME_CCP_PMD))) {
 366                 nb_devs = rte_cryptodev_device_count_by_driver(
 367                                 rte_cryptodev_driver_id_get(
 368                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)));
 369                 if (nb_devs < 1) {
 370                         ret = rte_vdev_init(
 371                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD),
 372                                 NULL);
 373
 374                         TEST_ASSERT(ret == 0, "Failed to create "
 375                                 "instance of pmd : %s",
 376                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
 377                 }
 378         }
 379
 380 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
 381         char vdev_args[VDEV_ARGS_SIZE] = {""};
 382         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
 383                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
 384         uint16_t slave_core_count = 0;
 385         uint16_t socket_id = 0;
 386
 387         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 388                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
 389
 390                 /* Identify the Slave Cores
 391                  * Use 2 slave cores for the device args
 392                  */
 393                 RTE_LCORE_FOREACH_SLAVE(i) {
 394                         if (slave_core_count > 1)
 395                                 break;
 396                         snprintf(vdev_args, sizeof(vdev_args),
 397                                         "%s%d", temp_str, i);
 398                         strcpy(temp_str, vdev_args);
 399                         strlcat(temp_str, ";", sizeof(temp_str));
 400                         slave_core_count++;
 401                         socket_id = rte_lcore_to_socket_id(i);
 402                 }
 403                 if (slave_core_count != 2) {
 404                         RTE_LOG(ERR, USER1,
 405                                 "Cryptodev scheduler test require at least "
 406                                 "two slave cores to run. "
 407                                 "Please use the correct coremask.\n");
 408                         return TEST_FAILED;
 409                 }
 410                 strcpy(temp_str, vdev_args);
 411                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
 412                                 temp_str, socket_id);
 413                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
 414                 nb_devs = rte_cryptodev_device_count_by_driver(
 415                                 rte_cryptodev_driver_id_get(
 416                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
 417                 if (nb_devs < 1) {
 418                         ret = rte_vdev_init(
 419                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
 420                                         vdev_args);
 421                         TEST_ASSERT(ret == 0,
 422                                 "Failed to create instance %u of"
 423                                 " pmd : %s",
 424                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
 425                 }
 426         }
 427 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
 428
 429         nb_devs = rte_cryptodev_count();
 430         if (nb_devs < 1) {
 431                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 432                 return TEST_SKIPPED;
 433         }
 434
 435         /* Create list of valid crypto devs */
 436         for (i = 0; i < nb_devs; i++) {
 437                 rte_cryptodev_info_get(i, &info);
 438                 if (info.driver_id == gbl_driver_id)
 439                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 440         }
 441
 442         if (ts_params->valid_dev_count < 1)
 443                 return TEST_FAILED;
 444
 445         /* Set up all the qps on the first of the valid devices found */
 446
 447         dev_id = ts_params->valid_devs[0];
 448
 449         rte_cryptodev_info_get(dev_id, &info);
 450
 451         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 452         ts_params->conf.socket_id = SOCKET_ID_ANY;
 453         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 454
 455         unsigned int session_size =
 456                 rte_cryptodev_sym_get_private_session_size(dev_id);
 457
 458         /*
 459          * Create mempool with maximum number of sessions * 2,
 460          * to include the session headers
 461          */
 462         if (info.sym.max_nb_sessions != 0 &&
 463                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 464                 RTE_LOG(ERR, USER1, "Device does not support "
 465                                 "at least %u sessions\n",
 466                                 MAX_NB_SESSIONS);
 467                 return TEST_FAILED;
 468         }
 469
 470         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 471                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 472                         SOCKET_ID_ANY);
 473         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 474                         "session mempool allocation failed");
 475
 476         ts_params->session_priv_mpool = rte_mempool_create(
 477                         "test_sess_mp_priv",
 478                         MAX_NB_SESSIONS,
 479                         session_size,
 480                         0, 0, NULL, NULL, NULL,
 481                         NULL, SOCKET_ID_ANY,
 482                         0);
 483         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 484                         "session mempool allocation failed");
 485
 486
 487
 488         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 489                         &ts_params->conf),
 490                         "Failed to configure cryptodev %u with %u qps",
 491                         dev_id, ts_params->conf.nb_queue_pairs);
 492
 493         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 494         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 495         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 496
 497         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 498                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 499                         dev_id, qp_id, &ts_params->qp_conf,
 500                         rte_cryptodev_socket_id(dev_id)),
 501                         "Failed to setup queue pair %u on cryptodev %u",
 502                         qp_id, dev_id);
 503         }
 504
 505         return TEST_SUCCESS;
 506 }
 507
 508 static void
 509 testsuite_teardown(void)
 510 {
 511         struct crypto_testsuite_params *ts_params = &testsuite_params;
 512
 513         if (ts_params->mbuf_pool != NULL) {
 514                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 515                 rte_mempool_avail_count(ts_params->mbuf_pool));
 516         }
 517
 518         if (ts_params->op_mpool != NULL) {
 519                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 520                 rte_mempool_avail_count(ts_params->op_mpool));
 521         }
 522
 523         /* Free session mempools */
 524         if (ts_params->session_priv_mpool != NULL) {
 525                 rte_mempool_free(ts_params->session_priv_mpool);
 526                 ts_params->session_priv_mpool = NULL;
 527         }
 528
 529         if (ts_params->session_mpool != NULL) {
 530                 rte_mempool_free(ts_params->session_mpool);
 531                 ts_params->session_mpool = NULL;
 532         }
 533 }
 534
 535 static int
 536 ut_setup(void)
 537 {
 538         struct crypto_testsuite_params *ts_params = &testsuite_params;
 539         struct crypto_unittest_params *ut_params = &unittest_params;
 540
 541         uint16_t qp_id;
 542
 543         /* Clear unit test parameters before running test */
 544         memset(ut_params, 0, sizeof(*ut_params));
 545
 546         /* Reconfigure device to default parameters */
 547         ts_params->conf.socket_id = SOCKET_ID_ANY;
 548         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 549         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 550         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 551         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 552
 553         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 554                         &ts_params->conf),
 555                         "Failed to configure cryptodev %u",
 556                         ts_params->valid_devs[0]);
 557
 558         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 559                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 560                         ts_params->valid_devs[0], qp_id,
 561                         &ts_params->qp_conf,
 562                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 563                         "Failed to setup queue pair %u on cryptodev %u",
 564                         qp_id, ts_params->valid_devs[0]);
 565         }
 566
 567
 568         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 569
 570         /* Start the device */
 571         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
 572                         "Failed to start cryptodev %u",
 573                         ts_params->valid_devs[0]);
 574
 575         return TEST_SUCCESS;
 576 }
 577
 578 static void
 579 ut_teardown(void)
 580 {
 581         struct crypto_testsuite_params *ts_params = &testsuite_params;
 582         struct crypto_unittest_params *ut_params = &unittest_params;
 583         struct rte_cryptodev_stats stats;
 584
 585         /* free crypto session structure */
 586 #ifdef RTE_LIBRTE_SECURITY
 587         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
 588                 if (ut_params->sec_session) {
 589                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
 590                                                 (ts_params->valid_devs[0]),
 591                                                 ut_params->sec_session);
 592                         ut_params->sec_session = NULL;
 593                 }
 594         } else
 595 #endif
 596         {
 597                 if (ut_params->sess) {
 598                         rte_cryptodev_sym_session_clear(
 599                                         ts_params->valid_devs[0],
 600                                         ut_params->sess);
 601                         rte_cryptodev_sym_session_free(ut_params->sess);
 602                         ut_params->sess = NULL;
 603                 }
 604         }
 605
 606         /* free crypto operation structure */
 607         if (ut_params->op)
 608                 rte_crypto_op_free(ut_params->op);
 609
 610         /*
 611          * free mbuf - both obuf and ibuf are usually the same,
 612          * so check if they point at the same address is necessary,
 613          * to avoid freeing the mbuf twice.
 614          */
 615         if (ut_params->obuf) {
 616                 rte_pktmbuf_free(ut_params->obuf);
 617                 if (ut_params->ibuf == ut_params->obuf)
 618                         ut_params->ibuf = 0;
 619                 ut_params->obuf = 0;
 620         }
 621         if (ut_params->ibuf) {
 622                 rte_pktmbuf_free(ut_params->ibuf);
 623                 ut_params->ibuf = 0;
 624         }
 625
 626         if (ts_params->mbuf_pool != NULL)
 627                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 628                         rte_mempool_avail_count(ts_params->mbuf_pool));
 629
 630         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
 631
 632         /* Stop the device */
 633         rte_cryptodev_stop(ts_params->valid_devs[0]);
 634 }
 635
 636 static int
 637 test_device_configure_invalid_dev_id(void)
 638 {
 639         struct crypto_testsuite_params *ts_params = &testsuite_params;
 640         uint16_t dev_id, num_devs = 0;
 641
 642         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
 643                         "Need at least %d devices for test", 1);
 644
 645         /* valid dev_id values */
 646         dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
 647
 648         /* Stop the device in case it's started so it can be configured */
 649         rte_cryptodev_stop(dev_id);
 650
 651         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
 652                         "Failed test for rte_cryptodev_configure: "
 653                         "invalid dev_num %u", dev_id);
 654
 655         /* invalid dev_id values */
 656         dev_id = num_devs;
 657
 658         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 659                         "Failed test for rte_cryptodev_configure: "
 660                         "invalid dev_num %u", dev_id);
 661
 662         dev_id = 0xff;
 663
 664         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 665                         "Failed test for rte_cryptodev_configure:"
 666                         "invalid dev_num %u", dev_id);
 667
 668         return TEST_SUCCESS;
 669 }
 670
 671 static int
 672 test_device_configure_invalid_queue_pair_ids(void)
 673 {
 674         struct crypto_testsuite_params *ts_params = &testsuite_params;
 675         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
 676
 677         /* Stop the device in case it's started so it can be configured */
 678         rte_cryptodev_stop(ts_params->valid_devs[0]);
 679
 680         /* valid - one queue pairs */
 681         ts_params->conf.nb_queue_pairs = 1;
 682
 683         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 684                         &ts_params->conf),
 685                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 686                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 687
 688
 689         /* valid - max value queue pairs */
 690         ts_params->conf.nb_queue_pairs = orig_nb_qps;
 691
 692         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 693                         &ts_params->conf),
 694                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 695                         ts_params->valid_devs[0],
 696                         ts_params->conf.nb_queue_pairs);
 697
 698
 699         /* invalid - zero queue pairs */
 700         ts_params->conf.nb_queue_pairs = 0;
 701
 702         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 703                         &ts_params->conf),
 704                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 705                         " invalid qps: %u",
 706                         ts_params->valid_devs[0],
 707                         ts_params->conf.nb_queue_pairs);
 708
 709
 710         /* invalid - max value supported by field queue pairs */
 711         ts_params->conf.nb_queue_pairs = UINT16_MAX;
 712
 713         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 714                         &ts_params->conf),
 715                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 716                         " invalid qps: %u",
 717                         ts_params->valid_devs[0],
 718                         ts_params->conf.nb_queue_pairs);
 719
 720
 721         /* invalid - max value + 1 queue pairs */
 722         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
 723
 724         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 725                         &ts_params->conf),
 726                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 727                         " invalid qps: %u",
 728                         ts_params->valid_devs[0],
 729                         ts_params->conf.nb_queue_pairs);
 730
 731         /* revert to original testsuite value */
 732         ts_params->conf.nb_queue_pairs = orig_nb_qps;
 733
 734         return TEST_SUCCESS;
 735 }
 736
 737 static int
 738 test_queue_pair_descriptor_setup(void)
 739 {
 740         struct crypto_testsuite_params *ts_params = &testsuite_params;
 741         struct rte_cryptodev_info dev_info;
 742         struct rte_cryptodev_qp_conf qp_conf = {
 743                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
 744         };
 745
 746         uint16_t qp_id;
 747
 748         /* Stop the device in case it's started so it can be configured */
 749         rte_cryptodev_stop(ts_params->valid_devs[0]);
 750
 751
 752         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 753
 754         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 755                         &ts_params->conf),
 756                         "Failed to configure cryptodev %u",
 757                         ts_params->valid_devs[0]);
 758
 759         /*
 760          * Test various ring sizes on this device. memzones can't be
 761          * freed so are re-used if ring is released and re-created.
 762          */
 763         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
 764         qp_conf.mp_session = ts_params->session_mpool;
 765         qp_conf.mp_session_private = ts_params->session_priv_mpool;
 766
 767         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 768                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 769                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 770                                 rte_cryptodev_socket_id(
 771                                                 ts_params->valid_devs[0])),
 772                                 "Failed test for "
 773                                 "rte_cryptodev_queue_pair_setup: num_inflights "
 774                                 "%u on qp %u on cryptodev %u",
 775                                 qp_conf.nb_descriptors, qp_id,
 776                                 ts_params->valid_devs[0]);
 777         }
 778
 779         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
 780
 781         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 782                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 783                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 784                                 rte_cryptodev_socket_id(
 785                                                 ts_params->valid_devs[0])),
 786                                 "Failed test for"
 787                                 " rte_cryptodev_queue_pair_setup: num_inflights"
 788                                 " %u on qp %u on cryptodev %u",
 789                                 qp_conf.nb_descriptors, qp_id,
 790                                 ts_params->valid_devs[0]);
 791         }
 792
 793         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
 794
 795         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 796                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 797                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 798                                 rte_cryptodev_socket_id(
 799                                                 ts_params->valid_devs[0])),
 800                                 "Failed test for "
 801                                 "rte_cryptodev_queue_pair_setup: num_inflights"
 802                                 " %u on qp %u on cryptodev %u",
 803                                 qp_conf.nb_descriptors, qp_id,
 804                                 ts_params->valid_devs[0]);
 805         }
 806
 807         /* invalid number of descriptors - max supported + 2 */
 808         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
 809
 810         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 811                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 812                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 813                                 rte_cryptodev_socket_id(
 814                                                 ts_params->valid_devs[0])),
 815                                 "Unexpectedly passed test for "
 816                                 "rte_cryptodev_queue_pair_setup:"
 817                                 "num_inflights %u on qp %u on cryptodev %u",
 818                                 qp_conf.nb_descriptors, qp_id,
 819                                 ts_params->valid_devs[0]);
 820         }
 821
 822         /* invalid number of descriptors - max value of parameter */
 823         qp_conf.nb_descriptors = UINT32_MAX-1;
 824
 825         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 826                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 827                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 828                                 rte_cryptodev_socket_id(
 829                                                 ts_params->valid_devs[0])),
 830                                 "Unexpectedly passed test for "
 831                                 "rte_cryptodev_queue_pair_setup:"
 832                                 "num_inflights %u on qp %u on cryptodev %u",
 833                                 qp_conf.nb_descriptors, qp_id,
 834                                 ts_params->valid_devs[0]);
 835         }
 836
 837         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 838
 839         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 840                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 841                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 842                                 rte_cryptodev_socket_id(
 843                                                 ts_params->valid_devs[0])),
 844                                 "Failed test for"
 845                                 " rte_cryptodev_queue_pair_setup:"
 846                                 "num_inflights %u on qp %u on cryptodev %u",
 847                                 qp_conf.nb_descriptors, qp_id,
 848                                 ts_params->valid_devs[0]);
 849         }
 850
 851         /* invalid number of descriptors - max supported + 1 */
 852         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
 853
 854         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 855                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 856                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 857                                 rte_cryptodev_socket_id(
 858                                                 ts_params->valid_devs[0])),
 859                                 "Unexpectedly passed test for "
 860                                 "rte_cryptodev_queue_pair_setup:"
 861                                 "num_inflights %u on qp %u on cryptodev %u",
 862                                 qp_conf.nb_descriptors, qp_id,
 863                                 ts_params->valid_devs[0]);
 864         }
 865
 866         /* test invalid queue pair id */
 867         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
 868
 869         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
 870
 871         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 872                         ts_params->valid_devs[0],
 873                         qp_id, &qp_conf,
 874                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 875                         "Failed test for rte_cryptodev_queue_pair_setup:"
 876                         "invalid qp %u on cryptodev %u",
 877                         qp_id, ts_params->valid_devs[0]);
 878
 879         qp_id = 0xffff; /*invalid*/
 880
 881         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 882                         ts_params->valid_devs[0],
 883                         qp_id, &qp_conf,
 884                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 885                         "Failed test for rte_cryptodev_queue_pair_setup:"
 886                         "invalid qp %u on cryptodev %u",
 887                         qp_id, ts_params->valid_devs[0]);
 888
 889         return TEST_SUCCESS;
 890 }
 891
 892 /* ***** Plaintext data for tests ***** */
 893
 894 const char catch_22_quote_1[] =
 895                 "There was only one catch and that was Catch-22, which "
 896                 "specified that a concern for one's safety in the face of "
 897                 "dangers that were real and immediate was the process of a "
 898                 "rational mind. Orr was crazy and could be grounded. All he "
 899                 "had to do was ask; and as soon as he did, he would no longer "
 900                 "be crazy and would have to fly more missions. Orr would be "
 901                 "crazy to fly more missions and sane if he didn't, but if he "
 902                 "was sane he had to fly them. If he flew them he was crazy "
 903                 "and didn't have to; but if he didn't want to he was sane and "
 904                 "had to. Yossarian was moved very deeply by the absolute "
 905                 "simplicity of this clause of Catch-22 and let out a "
 906                 "respectful whistle. \"That's some catch, that Catch-22\", he "
 907                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
 908
 909 const char catch_22_quote[] =
 910                 "What a lousy earth! He wondered how many people were "
 911                 "destitute that same night even in his own prosperous country, "
 912                 "how many homes were shanties, how many husbands were drunk "
 913                 "and wives socked, and how many children were bullied, abused, "
 914                 "or abandoned. How many families hungered for food they could "
 915                 "not afford to buy? How many hearts were broken? How many "
 916                 "suicides would take place that same night, how many people "
 917                 "would go insane? How many cockroaches and landlords would "
 918                 "triumph? How many winners were losers, successes failures, "
 919                 "and rich men poor men? How many wise guys were stupid? How "
 920                 "many happy endings were unhappy endings? How many honest men "
 921                 "were liars, brave men cowards, loyal men traitors, how many "
 922                 "sainted men were corrupt, how many people in positions of "
 923                 "trust had sold their souls to bodyguards, how many had never "
 924                 "had souls? How many straight-and-narrow paths were crooked "
 925                 "paths? How many best families were worst families and how "
 926                 "many good people were bad people? When you added them all up "
 927                 "and then subtracted, you might be left with only the children, "
 928                 "and perhaps with Albert Einstein and an old violinist or "
 929                 "sculptor somewhere.";
 930
 931 #define QUOTE_480_BYTES         (480)
 932 #define QUOTE_512_BYTES         (512)
 933 #define QUOTE_768_BYTES         (768)
 934 #define QUOTE_1024_BYTES        (1024)
 935
 936
 937
 938 /* ***** SHA1 Hash Tests ***** */
 939
 940 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
 941
 942 static uint8_t hmac_sha1_key[] = {
 943         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 944         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 945         0xDE, 0xF4, 0xDE, 0xAD };
 946
 947 /* ***** SHA224 Hash Tests ***** */
 948
 949 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
 950
 951
 952 /* ***** AES-CBC Cipher Tests ***** */
 953
 954 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
 955 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
 956
 957 static uint8_t aes_cbc_key[] = {
 958         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 959         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
 960
 961 static uint8_t aes_cbc_iv[] = {
 962         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 963         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
 964
 965
 966 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
 967
 968 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
 969         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
 970         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
 971         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
 972         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
 973         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
 974         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
 975         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
 976         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
 977         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
 978         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
 979         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
 980         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
 981         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
 982         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
 983         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
 984         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
 985         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
 986         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
 987         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
 988         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
 989         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
 990         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
 991         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 992         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
 993         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
 994         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
 995         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
 996         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
 997         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
 998         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
 999         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1000         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1001         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1002         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1003         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1004         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1005         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1006         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1007         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1008         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1009         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1010         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1011         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1012         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1013         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1014         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1015         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1016         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1017         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1018         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1019         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1020         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1021         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1022         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1023         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1024         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1025         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1026         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1027         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1028         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1029         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1030         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1031         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1032         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1033 };
1034
1035 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1036         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1037         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1038         0x18, 0x8c, 0x1d, 0x32
1039 };
1040
1041
1042 /* Multisession Vector context Test */
1043 /*Begin Session 0 */
1044 static uint8_t ms_aes_cbc_key0[] = {
1045         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1046         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1047 };
1048
1049 static uint8_t ms_aes_cbc_iv0[] = {
1050         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1051         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1052 };
1053
1054 static const uint8_t ms_aes_cbc_cipher0[] = {
1055                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1056                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1057                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1058                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1059                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1060                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1061                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1062                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1063                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1064                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1065                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1066                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1067                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1068                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1069                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1070                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1071                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1072                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1073                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1074                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1075                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1076                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1077                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1078                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1079                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1080                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1081                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1082                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1083                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1084                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1085                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1086                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1087                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1088                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1089                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1090                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1091                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1092                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1093                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1094                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1095                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1096                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1097                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1098                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1099                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1100                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1101                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1102                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1103                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1104                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1105                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1106                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1107                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1108                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1109                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1110                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1111                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1112                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1113                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1114                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1115                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1116                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1117                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1118                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1119 };
1120
1121
1122 static  uint8_t ms_hmac_key0[] = {
1123                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1124                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1125                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1126                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1127                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1128                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1129                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1130                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1131 };
1132
1133 static const uint8_t ms_hmac_digest0[] = {
1134                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1135                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1136                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1137                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1138                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1139                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1140                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1141                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1142                 };
1143
1144 /* End Session 0 */
1145 /* Begin session 1 */
1146
1147 static  uint8_t ms_aes_cbc_key1[] = {
1148                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1149                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1150 };
1151
1152 static  uint8_t ms_aes_cbc_iv1[] = {
1153         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1154         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1155 };
1156
1157 static const uint8_t ms_aes_cbc_cipher1[] = {
1158                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1159                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1160                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1161                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1162                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1163                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1164                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1165                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1166                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1167                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1168                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1169                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1170                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1171                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1172                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1173                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1174                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1175                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1176                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1177                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1178                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1179                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1180                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1181                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1182                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1183                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1184                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1185                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1186                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1187                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1188                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1189                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1190                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1191                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1192                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1193                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1194                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1195                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1196                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1197                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1198                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1199                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1200                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1201                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1202                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1203                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1204                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1205                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1206                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1207                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1208                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1209                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1210                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1211                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1212                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1213                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1214                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1215                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1216                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1217                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1218                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1219                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1220                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1221                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1222
1223 };
1224
1225 static uint8_t ms_hmac_key1[] = {
1226                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1227                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1228                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1229                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1230                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1231                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1232                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1233                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1234 };
1235
1236 static const uint8_t ms_hmac_digest1[] = {
1237                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1238                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1239                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1240                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1241                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1242                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1243                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1244                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1245 };
1246 /* End Session 1  */
1247 /* Begin Session 2 */
1248 static  uint8_t ms_aes_cbc_key2[] = {
1249                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1250                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1251 };
1252
1253 static  uint8_t ms_aes_cbc_iv2[] = {
1254                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1255                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1256 };
1257
1258 static const uint8_t ms_aes_cbc_cipher2[] = {
1259                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1260                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1261                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1262                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1263                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1264                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1265                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1266                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1267                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1268                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1269                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1270                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1271                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1272                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1273                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1274                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1275                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1276                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1277                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1278                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1279                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1280                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1281                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1282                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1283                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1284                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1285                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1286                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1287                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1288                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1289                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1290                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1291                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1292                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1293                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1294                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1295                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1296                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1297                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1298                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1299                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1300                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1301                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1302                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1303                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1304                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1305                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1306                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1307                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1308                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1309                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1310                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1311                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1312                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1313                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1314                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1315                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1316                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1317                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1318                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1319                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1320                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1321                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1322                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1323 };
1324
1325 static  uint8_t ms_hmac_key2[] = {
1326                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1327                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1328                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1329                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1330                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1331                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1332                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1333                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1334 };
1335
1336 static const uint8_t ms_hmac_digest2[] = {
1337                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1338                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1339                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1340                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1341                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1342                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1343                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1344                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1345 };
1346
1347 /* End Session 2 */
1348
1349
1350 static int
1351 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1352 {
1353         struct crypto_testsuite_params *ts_params = &testsuite_params;
1354         struct crypto_unittest_params *ut_params = &unittest_params;
1355
1356         /* Generate test mbuf data and space for digest */
1357         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1358                         catch_22_quote, QUOTE_512_BYTES, 0);
1359
1360         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1361                         DIGEST_BYTE_LENGTH_SHA1);
1362         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1363
1364         /* Setup Cipher Parameters */
1365         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1366         ut_params->cipher_xform.next = &ut_params->auth_xform;
1367
1368         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1369         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1370         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1371         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1372         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1373         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1374
1375         /* Setup HMAC Parameters */
1376         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1377
1378         ut_params->auth_xform.next = NULL;
1379
1380         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1381         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1382         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1383         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1384         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1385
1386         ut_params->sess = rte_cryptodev_sym_session_create(
1387                         ts_params->session_mpool);
1388
1389         /* Create crypto session*/
1390         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
1391                         ut_params->sess, &ut_params->cipher_xform,
1392                         ts_params->session_priv_mpool);
1393         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1394
1395         /* Generate crypto op data structure */
1396         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1397                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1398         TEST_ASSERT_NOT_NULL(ut_params->op,
1399                         "Failed to allocate symmetric crypto operation struct");
1400
1401         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1402
1403         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1404
1405         /* set crypto operation source mbuf */
1406         sym_op->m_src = ut_params->ibuf;
1407
1408         /* Set crypto operation authentication parameters */
1409         sym_op->auth.digest.data = ut_params->digest;
1410         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1411                         ut_params->ibuf, QUOTE_512_BYTES);
1412
1413         sym_op->auth.data.offset = 0;
1414         sym_op->auth.data.length = QUOTE_512_BYTES;
1415
1416         /* Copy IV at the end of the crypto operation */
1417         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1418                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
1419
1420         /* Set crypto operation cipher parameters */
1421         sym_op->cipher.data.offset = 0;
1422         sym_op->cipher.data.length = QUOTE_512_BYTES;
1423
1424         /* Process crypto operation */
1425         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1426                         ut_params->op), "failed to process sym crypto op");
1427
1428         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1429                         "crypto op processing failed");
1430
1431         /* Validate obuf */
1432         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
1433                         uint8_t *);
1434
1435         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1436                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1437                         QUOTE_512_BYTES,
1438                         "ciphertext data not as expected");
1439
1440         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1441
1442         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1443                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1444                         gbl_driver_id == rte_cryptodev_driver_id_get(
1445                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
1446                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1447                                         DIGEST_BYTE_LENGTH_SHA1,
1448                         "Generated digest data not as expected");
1449
1450         return TEST_SUCCESS;
1451 }
1452
1453 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1454
1455 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
1456
1457 static uint8_t hmac_sha512_key[] = {
1458         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1459         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1460         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1461         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1462         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1463         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1464         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1465         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1466
1467 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1468         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1469         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1470         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1471         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1472         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1473         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1474         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1475         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1476
1477
1478
1479 static int
1480 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1481                 struct crypto_unittest_params *ut_params,
1482                 uint8_t *cipher_key,
1483                 uint8_t *hmac_key);
1484
1485 static int
1486 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1487                 struct crypto_unittest_params *ut_params,
1488                 struct crypto_testsuite_params *ts_params,
1489                 const uint8_t *cipher,
1490                 const uint8_t *digest,
1491                 const uint8_t *iv);
1492
1493
1494 static int
1495 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1496                 struct crypto_unittest_params *ut_params,
1497                 uint8_t *cipher_key,
1498                 uint8_t *hmac_key)
1499 {
1500
1501         /* Setup Cipher Parameters */
1502         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1503         ut_params->cipher_xform.next = NULL;
1504
1505         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1506         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1507         ut_params->cipher_xform.cipher.key.data = cipher_key;
1508         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1509         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1510         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1511
1512         /* Setup HMAC Parameters */
1513         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1514         ut_params->auth_xform.next = &ut_params->cipher_xform;
1515
1516         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1517         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1518         ut_params->auth_xform.auth.key.data = hmac_key;
1519         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1520         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1521
1522         return TEST_SUCCESS;
1523 }
1524
1525
1526 static int
1527 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1528                 struct crypto_unittest_params *ut_params,
1529                 struct crypto_testsuite_params *ts_params,
1530                 const uint8_t *cipher,
1531                 const uint8_t *digest,
1532                 const uint8_t *iv)
1533 {
1534         /* Generate test mbuf data and digest */
1535         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1536                         (const char *)
1537                         cipher,
1538                         QUOTE_512_BYTES, 0);
1539
1540         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1541                         DIGEST_BYTE_LENGTH_SHA512);
1542         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1543
1544         rte_memcpy(ut_params->digest,
1545                         digest,
1546                         DIGEST_BYTE_LENGTH_SHA512);
1547
1548         /* Generate Crypto op data structure */
1549         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1550                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1551         TEST_ASSERT_NOT_NULL(ut_params->op,
1552                         "Failed to allocate symmetric crypto operation struct");
1553
1554         rte_crypto_op_attach_sym_session(ut_params->op, sess);
1555
1556         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1557
1558         /* set crypto operation source mbuf */
1559         sym_op->m_src = ut_params->ibuf;
1560
1561         sym_op->auth.digest.data = ut_params->digest;
1562         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1563                         ut_params->ibuf, QUOTE_512_BYTES);
1564
1565         sym_op->auth.data.offset = 0;
1566         sym_op->auth.data.length = QUOTE_512_BYTES;
1567
1568         /* Copy IV at the end of the crypto operation */
1569         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1570                         iv, CIPHER_IV_LENGTH_AES_CBC);
1571
1572         sym_op->cipher.data.offset = 0;
1573         sym_op->cipher.data.length = QUOTE_512_BYTES;
1574
1575         /* Process crypto operation */
1576         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1577                         ut_params->op), "failed to process sym crypto op");
1578
1579         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1580                         "crypto op processing failed");
1581
1582         ut_params->obuf = ut_params->op->sym->m_src;
1583
1584         /* Validate obuf */
1585         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1586                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
1587                         catch_22_quote,
1588                         QUOTE_512_BYTES,
1589                         "Plaintext data not as expected");
1590
1591         /* Validate obuf */
1592         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1593                         "Digest verification failed");
1594
1595         return TEST_SUCCESS;
1596 }
1597
1598 static int
1599 test_AES_cipheronly_mb_all(void)
1600 {
1601         struct crypto_testsuite_params *ts_params = &testsuite_params;
1602         int status;
1603
1604         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1605                 ts_params->op_mpool,
1606                 ts_params->session_mpool, ts_params->session_priv_mpool,
1607                 ts_params->valid_devs[0],
1608                 rte_cryptodev_driver_id_get(
1609                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1610                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1611
1612         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1613
1614         return TEST_SUCCESS;
1615 }
1616
1617 static int
1618 test_AES_docsis_mb_all(void)
1619 {
1620         struct crypto_testsuite_params *ts_params = &testsuite_params;
1621         int status;
1622
1623         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1624                 ts_params->op_mpool,
1625                 ts_params->session_mpool, ts_params->session_priv_mpool,
1626                 ts_params->valid_devs[0],
1627                 rte_cryptodev_driver_id_get(
1628                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1629                 BLKCIPHER_AES_DOCSIS_TYPE);
1630
1631         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1632
1633         return TEST_SUCCESS;
1634 }
1635
1636 static int
1637 test_AES_docsis_qat_all(void)
1638 {
1639         struct crypto_testsuite_params *ts_params = &testsuite_params;
1640         int status;
1641
1642         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1643                 ts_params->op_mpool,
1644                 ts_params->session_mpool, ts_params->session_priv_mpool,
1645                 ts_params->valid_devs[0],
1646                 rte_cryptodev_driver_id_get(
1647                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1648                 BLKCIPHER_AES_DOCSIS_TYPE);
1649
1650         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1651
1652         return TEST_SUCCESS;
1653 }
1654
1655 static int
1656 test_DES_docsis_qat_all(void)
1657 {
1658         struct crypto_testsuite_params *ts_params = &testsuite_params;
1659         int status;
1660
1661         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1662                 ts_params->op_mpool,
1663                 ts_params->session_mpool, ts_params->session_priv_mpool,
1664                 ts_params->valid_devs[0],
1665                 rte_cryptodev_driver_id_get(
1666                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1667                 BLKCIPHER_DES_DOCSIS_TYPE);
1668
1669         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1670
1671         return TEST_SUCCESS;
1672 }
1673
1674 static int
1675 test_authonly_mb_all(void)
1676 {
1677         struct crypto_testsuite_params *ts_params = &testsuite_params;
1678         int status;
1679
1680         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1681                 ts_params->op_mpool,
1682                 ts_params->session_mpool, ts_params->session_priv_mpool,
1683                 ts_params->valid_devs[0],
1684                 rte_cryptodev_driver_id_get(
1685                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1686                 BLKCIPHER_AUTHONLY_TYPE);
1687
1688         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1689
1690         return TEST_SUCCESS;
1691 }
1692
1693 static int
1694 test_authonly_qat_all(void)
1695 {
1696         struct crypto_testsuite_params *ts_params = &testsuite_params;
1697         int status;
1698
1699         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1700                 ts_params->op_mpool,
1701                 ts_params->session_mpool, ts_params->session_priv_mpool,
1702                 ts_params->valid_devs[0],
1703                 rte_cryptodev_driver_id_get(
1704                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1705                 BLKCIPHER_AUTHONLY_TYPE);
1706
1707         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1708
1709         return TEST_SUCCESS;
1710 }
1711
1712 static int
1713 test_AES_chain_null_all(void)
1714 {
1715         struct crypto_testsuite_params *ts_params = &testsuite_params;
1716         int status;
1717
1718         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1719                 ts_params->op_mpool,
1720                 ts_params->session_mpool, ts_params->session_priv_mpool,
1721                 ts_params->valid_devs[0],
1722                 rte_cryptodev_driver_id_get(
1723                 RTE_STR(CRYPTODEV_NAME_NULL_PMD)),
1724                 BLKCIPHER_AES_CHAIN_TYPE);
1725
1726         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1727
1728         return TEST_SUCCESS;
1729 }
1730
1731 static int
1732 test_AES_cipheronly_null_all(void)
1733 {
1734         struct crypto_testsuite_params *ts_params = &testsuite_params;
1735         int status;
1736
1737         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1738                 ts_params->op_mpool,
1739                 ts_params->session_mpool, ts_params->session_priv_mpool,
1740                 ts_params->valid_devs[0],
1741                 rte_cryptodev_driver_id_get(
1742                 RTE_STR(CRYPTODEV_NAME_NULL_PMD)),
1743                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1744
1745         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1746
1747         return TEST_SUCCESS;
1748 }
1749
1750 static int
1751 test_authonly_null_all(void)
1752 {
1753         struct crypto_testsuite_params *ts_params = &testsuite_params;
1754         int status;
1755
1756         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1757                 ts_params->op_mpool,
1758                 ts_params->session_mpool, ts_params->session_priv_mpool,
1759                 ts_params->valid_devs[0],
1760                 rte_cryptodev_driver_id_get(
1761                 RTE_STR(CRYPTODEV_NAME_NULL_PMD)),
1762                 BLKCIPHER_AUTHONLY_TYPE);
1763
1764         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1765
1766         return TEST_SUCCESS;
1767 }
1768
1769 static int
1770 test_AES_chain_mb_all(void)
1771 {
1772         struct crypto_testsuite_params *ts_params = &testsuite_params;
1773         int status;
1774
1775         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1776                 ts_params->op_mpool,
1777                 ts_params->session_mpool, ts_params->session_priv_mpool,
1778                 ts_params->valid_devs[0],
1779                 rte_cryptodev_driver_id_get(
1780                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
1781                 BLKCIPHER_AES_CHAIN_TYPE);
1782
1783         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1784
1785         return TEST_SUCCESS;
1786 }
1787
1788 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
1789
1790 static int
1791 test_AES_cipheronly_scheduler_all(void)
1792 {
1793         struct crypto_testsuite_params *ts_params = &testsuite_params;
1794         int status;
1795
1796         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1797                 ts_params->op_mpool,
1798                 ts_params->session_mpool, ts_params->session_priv_mpool,
1799                 ts_params->valid_devs[0],
1800                 rte_cryptodev_driver_id_get(
1801                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1802                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1803
1804         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1805
1806         return TEST_SUCCESS;
1807 }
1808
1809 static int
1810 test_AES_chain_scheduler_all(void)
1811 {
1812         struct crypto_testsuite_params *ts_params = &testsuite_params;
1813         int status;
1814
1815         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1816                 ts_params->op_mpool,
1817                 ts_params->session_mpool, ts_params->session_priv_mpool,
1818                 ts_params->valid_devs[0],
1819                 rte_cryptodev_driver_id_get(
1820                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1821                 BLKCIPHER_AES_CHAIN_TYPE);
1822
1823         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1824
1825         return TEST_SUCCESS;
1826 }
1827
1828 static int
1829 test_authonly_scheduler_all(void)
1830 {
1831         struct crypto_testsuite_params *ts_params = &testsuite_params;
1832         int status;
1833
1834         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1835                 ts_params->op_mpool,
1836                 ts_params->session_mpool, ts_params->session_priv_mpool,
1837                 ts_params->valid_devs[0],
1838                 rte_cryptodev_driver_id_get(
1839                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
1840                 BLKCIPHER_AUTHONLY_TYPE);
1841
1842         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1843
1844         return TEST_SUCCESS;
1845 }
1846
1847 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
1848
1849 static int
1850 test_AES_chain_openssl_all(void)
1851 {
1852         struct crypto_testsuite_params *ts_params = &testsuite_params;
1853         int status;
1854
1855         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1856                 ts_params->op_mpool,
1857                 ts_params->session_mpool, ts_params->session_priv_mpool,
1858                 ts_params->valid_devs[0],
1859                 rte_cryptodev_driver_id_get(
1860                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
1861                 BLKCIPHER_AES_CHAIN_TYPE);
1862
1863         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1864
1865         return TEST_SUCCESS;
1866 }
1867
1868 static int
1869 test_AES_cipheronly_openssl_all(void)
1870 {
1871         struct crypto_testsuite_params *ts_params = &testsuite_params;
1872         int status;
1873
1874         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1875                 ts_params->op_mpool,
1876                 ts_params->session_mpool, ts_params->session_priv_mpool,
1877                 ts_params->valid_devs[0],
1878                 rte_cryptodev_driver_id_get(
1879                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
1880                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1881
1882         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1883
1884         return TEST_SUCCESS;
1885 }
1886
1887 static int
1888 test_AES_chain_ccp_all(void)
1889 {
1890         struct crypto_testsuite_params *ts_params = &testsuite_params;
1891         int status;
1892
1893         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1894                 ts_params->op_mpool,
1895                 ts_params->session_mpool, ts_params->session_priv_mpool,
1896                 ts_params->valid_devs[0],
1897                 rte_cryptodev_driver_id_get(
1898                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
1899                 BLKCIPHER_AES_CHAIN_TYPE);
1900
1901         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1902
1903         return TEST_SUCCESS;
1904 }
1905
1906 static int
1907 test_AES_cipheronly_ccp_all(void)
1908 {
1909         struct crypto_testsuite_params *ts_params = &testsuite_params;
1910         int status;
1911
1912         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1913                 ts_params->op_mpool,
1914                 ts_params->session_mpool, ts_params->session_priv_mpool,
1915                 ts_params->valid_devs[0],
1916                 rte_cryptodev_driver_id_get(
1917                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
1918                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1919
1920         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1921
1922         return TEST_SUCCESS;
1923 }
1924
1925 static int
1926 test_AES_chain_qat_all(void)
1927 {
1928         struct crypto_testsuite_params *ts_params = &testsuite_params;
1929         int status;
1930
1931         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1932                 ts_params->op_mpool,
1933                 ts_params->session_mpool, ts_params->session_priv_mpool,
1934                 ts_params->valid_devs[0],
1935                 rte_cryptodev_driver_id_get(
1936                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1937                 BLKCIPHER_AES_CHAIN_TYPE);
1938
1939         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1940
1941         return TEST_SUCCESS;
1942 }
1943
1944 static int
1945 test_AES_cipheronly_qat_all(void)
1946 {
1947         struct crypto_testsuite_params *ts_params = &testsuite_params;
1948         int status;
1949
1950         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1951                 ts_params->op_mpool,
1952                 ts_params->session_mpool, ts_params->session_priv_mpool,
1953                 ts_params->valid_devs[0],
1954                 rte_cryptodev_driver_id_get(
1955                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
1956                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1957
1958         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1959
1960         return TEST_SUCCESS;
1961 }
1962
1963 static int
1964 test_AES_cipheronly_virtio_all(void)
1965 {
1966         struct crypto_testsuite_params *ts_params = &testsuite_params;
1967         int status;
1968
1969         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1970                 ts_params->op_mpool,
1971                 ts_params->session_mpool, ts_params->session_priv_mpool,
1972                 ts_params->valid_devs[0],
1973                 rte_cryptodev_driver_id_get(
1974                 RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD)),
1975                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1976
1977         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1978
1979         return TEST_SUCCESS;
1980 }
1981
1982 static int
1983 test_AES_chain_caam_jr_all(void)
1984 {
1985         struct crypto_testsuite_params *ts_params = &testsuite_params;
1986         int status;
1987
1988         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1989                 ts_params->op_mpool,
1990                 ts_params->session_mpool, ts_params->session_priv_mpool,
1991                 ts_params->valid_devs[0],
1992                 rte_cryptodev_driver_id_get(
1993                 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
1994                 BLKCIPHER_AES_CHAIN_TYPE);
1995
1996         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1997
1998         return TEST_SUCCESS;
1999 }
2000
2001 static int
2002 test_AES_cipheronly_caam_jr_all(void)
2003 {
2004         struct crypto_testsuite_params *ts_params = &testsuite_params;
2005         int status;
2006
2007         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2008                 ts_params->op_mpool,
2009                 ts_params->session_mpool, ts_params->session_priv_mpool,
2010                 ts_params->valid_devs[0],
2011                 rte_cryptodev_driver_id_get(
2012                 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
2013                 BLKCIPHER_AES_CIPHERONLY_TYPE);
2014
2015         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2016
2017         return TEST_SUCCESS;
2018 }
2019
2020 static int
2021 test_authonly_caam_jr_all(void)
2022 {
2023         struct crypto_testsuite_params *ts_params = &testsuite_params;
2024         int status;
2025
2026         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2027                 ts_params->op_mpool,
2028                 ts_params->session_mpool, ts_params->session_priv_mpool,
2029                 ts_params->valid_devs[0],
2030                 rte_cryptodev_driver_id_get(
2031                 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
2032                 BLKCIPHER_AUTHONLY_TYPE);
2033
2034         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2035
2036         return TEST_SUCCESS;
2037 }
2038
2039
2040 static int
2041 test_AES_chain_dpaa_sec_all(void)
2042 {
2043         struct crypto_testsuite_params *ts_params = &testsuite_params;
2044         int status;
2045
2046         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2047                 ts_params->op_mpool,
2048                 ts_params->session_mpool, ts_params->session_priv_mpool,
2049                 ts_params->valid_devs[0],
2050                 rte_cryptodev_driver_id_get(
2051                 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
2052                 BLKCIPHER_AES_CHAIN_TYPE);
2053
2054         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2055
2056         return TEST_SUCCESS;
2057 }
2058
2059 static int
2060 test_AES_cipheronly_dpaa_sec_all(void)
2061 {
2062         struct crypto_testsuite_params *ts_params = &testsuite_params;
2063         int status;
2064
2065         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2066                 ts_params->op_mpool,
2067                 ts_params->session_mpool, ts_params->session_priv_mpool,
2068                 ts_params->valid_devs[0],
2069                 rte_cryptodev_driver_id_get(
2070                 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
2071                 BLKCIPHER_AES_CIPHERONLY_TYPE);
2072
2073         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2074
2075         return TEST_SUCCESS;
2076 }
2077
2078 static int
2079 test_authonly_dpaa_sec_all(void)
2080 {
2081         struct crypto_testsuite_params *ts_params = &testsuite_params;
2082         int status;
2083
2084         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2085                 ts_params->op_mpool,
2086                 ts_params->session_mpool, ts_params->session_priv_mpool,
2087                 ts_params->valid_devs[0],
2088                 rte_cryptodev_driver_id_get(
2089                 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
2090                 BLKCIPHER_AUTHONLY_TYPE);
2091
2092         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2093
2094         return TEST_SUCCESS;
2095 }
2096
2097 static int
2098 test_AES_chain_dpaa2_sec_all(void)
2099 {
2100         struct crypto_testsuite_params *ts_params = &testsuite_params;
2101         int status;
2102
2103         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2104                 ts_params->op_mpool,
2105                 ts_params->session_mpool, ts_params->session_priv_mpool,
2106                 ts_params->valid_devs[0],
2107                 rte_cryptodev_driver_id_get(
2108                 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
2109                 BLKCIPHER_AES_CHAIN_TYPE);
2110
2111         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2112
2113         return TEST_SUCCESS;
2114 }
2115
2116 static int
2117 test_AES_cipheronly_dpaa2_sec_all(void)
2118 {
2119         struct crypto_testsuite_params *ts_params = &testsuite_params;
2120         int status;
2121
2122         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2123                 ts_params->op_mpool,
2124                 ts_params->session_mpool, ts_params->session_priv_mpool,
2125                 ts_params->valid_devs[0],
2126                 rte_cryptodev_driver_id_get(
2127                 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
2128                 BLKCIPHER_AES_CIPHERONLY_TYPE);
2129
2130         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2131
2132         return TEST_SUCCESS;
2133 }
2134
2135 static int
2136 test_authonly_dpaa2_sec_all(void)
2137 {
2138         struct crypto_testsuite_params *ts_params = &testsuite_params;
2139         int status;
2140
2141         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2142                 ts_params->op_mpool,
2143                 ts_params->session_mpool, ts_params->session_priv_mpool,
2144                 ts_params->valid_devs[0],
2145                 rte_cryptodev_driver_id_get(
2146                 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
2147                 BLKCIPHER_AUTHONLY_TYPE);
2148
2149         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2150
2151         return TEST_SUCCESS;
2152 }
2153
2154 static int
2155 test_authonly_openssl_all(void)
2156 {
2157         struct crypto_testsuite_params *ts_params = &testsuite_params;
2158         int status;
2159
2160         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2161                 ts_params->op_mpool,
2162                 ts_params->session_mpool, ts_params->session_priv_mpool,
2163                 ts_params->valid_devs[0],
2164                 rte_cryptodev_driver_id_get(
2165                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
2166                 BLKCIPHER_AUTHONLY_TYPE);
2167
2168         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2169
2170         return TEST_SUCCESS;
2171 }
2172
2173 static int
2174 test_authonly_ccp_all(void)
2175 {
2176         struct crypto_testsuite_params *ts_params = &testsuite_params;
2177         int status;
2178
2179         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2180                 ts_params->op_mpool,
2181                 ts_params->session_mpool, ts_params->session_priv_mpool,
2182                 ts_params->valid_devs[0],
2183                 rte_cryptodev_driver_id_get(
2184                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
2185                 BLKCIPHER_AUTHONLY_TYPE);
2186
2187         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2188
2189         return TEST_SUCCESS;
2190 }
2191
2192 static int
2193 test_AES_chain_armv8_all(void)
2194 {
2195         struct crypto_testsuite_params *ts_params = &testsuite_params;
2196         int status;
2197
2198         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2199                 ts_params->op_mpool,
2200                 ts_params->session_mpool, ts_params->session_priv_mpool,
2201                 ts_params->valid_devs[0],
2202                 rte_cryptodev_driver_id_get(
2203                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)),
2204                 BLKCIPHER_AES_CHAIN_TYPE);
2205
2206         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2207
2208         return TEST_SUCCESS;
2209 }
2210
2211 static int
2212 test_AES_chain_mrvl_all(void)
2213 {
2214         struct crypto_testsuite_params *ts_params = &testsuite_params;
2215         int status;
2216
2217         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2218                 ts_params->op_mpool,
2219                 ts_params->session_mpool, ts_params->session_priv_mpool,
2220                 ts_params->valid_devs[0],
2221                 rte_cryptodev_driver_id_get(
2222                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2223                 BLKCIPHER_AES_CHAIN_TYPE);
2224
2225         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2226
2227         return TEST_SUCCESS;
2228 }
2229
2230 static int
2231 test_AES_cipheronly_mrvl_all(void)
2232 {
2233         struct crypto_testsuite_params *ts_params = &testsuite_params;
2234         int status;
2235
2236         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2237                 ts_params->op_mpool,
2238                 ts_params->session_mpool, ts_params->session_priv_mpool,
2239                 ts_params->valid_devs[0],
2240                 rte_cryptodev_driver_id_get(
2241                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2242                 BLKCIPHER_AES_CIPHERONLY_TYPE);
2243
2244         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2245
2246         return TEST_SUCCESS;
2247 }
2248
2249 static int
2250 test_authonly_mrvl_all(void)
2251 {
2252         struct crypto_testsuite_params *ts_params = &testsuite_params;
2253         int status;
2254
2255         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2256                 ts_params->op_mpool,
2257                 ts_params->session_mpool, ts_params->session_priv_mpool,
2258                 ts_params->valid_devs[0],
2259                 rte_cryptodev_driver_id_get(
2260                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2261                 BLKCIPHER_AUTHONLY_TYPE);
2262
2263         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2264
2265         return TEST_SUCCESS;
2266 }
2267
2268 static int
2269 test_3DES_chain_mrvl_all(void)
2270 {
2271         struct crypto_testsuite_params *ts_params = &testsuite_params;
2272         int status;
2273
2274         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2275                 ts_params->op_mpool,
2276                 ts_params->session_mpool, ts_params->session_priv_mpool,
2277                 ts_params->valid_devs[0],
2278                 rte_cryptodev_driver_id_get(
2279                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2280                 BLKCIPHER_3DES_CHAIN_TYPE);
2281
2282         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2283
2284         return TEST_SUCCESS;
2285 }
2286
2287 static int
2288 test_3DES_cipheronly_mrvl_all(void)
2289 {
2290         struct crypto_testsuite_params *ts_params = &testsuite_params;
2291         int status;
2292
2293         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2294                 ts_params->op_mpool,
2295                 ts_params->session_mpool, ts_params->session_priv_mpool,
2296                 ts_params->valid_devs[0],
2297                 rte_cryptodev_driver_id_get(
2298                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
2299                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
2300
2301         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2302
2303         return TEST_SUCCESS;
2304 }
2305
2306 static int
2307 test_AES_chain_octeontx_all(void)
2308 {
2309         struct crypto_testsuite_params *ts_params = &testsuite_params;
2310         int status;
2311
2312         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2313                 ts_params->op_mpool, ts_params->session_mpool,
2314                 ts_params->session_priv_mpool,
2315                 ts_params->valid_devs[0],
2316                 rte_cryptodev_driver_id_get(
2317                 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2318                 BLKCIPHER_AES_CHAIN_TYPE);
2319
2320         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2321
2322         return TEST_SUCCESS;
2323 }
2324
2325 static int
2326 test_AES_cipheronly_octeontx_all(void)
2327 {
2328         struct crypto_testsuite_params *ts_params = &testsuite_params;
2329         int status;
2330
2331         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2332                 ts_params->op_mpool, ts_params->session_mpool,
2333                 ts_params->session_priv_mpool,
2334                 ts_params->valid_devs[0],
2335                 rte_cryptodev_driver_id_get(
2336                 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2337                 BLKCIPHER_AES_CIPHERONLY_TYPE);
2338
2339         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2340
2341         return TEST_SUCCESS;
2342 }
2343
2344 static int
2345 test_3DES_chain_octeontx_all(void)
2346 {
2347         struct crypto_testsuite_params *ts_params = &testsuite_params;
2348         int status;
2349
2350         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2351                 ts_params->op_mpool, ts_params->session_mpool,
2352                 ts_params->session_priv_mpool,
2353                 ts_params->valid_devs[0],
2354                 rte_cryptodev_driver_id_get(
2355                 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2356                 BLKCIPHER_3DES_CHAIN_TYPE);
2357
2358         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2359
2360         return TEST_SUCCESS;
2361 }
2362
2363 static int
2364 test_AES_chain_nitrox_all(void)
2365 {
2366         struct crypto_testsuite_params *ts_params = &testsuite_params;
2367         int status;
2368
2369         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2370                 ts_params->op_mpool,
2371                 ts_params->session_mpool, ts_params->session_priv_mpool,
2372                 ts_params->valid_devs[0],
2373                 rte_cryptodev_driver_id_get(
2374                 RTE_STR(CRYPTODEV_NAME_NITROX_PMD)),
2375                 BLKCIPHER_AES_CHAIN_TYPE);
2376
2377         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2378
2379         return TEST_SUCCESS;
2380 }
2381
2382 static int
2383 test_3DES_cipheronly_octeontx_all(void)
2384 {
2385         struct crypto_testsuite_params *ts_params = &testsuite_params;
2386         int status;
2387
2388         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2389                 ts_params->op_mpool, ts_params->session_mpool,
2390                 ts_params->session_priv_mpool,
2391                 ts_params->valid_devs[0],
2392                 rte_cryptodev_driver_id_get(
2393                 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2394                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
2395
2396         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2397
2398         return TEST_SUCCESS;
2399 }
2400
2401 static int
2402 test_authonly_octeontx_all(void)
2403 {
2404         struct crypto_testsuite_params *ts_params = &testsuite_params;
2405         int status;
2406
2407         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2408                 ts_params->op_mpool, ts_params->session_mpool,
2409                 ts_params->session_priv_mpool,
2410                 ts_params->valid_devs[0],
2411                 rte_cryptodev_driver_id_get(
2412                 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
2413                 BLKCIPHER_AUTHONLY_TYPE);
2414
2415         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2416
2417         return TEST_SUCCESS;
2418 }
2419
2420 static int
2421 test_AES_chain_octeontx2_all(void)
2422 {
2423         struct crypto_testsuite_params *ts_params = &testsuite_params;
2424         int status;
2425
2426         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2427                 ts_params->op_mpool, ts_params->session_mpool,
2428                 ts_params->session_priv_mpool,
2429                 ts_params->valid_devs[0],
2430                 rte_cryptodev_driver_id_get(
2431                 RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)),
2432                 BLKCIPHER_AES_CHAIN_TYPE);
2433
2434         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2435
2436         return TEST_SUCCESS;
2437 }
2438
2439 static int
2440 test_AES_cipheronly_octeontx2_all(void)
2441 {
2442         struct crypto_testsuite_params *ts_params = &testsuite_params;
2443         int status;
2444
2445         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2446                 ts_params->op_mpool, ts_params->session_mpool,
2447                 ts_params->session_priv_mpool,
2448                 ts_params->valid_devs[0],
2449                 rte_cryptodev_driver_id_get(
2450                 RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)),
2451                 BLKCIPHER_AES_CIPHERONLY_TYPE);
2452
2453         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2454
2455         return TEST_SUCCESS;
2456 }
2457
2458 static int
2459 test_3DES_chain_octeontx2_all(void)
2460 {
2461         struct crypto_testsuite_params *ts_params = &testsuite_params;
2462         int status;
2463
2464         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2465                 ts_params->op_mpool, ts_params->session_mpool,
2466                 ts_params->session_priv_mpool,
2467                 ts_params->valid_devs[0],
2468                 rte_cryptodev_driver_id_get(
2469                 RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)),
2470                 BLKCIPHER_3DES_CHAIN_TYPE);
2471
2472         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2473
2474         return TEST_SUCCESS;
2475 }
2476
2477 static int
2478 test_3DES_cipheronly_octeontx2_all(void)
2479 {
2480         struct crypto_testsuite_params *ts_params = &testsuite_params;
2481         int status;
2482
2483         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2484                 ts_params->op_mpool, ts_params->session_mpool,
2485                 ts_params->session_priv_mpool,
2486                 ts_params->valid_devs[0],
2487                 rte_cryptodev_driver_id_get(
2488                 RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)),
2489                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
2490
2491         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2492
2493         return TEST_SUCCESS;
2494 }
2495
2496 static int
2497 test_authonly_octeontx2_all(void)
2498 {
2499         struct crypto_testsuite_params *ts_params = &testsuite_params;
2500         int status;
2501
2502         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
2503                 ts_params->op_mpool, ts_params->session_mpool,
2504                 ts_params->session_priv_mpool,
2505                 ts_params->valid_devs[0],
2506                 rte_cryptodev_driver_id_get(
2507                 RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)),
2508                 BLKCIPHER_AUTHONLY_TYPE);
2509
2510         TEST_ASSERT_EQUAL(status, 0, "Test failed");
2511
2512         return TEST_SUCCESS;
2513 }
2514
2515 /* ***** SNOW 3G Tests ***** */
2516 static int
2517 create_wireless_algo_hash_session(uint8_t dev_id,
2518         const uint8_t *key, const uint8_t key_len,
2519         const uint8_t iv_len, const uint8_t auth_len,
2520         enum rte_crypto_auth_operation op,
2521         enum rte_crypto_auth_algorithm algo)
2522 {
2523         uint8_t hash_key[key_len];
2524         int status;
2525
2526         struct crypto_testsuite_params *ts_params = &testsuite_params;
2527         struct crypto_unittest_params *ut_params = &unittest_params;
2528
2529         memcpy(hash_key, key, key_len);
2530
2531         debug_hexdump(stdout, "key:", key, key_len);
2532
2533         /* Setup Authentication Parameters */
2534         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2535         ut_params->auth_xform.next = NULL;
2536
2537         ut_params->auth_xform.auth.op = op;
2538         ut_params->auth_xform.auth.algo = algo;
2539         ut_params->auth_xform.auth.key.length = key_len;
2540         ut_params->auth_xform.auth.key.data = hash_key;
2541         ut_params->auth_xform.auth.digest_length = auth_len;
2542         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2543         ut_params->auth_xform.auth.iv.length = iv_len;
2544         ut_params->sess = rte_cryptodev_sym_session_create(
2545                         ts_params->session_mpool);
2546
2547         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2548                         &ut_params->auth_xform,
2549                         ts_params->session_priv_mpool);
2550         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2551         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2552         return 0;
2553 }
2554
2555 static int
2556 create_wireless_algo_cipher_session(uint8_t dev_id,
2557                         enum rte_crypto_cipher_operation op,
2558                         enum rte_crypto_cipher_algorithm algo,
2559                         const uint8_t *key, const uint8_t key_len,
2560                         uint8_t iv_len)
2561 {
2562         uint8_t cipher_key[key_len];
2563         int status;
2564         struct crypto_testsuite_params *ts_params = &testsuite_params;
2565         struct crypto_unittest_params *ut_params = &unittest_params;
2566
2567         memcpy(cipher_key, key, key_len);
2568
2569         /* Setup Cipher Parameters */
2570         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2571         ut_params->cipher_xform.next = NULL;
2572
2573         ut_params->cipher_xform.cipher.algo = algo;
2574         ut_params->cipher_xform.cipher.op = op;
2575         ut_params->cipher_xform.cipher.key.data = cipher_key;
2576         ut_params->cipher_xform.cipher.key.length = key_len;
2577         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2578         ut_params->cipher_xform.cipher.iv.length = iv_len;
2579
2580         debug_hexdump(stdout, "key:", key, key_len);
2581
2582         /* Create Crypto session */
2583         ut_params->sess = rte_cryptodev_sym_session_create(
2584                         ts_params->session_mpool);
2585
2586         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2587                         &ut_params->cipher_xform,
2588                         ts_params->session_priv_mpool);
2589         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2590         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2591         return 0;
2592 }
2593
2594 static int
2595 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2596                         unsigned int cipher_len,
2597                         unsigned int cipher_offset)
2598 {
2599         struct crypto_testsuite_params *ts_params = &testsuite_params;
2600         struct crypto_unittest_params *ut_params = &unittest_params;
2601
2602         /* Generate Crypto op data structure */
2603         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2604                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2605         TEST_ASSERT_NOT_NULL(ut_params->op,
2606                                 "Failed to allocate pktmbuf offload");
2607
2608         /* Set crypto operation data parameters */
2609         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2610
2611         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2612
2613         /* set crypto operation source mbuf */
2614         sym_op->m_src = ut_params->ibuf;
2615
2616         /* iv */
2617         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2618                         iv, iv_len);
2619         sym_op->cipher.data.length = cipher_len;
2620         sym_op->cipher.data.offset = cipher_offset;
2621         return 0;
2622 }
2623
2624 static int
2625 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2626                         unsigned int cipher_len,
2627                         unsigned int cipher_offset)
2628 {
2629         struct crypto_testsuite_params *ts_params = &testsuite_params;
2630         struct crypto_unittest_params *ut_params = &unittest_params;
2631
2632         /* Generate Crypto op data structure */
2633         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2634                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2635         TEST_ASSERT_NOT_NULL(ut_params->op,
2636                                 "Failed to allocate pktmbuf offload");
2637
2638         /* Set crypto operation data parameters */
2639         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2640
2641         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2642
2643         /* set crypto operation source mbuf */
2644         sym_op->m_src = ut_params->ibuf;
2645         sym_op->m_dst = ut_params->obuf;
2646
2647         /* iv */
2648         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2649                         iv, iv_len);
2650         sym_op->cipher.data.length = cipher_len;
2651         sym_op->cipher.data.offset = cipher_offset;
2652         return 0;
2653 }
2654
2655 static int
2656 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2657                 enum rte_crypto_cipher_operation cipher_op,
2658                 enum rte_crypto_auth_operation auth_op,
2659                 enum rte_crypto_auth_algorithm auth_algo,
2660                 enum rte_crypto_cipher_algorithm cipher_algo,
2661                 const uint8_t *key, uint8_t key_len,
2662                 uint8_t auth_iv_len, uint8_t auth_len,
2663                 uint8_t cipher_iv_len)
2664
2665 {
2666         uint8_t cipher_auth_key[key_len];
2667         int status;
2668
2669         struct crypto_testsuite_params *ts_params = &testsuite_params;
2670         struct crypto_unittest_params *ut_params = &unittest_params;
2671
2672         memcpy(cipher_auth_key, key, key_len);
2673
2674         /* Setup Authentication Parameters */
2675         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2676         ut_params->auth_xform.next = NULL;
2677
2678         ut_params->auth_xform.auth.op = auth_op;
2679         ut_params->auth_xform.auth.algo = auth_algo;
2680         ut_params->auth_xform.auth.key.length = key_len;
2681         /* Hash key = cipher key */
2682         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2683         ut_params->auth_xform.auth.digest_length = auth_len;
2684         /* Auth IV will be after cipher IV */
2685         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2686         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2687
2688         /* Setup Cipher Parameters */
2689         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2690         ut_params->cipher_xform.next = &ut_params->auth_xform;
2691
2692         ut_params->cipher_xform.cipher.algo = cipher_algo;
2693         ut_params->cipher_xform.cipher.op = cipher_op;
2694         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2695         ut_params->cipher_xform.cipher.key.length = key_len;
2696         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2697         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2698
2699         debug_hexdump(stdout, "key:", key, key_len);
2700
2701         /* Create Crypto session*/
2702         ut_params->sess = rte_cryptodev_sym_session_create(
2703                         ts_params->session_mpool);
2704         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2705
2706         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2707                         &ut_params->cipher_xform,
2708                         ts_params->session_priv_mpool);
2709         if (status == -ENOTSUP)
2710                 return status;
2711
2712         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2713         return 0;
2714 }
2715
2716 static int
2717 create_wireless_cipher_auth_session(uint8_t dev_id,
2718                 enum rte_crypto_cipher_operation cipher_op,
2719                 enum rte_crypto_auth_operation auth_op,
2720                 enum rte_crypto_auth_algorithm auth_algo,
2721                 enum rte_crypto_cipher_algorithm cipher_algo,
2722                 const struct wireless_test_data *tdata)
2723 {
2724         const uint8_t key_len = tdata->key.len;
2725         uint8_t cipher_auth_key[key_len];
2726         int status;
2727
2728         struct crypto_testsuite_params *ts_params = &testsuite_params;
2729         struct crypto_unittest_params *ut_params = &unittest_params;
2730         const uint8_t *key = tdata->key.data;
2731         const uint8_t auth_len = tdata->digest.len;
2732         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2733         uint8_t auth_iv_len = tdata->auth_iv.len;
2734
2735         memcpy(cipher_auth_key, key, key_len);
2736
2737         /* Setup Authentication Parameters */
2738         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2739         ut_params->auth_xform.next = NULL;
2740
2741         ut_params->auth_xform.auth.op = auth_op;
2742         ut_params->auth_xform.auth.algo = auth_algo;
2743         ut_params->auth_xform.auth.key.length = key_len;
2744         /* Hash key = cipher key */
2745         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2746         ut_params->auth_xform.auth.digest_length = auth_len;
2747         /* Auth IV will be after cipher IV */
2748         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2749         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2750
2751         /* Setup Cipher Parameters */
2752         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2753         ut_params->cipher_xform.next = &ut_params->auth_xform;
2754
2755         ut_params->cipher_xform.cipher.algo = cipher_algo;
2756         ut_params->cipher_xform.cipher.op = cipher_op;
2757         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2758         ut_params->cipher_xform.cipher.key.length = key_len;
2759         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2760         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2761
2762
2763         debug_hexdump(stdout, "key:", key, key_len);
2764
2765         /* Create Crypto session*/
2766         ut_params->sess = rte_cryptodev_sym_session_create(
2767                         ts_params->session_mpool);
2768
2769         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2770                         &ut_params->cipher_xform,
2771                         ts_params->session_priv_mpool);
2772
2773         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2774         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2775         return 0;
2776 }
2777
2778 static int
2779 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2780                 const struct wireless_test_data *tdata)
2781 {
2782         return create_wireless_cipher_auth_session(dev_id,
2783                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2784                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2785                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2786 }
2787
2788 static int
2789 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2790                 enum rte_crypto_cipher_operation cipher_op,
2791                 enum rte_crypto_auth_operation auth_op,
2792                 enum rte_crypto_auth_algorithm auth_algo,
2793                 enum rte_crypto_cipher_algorithm cipher_algo,
2794                 const uint8_t *key, const uint8_t key_len,
2795                 uint8_t auth_iv_len, uint8_t auth_len,
2796                 uint8_t cipher_iv_len)
2797 {
2798         uint8_t auth_cipher_key[key_len];
2799         int status;
2800         struct crypto_testsuite_params *ts_params = &testsuite_params;
2801         struct crypto_unittest_params *ut_params = &unittest_params;
2802
2803         memcpy(auth_cipher_key, key, key_len);
2804
2805         /* Setup Authentication Parameters */
2806         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2807         ut_params->auth_xform.auth.op = auth_op;
2808         ut_params->auth_xform.next = &ut_params->cipher_xform;
2809         ut_params->auth_xform.auth.algo = auth_algo;
2810         ut_params->auth_xform.auth.key.length = key_len;
2811         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2812         ut_params->auth_xform.auth.digest_length = auth_len;
2813         /* Auth IV will be after cipher IV */
2814         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2815         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2816
2817         /* Setup Cipher Parameters */
2818         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2819         ut_params->cipher_xform.next = NULL;
2820         ut_params->cipher_xform.cipher.algo = cipher_algo;
2821         ut_params->cipher_xform.cipher.op = cipher_op;
2822         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2823         ut_params->cipher_xform.cipher.key.length = key_len;
2824         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2825         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2826
2827         debug_hexdump(stdout, "key:", key, key_len);
2828
2829         /* Create Crypto session*/
2830         ut_params->sess = rte_cryptodev_sym_session_create(
2831                         ts_params->session_mpool);
2832         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2833
2834         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2835                 ut_params->auth_xform.next = NULL;
2836                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2837                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2838                                 &ut_params->cipher_xform,
2839                                 ts_params->session_priv_mpool);
2840
2841         } else
2842                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2843                                 &ut_params->auth_xform,
2844                                 ts_params->session_priv_mpool);
2845
2846         if (status == -ENOTSUP)
2847                 return status;
2848
2849         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2850
2851         return 0;
2852 }
2853
2854 static int
2855 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2856                 unsigned int auth_tag_len,
2857                 const uint8_t *iv, unsigned int iv_len,
2858                 unsigned int data_pad_len,
2859                 enum rte_crypto_auth_operation op,
2860                 unsigned int auth_len, unsigned int auth_offset)
2861 {
2862         struct crypto_testsuite_params *ts_params = &testsuite_params;
2863
2864         struct crypto_unittest_params *ut_params = &unittest_params;
2865
2866         /* Generate Crypto op data structure */
2867         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2868                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2869         TEST_ASSERT_NOT_NULL(ut_params->op,
2870                 "Failed to allocate pktmbuf offload");
2871
2872         /* Set crypto operation data parameters */
2873         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2874
2875         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2876
2877         /* set crypto operation source mbuf */
2878         sym_op->m_src = ut_params->ibuf;
2879
2880         /* iv */
2881         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2882                         iv, iv_len);
2883         /* digest */
2884         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2885                                         ut_params->ibuf, auth_tag_len);
2886
2887         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2888                                 "no room to append auth tag");
2889         ut_params->digest = sym_op->auth.digest.data;
2890         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2891                         ut_params->ibuf, data_pad_len);
2892         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2893                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2894         else
2895                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2896
2897         debug_hexdump(stdout, "digest:",
2898                 sym_op->auth.digest.data,
2899                 auth_tag_len);
2900
2901         sym_op->auth.data.length = auth_len;
2902         sym_op->auth.data.offset = auth_offset;
2903
2904         return 0;
2905 }
2906
2907 static int
2908 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2909         enum rte_crypto_auth_operation op)
2910 {
2911         struct crypto_testsuite_params *ts_params = &testsuite_params;
2912         struct crypto_unittest_params *ut_params = &unittest_params;
2913
2914         const uint8_t *auth_tag = tdata->digest.data;
2915         const unsigned int auth_tag_len = tdata->digest.len;
2916         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2917         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2918
2919         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2920         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2921         const uint8_t *auth_iv = tdata->auth_iv.data;
2922         const uint8_t auth_iv_len = tdata->auth_iv.len;
2923         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2924         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2925
2926         /* Generate Crypto op data structure */
2927         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2928                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2929         TEST_ASSERT_NOT_NULL(ut_params->op,
2930                         "Failed to allocate pktmbuf offload");
2931         /* Set crypto operation data parameters */
2932         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2933
2934         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2935
2936         /* set crypto operation source mbuf */
2937         sym_op->m_src = ut_params->ibuf;
2938
2939         /* digest */
2940         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2941                         ut_params->ibuf, auth_tag_len);
2942
2943         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2944                         "no room to append auth tag");
2945         ut_params->digest = sym_op->auth.digest.data;
2946         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2947                         ut_params->ibuf, data_pad_len);
2948         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2949                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2950         else
2951                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2952
2953         debug_hexdump(stdout, "digest:",
2954                 sym_op->auth.digest.data,
2955                 auth_tag_len);
2956
2957         /* Copy cipher and auth IVs at the end of the crypto operation */
2958         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2959                                                 IV_OFFSET);
2960         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2961         iv_ptr += cipher_iv_len;
2962         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2963
2964         sym_op->cipher.data.length = cipher_len;
2965         sym_op->cipher.data.offset = 0;
2966         sym_op->auth.data.length = auth_len;
2967         sym_op->auth.data.offset = 0;
2968
2969         return 0;
2970 }
2971
2972 static int
2973 create_zuc_cipher_hash_generate_operation(
2974                 const struct wireless_test_data *tdata)
2975 {
2976         return create_wireless_cipher_hash_operation(tdata,
2977                 RTE_CRYPTO_AUTH_OP_GENERATE);
2978 }
2979
2980 static int
2981 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2982                 const unsigned auth_tag_len,
2983                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2984                 unsigned data_pad_len,
2985                 enum rte_crypto_auth_operation op,
2986                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2987                 const unsigned cipher_len, const unsigned cipher_offset,
2988                 const unsigned auth_len, const unsigned auth_offset)
2989 {
2990         struct crypto_testsuite_params *ts_params = &testsuite_params;
2991         struct crypto_unittest_params *ut_params = &unittest_params;
2992
2993         enum rte_crypto_cipher_algorithm cipher_algo =
2994                         ut_params->cipher_xform.cipher.algo;
2995         enum rte_crypto_auth_algorithm auth_algo =
2996                         ut_params->auth_xform.auth.algo;
2997
2998         /* Generate Crypto op data structure */
2999         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3000                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3001         TEST_ASSERT_NOT_NULL(ut_params->op,
3002                         "Failed to allocate pktmbuf offload");
3003         /* Set crypto operation data parameters */
3004         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3005
3006         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3007
3008         /* set crypto operation source mbuf */
3009         sym_op->m_src = ut_params->ibuf;
3010
3011         /* digest */
3012         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
3013                         ut_params->ibuf, auth_tag_len);
3014
3015         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
3016                         "no room to append auth tag");
3017         ut_params->digest = sym_op->auth.digest.data;
3018
3019         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
3020                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3021                                 ut_params->ibuf, data_pad_len);
3022         } else {
3023                 struct rte_mbuf *m = ut_params->ibuf;
3024                 unsigned int offset = data_pad_len;
3025
3026                 while (offset > m->data_len && m->next != NULL) {
3027                         offset -= m->data_len;
3028                         m = m->next;
3029                 }
3030                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3031                         m, offset);
3032         }
3033
3034         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
3035                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
3036         else
3037                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3038
3039         debug_hexdump(stdout, "digest:",
3040                 sym_op->auth.digest.data,
3041                 auth_tag_len);
3042
3043         /* Copy cipher and auth IVs at the end of the crypto operation */
3044         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
3045                                                 IV_OFFSET);
3046         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3047         iv_ptr += cipher_iv_len;
3048         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3049
3050         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3051                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3052                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3053                 sym_op->cipher.data.length = cipher_len;
3054                 sym_op->cipher.data.offset = cipher_offset;
3055         } else {
3056                 sym_op->cipher.data.length = cipher_len >> 3;
3057                 sym_op->cipher.data.offset = cipher_offset >> 3;
3058         }
3059
3060         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3061                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3062                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3063                 sym_op->auth.data.length = auth_len;
3064                 sym_op->auth.data.offset = auth_offset;
3065         } else {
3066                 sym_op->auth.data.length = auth_len >> 3;
3067                 sym_op->auth.data.offset = auth_offset >> 3;
3068         }
3069
3070         return 0;
3071 }
3072
3073 static int
3074 create_wireless_algo_auth_cipher_operation(
3075                 const uint8_t *auth_tag, unsigned int auth_tag_len,
3076                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
3077                 const uint8_t *auth_iv, uint8_t auth_iv_len,
3078                 unsigned int data_pad_len,
3079                 unsigned int cipher_len, unsigned int cipher_offset,
3080                 unsigned int auth_len, unsigned int auth_offset,
3081                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
3082 {
3083         struct crypto_testsuite_params *ts_params = &testsuite_params;
3084         struct crypto_unittest_params *ut_params = &unittest_params;
3085
3086         enum rte_crypto_cipher_algorithm cipher_algo =
3087                         ut_params->cipher_xform.cipher.algo;
3088         enum rte_crypto_auth_algorithm auth_algo =
3089                         ut_params->auth_xform.auth.algo;
3090
3091         /* Generate Crypto op data structure */
3092         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3093                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3094         TEST_ASSERT_NOT_NULL(ut_params->op,
3095                         "Failed to allocate pktmbuf offload");
3096
3097         /* Set crypto operation data parameters */
3098         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3099
3100         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3101
3102         /* set crypto operation mbufs */
3103         sym_op->m_src = ut_params->ibuf;
3104         if (op_mode == OUT_OF_PLACE)
3105                 sym_op->m_dst = ut_params->obuf;
3106
3107         /* digest */
3108         if (!do_sgl) {
3109                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
3110                         (op_mode == IN_PLACE ?
3111                                 ut_params->ibuf : ut_params->obuf),
3112                         uint8_t *, data_pad_len);
3113                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3114                         (op_mode == IN_PLACE ?
3115                                 ut_params->ibuf : ut_params->obuf),
3116                         data_pad_len);
3117                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
3118         } else {
3119                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
3120                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
3121                                 sym_op->m_src : sym_op->m_dst);
3122                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
3123                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
3124                         sgl_buf = sgl_buf->next;
3125                 }
3126                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
3127                                 uint8_t *, remaining_off);
3128                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
3129                                 remaining_off);
3130                 memset(sym_op->auth.digest.data, 0, remaining_off);
3131                 while (sgl_buf->next != NULL) {
3132                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
3133                                 0, rte_pktmbuf_data_len(sgl_buf));
3134                         sgl_buf = sgl_buf->next;
3135                 }
3136         }
3137
3138         /* Copy digest for the verification */
3139         if (verify)
3140                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3141
3142         /* Copy cipher and auth IVs at the end of the crypto operation */
3143         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3144                         ut_params->op, uint8_t *, IV_OFFSET);
3145
3146         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3147         iv_ptr += cipher_iv_len;
3148         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3149
3150         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3151                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3152                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3153                 sym_op->cipher.data.length = cipher_len;
3154                 sym_op->cipher.data.offset = cipher_offset;
3155         } else {
3156                 sym_op->cipher.data.length = cipher_len >> 3;
3157                 sym_op->cipher.data.offset = cipher_offset >> 3;
3158         }
3159
3160         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3161                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3162                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3163                 sym_op->auth.data.length = auth_len;
3164                 sym_op->auth.data.offset = auth_offset;
3165         } else {
3166                 sym_op->auth.data.length = auth_len >> 3;
3167                 sym_op->auth.data.offset = auth_offset >> 3;
3168         }
3169
3170         return 0;
3171 }
3172
3173 static int
3174 test_snow3g_authentication(const struct snow3g_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 SNOW 3G session */
3185         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3186                         tdata->key.data, tdata->key.len,
3187                         tdata->auth_iv.len, tdata->digest.len,
3188                         RTE_CRYPTO_AUTH_OP_GENERATE,
3189                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3190         if (retval < 0)
3191                 return retval;
3192
3193         /* alloc mbuf and set payload */
3194         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3195
3196         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3197         rte_pktmbuf_tailroom(ut_params->ibuf));
3198
3199         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3200         /* Append data which is padded to a multiple of */
3201         /* the algorithms block size */
3202         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3203         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3204                                 plaintext_pad_len);
3205         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3206
3207         /* Create SNOW 3G operation */
3208         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3209                         tdata->auth_iv.data, tdata->auth_iv.len,
3210                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3211                         tdata->validAuthLenInBits.len,
3212                         0);
3213         if (retval < 0)
3214                 return retval;
3215
3216         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3217                                 ut_params->op);
3218         ut_params->obuf = ut_params->op->sym->m_src;
3219         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3220         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3221                         + plaintext_pad_len;
3222
3223         /* Validate obuf */
3224         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3225         ut_params->digest,
3226         tdata->digest.data,
3227         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3228         "SNOW 3G Generated auth tag not as expected");
3229
3230         return 0;
3231 }
3232
3233 static int
3234 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3235 {
3236         struct crypto_testsuite_params *ts_params = &testsuite_params;
3237         struct crypto_unittest_params *ut_params = &unittest_params;
3238
3239         int retval;
3240         unsigned plaintext_pad_len;
3241         unsigned plaintext_len;
3242         uint8_t *plaintext;
3243
3244         /* Create SNOW 3G session */
3245         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3246                                 tdata->key.data, tdata->key.len,
3247                                 tdata->auth_iv.len, tdata->digest.len,
3248                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3249                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3250         if (retval < 0)
3251                 return retval;
3252         /* alloc mbuf and set payload */
3253         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3254
3255         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3256         rte_pktmbuf_tailroom(ut_params->ibuf));
3257
3258         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3259         /* Append data which is padded to a multiple of */
3260         /* the algorithms block size */
3261         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3262         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3263                                 plaintext_pad_len);
3264         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3265
3266         /* Create SNOW 3G operation */
3267         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3268                         tdata->digest.len,
3269                         tdata->auth_iv.data, tdata->auth_iv.len,
3270                         plaintext_pad_len,
3271                         RTE_CRYPTO_AUTH_OP_VERIFY,
3272                         tdata->validAuthLenInBits.len,
3273                         0);
3274         if (retval < 0)
3275                 return retval;
3276
3277         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3278                                 ut_params->op);
3279         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3280         ut_params->obuf = ut_params->op->sym->m_src;
3281         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3282                                 + plaintext_pad_len;
3283
3284         /* Validate obuf */
3285         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3286                 return 0;
3287         else
3288                 return -1;
3289
3290         return 0;
3291 }
3292
3293 static int
3294 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3295 {
3296         struct crypto_testsuite_params *ts_params = &testsuite_params;
3297         struct crypto_unittest_params *ut_params = &unittest_params;
3298
3299         int retval;
3300         unsigned plaintext_pad_len;
3301         unsigned plaintext_len;
3302         uint8_t *plaintext;
3303
3304         /* Create KASUMI session */
3305         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3306                         tdata->key.data, tdata->key.len,
3307                         0, tdata->digest.len,
3308                         RTE_CRYPTO_AUTH_OP_GENERATE,
3309                         RTE_CRYPTO_AUTH_KASUMI_F9);
3310         if (retval < 0)
3311                 return retval;
3312
3313         /* alloc mbuf and set payload */
3314         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3315
3316         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3317         rte_pktmbuf_tailroom(ut_params->ibuf));
3318
3319         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3320         /* Append data which is padded to a multiple of */
3321         /* the algorithms block size */
3322         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3323         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3324                                 plaintext_pad_len);
3325         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3326
3327         /* Create KASUMI operation */
3328         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3329                         NULL, 0,
3330                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3331                         tdata->plaintext.len,
3332                         0);
3333         if (retval < 0)
3334                 return retval;
3335
3336         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3337                                 ut_params->op);
3338         ut_params->obuf = ut_params->op->sym->m_src;
3339         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3340         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3341                         + plaintext_pad_len;
3342
3343         /* Validate obuf */
3344         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3345         ut_params->digest,
3346         tdata->digest.data,
3347         DIGEST_BYTE_LENGTH_KASUMI_F9,
3348         "KASUMI Generated auth tag not as expected");
3349
3350         return 0;
3351 }
3352
3353 static int
3354 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3355 {
3356         struct crypto_testsuite_params *ts_params = &testsuite_params;
3357         struct crypto_unittest_params *ut_params = &unittest_params;
3358
3359         int retval;
3360         unsigned plaintext_pad_len;
3361         unsigned plaintext_len;
3362         uint8_t *plaintext;
3363
3364         /* Create KASUMI session */
3365         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3366                                 tdata->key.data, tdata->key.len,
3367                                 0, tdata->digest.len,
3368                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3369                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3370         if (retval < 0)
3371                 return retval;
3372         /* alloc mbuf and set payload */
3373         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3374
3375         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3376         rte_pktmbuf_tailroom(ut_params->ibuf));
3377
3378         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3379         /* Append data which is padded to a multiple */
3380         /* of the algorithms block size */
3381         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3382         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3383                                 plaintext_pad_len);
3384         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3385
3386         /* Create KASUMI operation */
3387         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3388                         tdata->digest.len,
3389                         NULL, 0,
3390                         plaintext_pad_len,
3391                         RTE_CRYPTO_AUTH_OP_VERIFY,
3392                         tdata->plaintext.len,
3393                         0);
3394         if (retval < 0)
3395                 return retval;
3396
3397         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3398                                 ut_params->op);
3399         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3400         ut_params->obuf = ut_params->op->sym->m_src;
3401         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3402                                 + plaintext_pad_len;
3403
3404         /* Validate obuf */
3405         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3406                 return 0;
3407         else
3408                 return -1;
3409
3410         return 0;
3411 }
3412
3413 static int
3414 test_snow3g_hash_generate_test_case_1(void)
3415 {
3416         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3417 }
3418
3419 static int
3420 test_snow3g_hash_generate_test_case_2(void)
3421 {
3422         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3423 }
3424
3425 static int
3426 test_snow3g_hash_generate_test_case_3(void)
3427 {
3428         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3429 }
3430
3431 static int
3432 test_snow3g_hash_generate_test_case_4(void)
3433 {
3434         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3435 }
3436
3437 static int
3438 test_snow3g_hash_generate_test_case_5(void)
3439 {
3440         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3441 }
3442
3443 static int
3444 test_snow3g_hash_generate_test_case_6(void)
3445 {
3446         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3447 }
3448
3449 static int
3450 test_snow3g_hash_verify_test_case_1(void)
3451 {
3452         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3453
3454 }
3455
3456 static int
3457 test_snow3g_hash_verify_test_case_2(void)
3458 {
3459         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3460 }
3461
3462 static int
3463 test_snow3g_hash_verify_test_case_3(void)
3464 {
3465         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3466 }
3467
3468 static int
3469 test_snow3g_hash_verify_test_case_4(void)
3470 {
3471         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3472 }
3473
3474 static int
3475 test_snow3g_hash_verify_test_case_5(void)
3476 {
3477         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3478 }
3479
3480 static int
3481 test_snow3g_hash_verify_test_case_6(void)
3482 {
3483         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3484 }
3485
3486 static int
3487 test_kasumi_hash_generate_test_case_1(void)
3488 {
3489         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3490 }
3491
3492 static int
3493 test_kasumi_hash_generate_test_case_2(void)
3494 {
3495         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3496 }
3497
3498 static int
3499 test_kasumi_hash_generate_test_case_3(void)
3500 {
3501         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3502 }
3503
3504 static int
3505 test_kasumi_hash_generate_test_case_4(void)
3506 {
3507         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3508 }
3509
3510 static int
3511 test_kasumi_hash_generate_test_case_5(void)
3512 {
3513         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3514 }
3515
3516 static int
3517 test_kasumi_hash_generate_test_case_6(void)
3518 {
3519         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3520 }
3521
3522 static int
3523 test_kasumi_hash_verify_test_case_1(void)
3524 {
3525         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3526 }
3527
3528 static int
3529 test_kasumi_hash_verify_test_case_2(void)
3530 {
3531         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3532 }
3533
3534 static int
3535 test_kasumi_hash_verify_test_case_3(void)
3536 {
3537         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3538 }
3539
3540 static int
3541 test_kasumi_hash_verify_test_case_4(void)
3542 {
3543         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3544 }
3545
3546 static int
3547 test_kasumi_hash_verify_test_case_5(void)
3548 {
3549         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3550 }
3551
3552 static int
3553 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3554 {
3555         struct crypto_testsuite_params *ts_params = &testsuite_params;
3556         struct crypto_unittest_params *ut_params = &unittest_params;
3557
3558         int retval;
3559         uint8_t *plaintext, *ciphertext;
3560         unsigned plaintext_pad_len;
3561         unsigned plaintext_len;
3562
3563         /* Create KASUMI session */
3564         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3565                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3566                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3567                                         tdata->key.data, tdata->key.len,
3568                                         tdata->cipher_iv.len);
3569         if (retval < 0)
3570                 return retval;
3571
3572         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3573
3574         /* Clear mbuf payload */
3575         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3576                rte_pktmbuf_tailroom(ut_params->ibuf));
3577
3578         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3579         /* Append data which is padded to a multiple */
3580         /* of the algorithms block size */
3581         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3582         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3583                                 plaintext_pad_len);
3584         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3585
3586         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3587
3588         /* Create KASUMI operation */
3589         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3590                                 tdata->cipher_iv.len,
3591                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3592                                 tdata->validCipherOffsetInBits.len);
3593         if (retval < 0)
3594                 return retval;
3595
3596         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3597                                                 ut_params->op);
3598         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3599
3600         ut_params->obuf = ut_params->op->sym->m_dst;
3601         if (ut_params->obuf)
3602                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3603         else
3604                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3605
3606         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3607
3608         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3609                                 (tdata->validCipherOffsetInBits.len >> 3);
3610         /* Validate obuf */
3611         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3612                 ciphertext,
3613                 reference_ciphertext,
3614                 tdata->validCipherLenInBits.len,
3615                 "KASUMI Ciphertext data not as expected");
3616         return 0;
3617 }
3618
3619 static int
3620 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3621 {
3622         struct crypto_testsuite_params *ts_params = &testsuite_params;
3623         struct crypto_unittest_params *ut_params = &unittest_params;
3624
3625         int retval;
3626
3627         unsigned int plaintext_pad_len;
3628         unsigned int plaintext_len;
3629
3630         uint8_t buffer[10000];
3631         const uint8_t *ciphertext;
3632
3633         struct rte_cryptodev_info dev_info;
3634
3635         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3636
3637         uint64_t feat_flags = dev_info.feature_flags;
3638
3639         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3640                 printf("Device doesn't support in-place scatter-gather. "
3641                                 "Test Skipped.\n");
3642                 return -ENOTSUP;
3643         }
3644
3645         /* Create KASUMI session */
3646         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3647                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3648                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3649                                         tdata->key.data, tdata->key.len,
3650                                         tdata->cipher_iv.len);
3651         if (retval < 0)
3652                 return retval;
3653
3654         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3655
3656
3657         /* Append data which is padded to a multiple */
3658         /* of the algorithms block size */
3659         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3660
3661         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3662                         plaintext_pad_len, 10, 0);
3663
3664         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3665
3666         /* Create KASUMI operation */
3667         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3668                                 tdata->cipher_iv.len,
3669                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3670                                 tdata->validCipherOffsetInBits.len);
3671         if (retval < 0)
3672                 return retval;
3673
3674         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3675                                                 ut_params->op);
3676         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3677
3678         ut_params->obuf = ut_params->op->sym->m_dst;
3679
3680         if (ut_params->obuf)
3681                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3682                                 plaintext_len, buffer);
3683         else
3684                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3685                                 tdata->validCipherOffsetInBits.len >> 3,
3686                                 plaintext_len, buffer);
3687
3688         /* Validate obuf */
3689         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3690
3691         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3692                                 (tdata->validCipherOffsetInBits.len >> 3);
3693         /* Validate obuf */
3694         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3695                 ciphertext,
3696                 reference_ciphertext,
3697                 tdata->validCipherLenInBits.len,
3698                 "KASUMI Ciphertext data not as expected");
3699         return 0;
3700 }
3701
3702 static int
3703 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3704 {
3705         struct crypto_testsuite_params *ts_params = &testsuite_params;
3706         struct crypto_unittest_params *ut_params = &unittest_params;
3707
3708         int retval;
3709         uint8_t *plaintext, *ciphertext;
3710         unsigned plaintext_pad_len;
3711         unsigned plaintext_len;
3712
3713         /* Create KASUMI session */
3714         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3715                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3716                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3717                                         tdata->key.data, tdata->key.len,
3718                                         tdata->cipher_iv.len);
3719         if (retval < 0)
3720                 return retval;
3721
3722         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3723         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3724
3725         /* Clear mbuf payload */
3726         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3727                rte_pktmbuf_tailroom(ut_params->ibuf));
3728
3729         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3730         /* Append data which is padded to a multiple */
3731         /* of the algorithms block size */
3732         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3733         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3734                                 plaintext_pad_len);
3735         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3736         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3737
3738         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3739
3740         /* Create KASUMI operation */
3741         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3742                                 tdata->cipher_iv.len,
3743                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3744                                 tdata->validCipherOffsetInBits.len);
3745         if (retval < 0)
3746                 return retval;
3747
3748         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3749                                                 ut_params->op);
3750         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3751
3752         ut_params->obuf = ut_params->op->sym->m_dst;
3753         if (ut_params->obuf)
3754                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3755         else
3756                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3757
3758         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3759
3760         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3761                                 (tdata->validCipherOffsetInBits.len >> 3);
3762         /* Validate obuf */
3763         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3764                 ciphertext,
3765                 reference_ciphertext,
3766                 tdata->validCipherLenInBits.len,
3767                 "KASUMI Ciphertext data not as expected");
3768         return 0;
3769 }
3770
3771 static int
3772 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3773 {
3774         struct crypto_testsuite_params *ts_params = &testsuite_params;
3775         struct crypto_unittest_params *ut_params = &unittest_params;
3776
3777         int retval;
3778         unsigned int plaintext_pad_len;
3779         unsigned int plaintext_len;
3780
3781         const uint8_t *ciphertext;
3782         uint8_t buffer[2048];
3783
3784         struct rte_cryptodev_info dev_info;
3785
3786         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3787
3788         uint64_t feat_flags = dev_info.feature_flags;
3789         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3790                 printf("Device doesn't support out-of-place scatter-gather "
3791                                 "in both input and output mbufs. "
3792                                 "Test Skipped.\n");
3793                 return -ENOTSUP;
3794         }
3795
3796         /* Create KASUMI session */
3797         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3798                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3799                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3800                                         tdata->key.data, tdata->key.len,
3801                                         tdata->cipher_iv.len);
3802         if (retval < 0)
3803                 return retval;
3804
3805         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3806         /* Append data which is padded to a multiple */
3807         /* of the algorithms block size */
3808         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3809
3810         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3811                         plaintext_pad_len, 10, 0);
3812         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3813                         plaintext_pad_len, 3, 0);
3814
3815         /* Append data which is padded to a multiple */
3816         /* of the algorithms block size */
3817         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3818
3819         /* Create KASUMI operation */
3820         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3821                                 tdata->cipher_iv.len,
3822                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3823                                 tdata->validCipherOffsetInBits.len);
3824         if (retval < 0)
3825                 return retval;
3826
3827         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3828                                                 ut_params->op);
3829         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3830
3831         ut_params->obuf = ut_params->op->sym->m_dst;
3832         if (ut_params->obuf)
3833                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3834                                 plaintext_pad_len, buffer);
3835         else
3836                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3837                                 tdata->validCipherOffsetInBits.len >> 3,
3838                                 plaintext_pad_len, buffer);
3839
3840         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3841                                 (tdata->validCipherOffsetInBits.len >> 3);
3842         /* Validate obuf */
3843         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3844                 ciphertext,
3845                 reference_ciphertext,
3846                 tdata->validCipherLenInBits.len,
3847                 "KASUMI Ciphertext data not as expected");
3848         return 0;
3849 }
3850
3851
3852 static int
3853 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3854 {
3855         struct crypto_testsuite_params *ts_params = &testsuite_params;
3856         struct crypto_unittest_params *ut_params = &unittest_params;
3857
3858         int retval;
3859         uint8_t *ciphertext, *plaintext;
3860         unsigned ciphertext_pad_len;
3861         unsigned ciphertext_len;
3862
3863         /* Create KASUMI session */
3864         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3865                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3866                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3867                                         tdata->key.data, tdata->key.len,
3868                                         tdata->cipher_iv.len);
3869         if (retval < 0)
3870                 return retval;
3871
3872         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3873         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3874
3875         /* Clear mbuf payload */
3876         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3877                rte_pktmbuf_tailroom(ut_params->ibuf));
3878
3879         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3880         /* Append data which is padded to a multiple */
3881         /* of the algorithms block size */
3882         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3883         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3884                                 ciphertext_pad_len);
3885         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3886         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3887
3888         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3889
3890         /* Create KASUMI operation */
3891         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3892                                 tdata->cipher_iv.len,
3893                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3894                                 tdata->validCipherOffsetInBits.len);
3895         if (retval < 0)
3896                 return retval;
3897
3898         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3899                                                 ut_params->op);
3900         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3901
3902         ut_params->obuf = ut_params->op->sym->m_dst;
3903         if (ut_params->obuf)
3904                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3905         else
3906                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3907
3908         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3909
3910         const uint8_t *reference_plaintext = tdata->plaintext.data +
3911                                 (tdata->validCipherOffsetInBits.len >> 3);
3912         /* Validate obuf */
3913         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3914                 plaintext,
3915                 reference_plaintext,
3916                 tdata->validCipherLenInBits.len,
3917                 "KASUMI Plaintext data not as expected");
3918         return 0;
3919 }
3920
3921 static int
3922 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3923 {
3924         struct crypto_testsuite_params *ts_params = &testsuite_params;
3925         struct crypto_unittest_params *ut_params = &unittest_params;
3926
3927         int retval;
3928         uint8_t *ciphertext, *plaintext;
3929         unsigned ciphertext_pad_len;
3930         unsigned ciphertext_len;
3931
3932         /* Create KASUMI session */
3933         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3934                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3935                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3936                                         tdata->key.data, tdata->key.len,
3937                                         tdata->cipher_iv.len);
3938         if (retval < 0)
3939                 return retval;
3940
3941         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3942
3943         /* Clear mbuf payload */
3944         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3945                rte_pktmbuf_tailroom(ut_params->ibuf));
3946
3947         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3948         /* Append data which is padded to a multiple */
3949         /* of the algorithms block size */
3950         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3951         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3952                                 ciphertext_pad_len);
3953         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3954
3955         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3956
3957         /* Create KASUMI operation */
3958         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3959                                         tdata->cipher_iv.len,
3960                                         tdata->ciphertext.len,
3961                                         tdata->validCipherOffsetInBits.len);
3962         if (retval < 0)
3963                 return retval;
3964
3965         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3966                                                 ut_params->op);
3967         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3968
3969         ut_params->obuf = ut_params->op->sym->m_dst;
3970         if (ut_params->obuf)
3971                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3972         else
3973                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3974
3975         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3976
3977         const uint8_t *reference_plaintext = tdata->plaintext.data +
3978                                 (tdata->validCipherOffsetInBits.len >> 3);
3979         /* Validate obuf */
3980         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3981                 plaintext,
3982                 reference_plaintext,
3983                 tdata->validCipherLenInBits.len,
3984                 "KASUMI Plaintext data not as expected");
3985         return 0;
3986 }
3987
3988 static int
3989 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3990 {
3991         struct crypto_testsuite_params *ts_params = &testsuite_params;
3992         struct crypto_unittest_params *ut_params = &unittest_params;
3993
3994         int retval;
3995         uint8_t *plaintext, *ciphertext;
3996         unsigned plaintext_pad_len;
3997         unsigned plaintext_len;
3998
3999         /* Create SNOW 3G session */
4000         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4001                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4002                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4003                                         tdata->key.data, tdata->key.len,
4004                                         tdata->cipher_iv.len);
4005         if (retval < 0)
4006                 return retval;
4007
4008         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4009
4010         /* Clear mbuf payload */
4011         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4012                rte_pktmbuf_tailroom(ut_params->ibuf));
4013
4014         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4015         /* Append data which is padded to a multiple of */
4016         /* the algorithms block size */
4017         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4018         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4019                                 plaintext_pad_len);
4020         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4021
4022         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4023
4024         /* Create SNOW 3G operation */
4025         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4026                                         tdata->cipher_iv.len,
4027                                         tdata->validCipherLenInBits.len,
4028                                         0);
4029         if (retval < 0)
4030                 return retval;
4031
4032         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4033                                                 ut_params->op);
4034         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4035
4036         ut_params->obuf = ut_params->op->sym->m_dst;
4037         if (ut_params->obuf)
4038                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4039         else
4040                 ciphertext = plaintext;
4041
4042         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4043
4044         /* Validate obuf */
4045         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4046                 ciphertext,
4047                 tdata->ciphertext.data,
4048                 tdata->validDataLenInBits.len,
4049                 "SNOW 3G Ciphertext data not as expected");
4050         return 0;
4051 }
4052
4053
4054 static int
4055 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4056 {
4057         struct crypto_testsuite_params *ts_params = &testsuite_params;
4058         struct crypto_unittest_params *ut_params = &unittest_params;
4059         uint8_t *plaintext, *ciphertext;
4060
4061         int retval;
4062         unsigned plaintext_pad_len;
4063         unsigned plaintext_len;
4064
4065         /* Create SNOW 3G session */
4066         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4067                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4068                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4069                                         tdata->key.data, tdata->key.len,
4070                                         tdata->cipher_iv.len);
4071         if (retval < 0)
4072                 return retval;
4073
4074         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4075         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4076
4077         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4078                         "Failed to allocate input buffer in mempool");
4079         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4080                         "Failed to allocate output buffer in mempool");
4081
4082         /* Clear mbuf payload */
4083         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4084                rte_pktmbuf_tailroom(ut_params->ibuf));
4085
4086         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4087         /* Append data which is padded to a multiple of */
4088         /* the algorithms block size */
4089         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4090         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4091                                 plaintext_pad_len);
4092         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4093         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4094
4095         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4096
4097         /* Create SNOW 3G operation */
4098         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4099                                         tdata->cipher_iv.len,
4100                                         tdata->validCipherLenInBits.len,
4101                                         0);
4102         if (retval < 0)
4103                 return retval;
4104
4105         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4106                                                 ut_params->op);
4107         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4108
4109         ut_params->obuf = ut_params->op->sym->m_dst;
4110         if (ut_params->obuf)
4111                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4112         else
4113                 ciphertext = plaintext;
4114
4115         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4116
4117         /* Validate obuf */
4118         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4119                 ciphertext,
4120                 tdata->ciphertext.data,
4121                 tdata->validDataLenInBits.len,
4122                 "SNOW 3G Ciphertext data not as expected");
4123         return 0;
4124 }
4125
4126 static int
4127 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4128 {
4129         struct crypto_testsuite_params *ts_params = &testsuite_params;
4130         struct crypto_unittest_params *ut_params = &unittest_params;
4131
4132         int retval;
4133         unsigned int plaintext_pad_len;
4134         unsigned int plaintext_len;
4135         uint8_t buffer[10000];
4136         const uint8_t *ciphertext;
4137
4138         struct rte_cryptodev_info dev_info;
4139
4140         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4141
4142         uint64_t feat_flags = dev_info.feature_flags;
4143
4144         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4145                 printf("Device doesn't support out-of-place scatter-gather "
4146                                 "in both input and output mbufs. "
4147                                 "Test Skipped.\n");
4148                 return -ENOTSUP;
4149         }
4150
4151         /* Create SNOW 3G session */
4152         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4153                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4154                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4155                                         tdata->key.data, tdata->key.len,
4156                                         tdata->cipher_iv.len);
4157         if (retval < 0)
4158                 return retval;
4159
4160         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4161         /* Append data which is padded to a multiple of */
4162         /* the algorithms block size */
4163         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4164
4165         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4166                         plaintext_pad_len, 10, 0);
4167         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4168                         plaintext_pad_len, 3, 0);
4169
4170         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4171                         "Failed to allocate input buffer in mempool");
4172         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4173                         "Failed to allocate output buffer in mempool");
4174
4175         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4176
4177         /* Create SNOW 3G operation */
4178         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4179                                         tdata->cipher_iv.len,
4180                                         tdata->validCipherLenInBits.len,
4181                                         0);
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
4189         ut_params->obuf = ut_params->op->sym->m_dst;
4190         if (ut_params->obuf)
4191                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4192                                 plaintext_len, buffer);
4193         else
4194                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4195                                 plaintext_len, buffer);
4196
4197         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4198
4199         /* Validate obuf */
4200         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4201                 ciphertext,
4202                 tdata->ciphertext.data,
4203                 tdata->validDataLenInBits.len,
4204                 "SNOW 3G Ciphertext data not as expected");
4205
4206         return 0;
4207 }
4208
4209 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4210 static void
4211 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4212 {
4213         uint8_t curr_byte, prev_byte;
4214         uint32_t length_in_bytes = ceil_byte_length(length + offset);
4215         uint8_t lower_byte_mask = (1 << offset) - 1;
4216         unsigned i;
4217
4218         prev_byte = buffer[0];
4219         buffer[0] >>= offset;
4220
4221         for (i = 1; i < length_in_bytes; i++) {
4222                 curr_byte = buffer[i];
4223                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4224                                 (curr_byte >> offset);
4225                 prev_byte = curr_byte;
4226         }
4227 }
4228
4229 static int
4230 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4231 {
4232         struct crypto_testsuite_params *ts_params = &testsuite_params;
4233         struct crypto_unittest_params *ut_params = &unittest_params;
4234         uint8_t *plaintext, *ciphertext;
4235         int retval;
4236         uint32_t plaintext_len;
4237         uint32_t plaintext_pad_len;
4238         uint8_t extra_offset = 4;
4239         uint8_t *expected_ciphertext_shifted;
4240
4241         /* Create SNOW 3G session */
4242         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4243                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4244                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4245                                         tdata->key.data, tdata->key.len,
4246                                         tdata->cipher_iv.len);
4247         if (retval < 0)
4248                 return retval;
4249
4250         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4251         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4252
4253         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4254                         "Failed to allocate input buffer in mempool");
4255         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4256                         "Failed to allocate output buffer in mempool");
4257
4258         /* Clear mbuf payload */
4259         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4260                rte_pktmbuf_tailroom(ut_params->ibuf));
4261
4262         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4263         /*
4264          * Append data which is padded to a
4265          * multiple of the algorithms block size
4266          */
4267         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4268
4269         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4270                                                 plaintext_pad_len);
4271
4272         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4273
4274         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4275         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4276
4277 #ifdef RTE_APP_TEST_DEBUG
4278         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4279 #endif
4280         /* Create SNOW 3G operation */
4281         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4282                                         tdata->cipher_iv.len,
4283                                         tdata->validCipherLenInBits.len,
4284                                         extra_offset);
4285         if (retval < 0)
4286                 return retval;
4287
4288         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4289                                                 ut_params->op);
4290         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4291
4292         ut_params->obuf = ut_params->op->sym->m_dst;
4293         if (ut_params->obuf)
4294                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4295         else
4296                 ciphertext = plaintext;
4297
4298 #ifdef RTE_APP_TEST_DEBUG
4299         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4300 #endif
4301
4302         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4303
4304         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4305                         "failed to reserve memory for ciphertext shifted\n");
4306
4307         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4308                         ceil_byte_length(tdata->ciphertext.len));
4309         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4310                         extra_offset);
4311         /* Validate obuf */
4312         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4313                 ciphertext,
4314                 expected_ciphertext_shifted,
4315                 tdata->validDataLenInBits.len,
4316                 extra_offset,
4317                 "SNOW 3G Ciphertext data not as expected");
4318         return 0;
4319 }
4320
4321 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4322 {
4323         struct crypto_testsuite_params *ts_params = &testsuite_params;
4324         struct crypto_unittest_params *ut_params = &unittest_params;
4325
4326         int retval;
4327
4328         uint8_t *plaintext, *ciphertext;
4329         unsigned ciphertext_pad_len;
4330         unsigned ciphertext_len;
4331
4332         /* Create SNOW 3G session */
4333         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4334                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4335                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4336                                         tdata->key.data, tdata->key.len,
4337                                         tdata->cipher_iv.len);
4338         if (retval < 0)
4339                 return retval;
4340
4341         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4342
4343         /* Clear mbuf payload */
4344         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4345                rte_pktmbuf_tailroom(ut_params->ibuf));
4346
4347         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4348         /* Append data which is padded to a multiple of */
4349         /* the algorithms block size */
4350         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4351         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4352                                 ciphertext_pad_len);
4353         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4354
4355         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4356
4357         /* Create SNOW 3G operation */
4358         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4359                                         tdata->cipher_iv.len,
4360                                         tdata->validCipherLenInBits.len,
4361                                         tdata->cipher.offset_bits);
4362         if (retval < 0)
4363                 return retval;
4364
4365         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4366                                                 ut_params->op);
4367         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4368         ut_params->obuf = ut_params->op->sym->m_dst;
4369         if (ut_params->obuf)
4370                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4371         else
4372                 plaintext = ciphertext;
4373
4374         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4375
4376         /* Validate obuf */
4377         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4378                                 tdata->plaintext.data,
4379                                 tdata->validDataLenInBits.len,
4380                                 "SNOW 3G Plaintext data not as expected");
4381         return 0;
4382 }
4383
4384 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4385 {
4386         struct crypto_testsuite_params *ts_params = &testsuite_params;
4387         struct crypto_unittest_params *ut_params = &unittest_params;
4388
4389         int retval;
4390
4391         uint8_t *plaintext, *ciphertext;
4392         unsigned ciphertext_pad_len;
4393         unsigned ciphertext_len;
4394
4395         /* Create SNOW 3G session */
4396         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4397                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4398                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4399                                         tdata->key.data, tdata->key.len,
4400                                         tdata->cipher_iv.len);
4401         if (retval < 0)
4402                 return retval;
4403
4404         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4405         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4406
4407         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4408                         "Failed to allocate input buffer");
4409         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4410                         "Failed to allocate output buffer");
4411
4412         /* Clear mbuf payload */
4413         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4414                rte_pktmbuf_tailroom(ut_params->ibuf));
4415
4416         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4417                        rte_pktmbuf_tailroom(ut_params->obuf));
4418
4419         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4420         /* Append data which is padded to a multiple of */
4421         /* the algorithms block size */
4422         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4423         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4424                                 ciphertext_pad_len);
4425         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4426         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4427
4428         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4429
4430         /* Create SNOW 3G operation */
4431         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4432                                         tdata->cipher_iv.len,
4433                                         tdata->validCipherLenInBits.len,
4434                                         0);
4435         if (retval < 0)
4436                 return retval;
4437
4438         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4439                                                 ut_params->op);
4440         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4441         ut_params->obuf = ut_params->op->sym->m_dst;
4442         if (ut_params->obuf)
4443                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4444         else
4445                 plaintext = ciphertext;
4446
4447         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4448
4449         /* Validate obuf */
4450         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4451                                 tdata->plaintext.data,
4452                                 tdata->validDataLenInBits.len,
4453                                 "SNOW 3G Plaintext data not as expected");
4454         return 0;
4455 }
4456
4457 static int
4458 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4459 {
4460         struct crypto_testsuite_params *ts_params = &testsuite_params;
4461         struct crypto_unittest_params *ut_params = &unittest_params;
4462
4463         int retval;
4464
4465         uint8_t *plaintext, *ciphertext;
4466         unsigned int plaintext_pad_len;
4467         unsigned int plaintext_len;
4468
4469         struct rte_cryptodev_sym_capability_idx cap_idx;
4470
4471         /* Check if device supports ZUC EEA3 */
4472         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4473         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4474
4475         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4476                         &cap_idx) == NULL)
4477                 return -ENOTSUP;
4478
4479         /* Check if device supports ZUC EIA3 */
4480         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4481         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4482
4483         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4484                         &cap_idx) == NULL)
4485                 return -ENOTSUP;
4486
4487         /* Create ZUC session */
4488         retval = create_zuc_cipher_auth_encrypt_generate_session(
4489                         ts_params->valid_devs[0],
4490                         tdata);
4491         if (retval < 0)
4492                 return retval;
4493         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4494
4495         /* clear mbuf payload */
4496         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4497                         rte_pktmbuf_tailroom(ut_params->ibuf));
4498
4499         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4500         /* Append data which is padded to a multiple of */
4501         /* the algorithms block size */
4502         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4503         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4504                                 plaintext_pad_len);
4505         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4506
4507         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4508
4509         /* Create ZUC operation */
4510         retval = create_zuc_cipher_hash_generate_operation(tdata);
4511         if (retval < 0)
4512                 return retval;
4513
4514         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4515                         ut_params->op);
4516         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4517         ut_params->obuf = ut_params->op->sym->m_src;
4518         if (ut_params->obuf)
4519                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4520         else
4521                 ciphertext = plaintext;
4522
4523         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4524         /* Validate obuf */
4525         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4526                         ciphertext,
4527                         tdata->ciphertext.data,
4528                         tdata->validDataLenInBits.len,
4529                         "ZUC Ciphertext data not as expected");
4530
4531         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4532             + plaintext_pad_len;
4533
4534         /* Validate obuf */
4535         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4536                         ut_params->digest,
4537                         tdata->digest.data,
4538                         4,
4539                         "ZUC Generated auth tag not as expected");
4540         return 0;
4541 }
4542
4543 static int
4544 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4545 {
4546         struct crypto_testsuite_params *ts_params = &testsuite_params;
4547         struct crypto_unittest_params *ut_params = &unittest_params;
4548
4549         int retval;
4550
4551         uint8_t *plaintext, *ciphertext;
4552         unsigned plaintext_pad_len;
4553         unsigned plaintext_len;
4554
4555         /* Create SNOW 3G session */
4556         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4557                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4558                         RTE_CRYPTO_AUTH_OP_GENERATE,
4559                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4560                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4561                         tdata->key.data, tdata->key.len,
4562                         tdata->auth_iv.len, tdata->digest.len,
4563                         tdata->cipher_iv.len);
4564         if (retval < 0)
4565                 return retval;
4566         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4567
4568         /* clear mbuf payload */
4569         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4570                         rte_pktmbuf_tailroom(ut_params->ibuf));
4571
4572         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4573         /* Append data which is padded to a multiple of */
4574         /* the algorithms block size */
4575         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4576         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4577                                 plaintext_pad_len);
4578         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4579
4580         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4581
4582         /* Create SNOW 3G operation */
4583         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4584                         tdata->digest.len, tdata->auth_iv.data,
4585                         tdata->auth_iv.len,
4586                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4587                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4588                         tdata->validCipherLenInBits.len,
4589                         0,
4590                         tdata->validAuthLenInBits.len,
4591                         0
4592                         );
4593         if (retval < 0)
4594                 return retval;
4595
4596         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4597                         ut_params->op);
4598         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4599         ut_params->obuf = ut_params->op->sym->m_src;
4600         if (ut_params->obuf)
4601                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4602         else
4603                 ciphertext = plaintext;
4604
4605         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4606         /* Validate obuf */
4607         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4608                         ciphertext,
4609                         tdata->ciphertext.data,
4610                         tdata->validDataLenInBits.len,
4611                         "SNOW 3G Ciphertext data not as expected");
4612
4613         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4614             + plaintext_pad_len;
4615
4616         /* Validate obuf */
4617         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4618                         ut_params->digest,
4619                         tdata->digest.data,
4620                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4621                         "SNOW 3G Generated auth tag not as expected");
4622         return 0;
4623 }
4624
4625 static int
4626 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4627         uint8_t op_mode, uint8_t verify)
4628 {
4629         struct crypto_testsuite_params *ts_params = &testsuite_params;
4630         struct crypto_unittest_params *ut_params = &unittest_params;
4631
4632         int retval;
4633
4634         uint8_t *plaintext = NULL, *ciphertext = NULL;
4635         unsigned int plaintext_pad_len;
4636         unsigned int plaintext_len;
4637         unsigned int ciphertext_pad_len;
4638         unsigned int ciphertext_len;
4639
4640         struct rte_cryptodev_info dev_info;
4641
4642         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4643
4644         uint64_t feat_flags = dev_info.feature_flags;
4645
4646         if (op_mode == OUT_OF_PLACE) {
4647                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4648                         printf("Device doesn't support digest encrypted.\n");
4649                         return -ENOTSUP;
4650                 }
4651         }
4652
4653         /* Create SNOW 3G session */
4654         retval = create_wireless_algo_auth_cipher_session(
4655                         ts_params->valid_devs[0],
4656                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4657                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4658                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4659                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4660                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4661                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4662                         tdata->key.data, tdata->key.len,
4663                         tdata->auth_iv.len, tdata->digest.len,
4664                         tdata->cipher_iv.len);
4665
4666         if (retval < 0)
4667                 return retval;
4668
4669         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4670         if (op_mode == OUT_OF_PLACE)
4671                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4672
4673         /* clear mbuf payload */
4674         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4675                 rte_pktmbuf_tailroom(ut_params->ibuf));
4676         if (op_mode == OUT_OF_PLACE)
4677                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4678                         rte_pktmbuf_tailroom(ut_params->obuf));
4679
4680         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4681         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4682         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4683         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4684
4685         if (verify) {
4686                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4687                                         ciphertext_pad_len);
4688                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4689                 if (op_mode == OUT_OF_PLACE)
4690                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4691                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4692                         ciphertext_len);
4693         } else {
4694                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4695                                         plaintext_pad_len);
4696                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4697                 if (op_mode == OUT_OF_PLACE)
4698                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4699                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4700         }
4701
4702         /* Create SNOW 3G operation */
4703         retval = create_wireless_algo_auth_cipher_operation(
4704                 tdata->digest.data, tdata->digest.len,
4705                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4706                 tdata->auth_iv.data, tdata->auth_iv.len,
4707                 (tdata->digest.offset_bytes == 0 ?
4708                 (verify ? ciphertext_pad_len : plaintext_pad_len)
4709                         : tdata->digest.offset_bytes),
4710                 tdata->validCipherLenInBits.len,
4711                 tdata->cipher.offset_bits,
4712                 tdata->validAuthLenInBits.len,
4713                 tdata->auth.offset_bits,
4714                 op_mode, 0, verify);
4715
4716         if (retval < 0)
4717                 return retval;
4718
4719         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4720                         ut_params->op);
4721
4722         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4723
4724         ut_params->obuf = (op_mode == IN_PLACE ?
4725                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4726
4727         if (verify) {
4728                 if (ut_params->obuf)
4729                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
4730                                                         uint8_t *);
4731                 else
4732                         plaintext = ciphertext +
4733                                 (tdata->cipher.offset_bits >> 3);
4734
4735                 debug_hexdump(stdout, "plaintext:", plaintext,
4736                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4737                 debug_hexdump(stdout, "plaintext expected:",
4738                         tdata->plaintext.data,
4739                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4740         } else {
4741                 if (ut_params->obuf)
4742                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
4743                                                         uint8_t *);
4744                 else
4745                         ciphertext = plaintext;
4746
4747                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4748                         ciphertext_len);
4749                 debug_hexdump(stdout, "ciphertext expected:",
4750                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4751
4752                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4753                         + (tdata->digest.offset_bytes == 0 ?
4754                 plaintext_pad_len : tdata->digest.offset_bytes);
4755
4756                 debug_hexdump(stdout, "digest:", ut_params->digest,
4757                         tdata->digest.len);
4758                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
4759                                 tdata->digest.len);
4760         }
4761
4762         /* Validate obuf */
4763         if (verify) {
4764                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4765                         plaintext,
4766                         tdata->plaintext.data,
4767                         tdata->plaintext.len >> 3,
4768                         "SNOW 3G Plaintext data not as expected");
4769         } else {
4770                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4771                         ciphertext,
4772                         tdata->ciphertext.data,
4773                         tdata->validDataLenInBits.len,
4774                         "SNOW 3G Ciphertext data not as expected");
4775
4776                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4777                         ut_params->digest,
4778                         tdata->digest.data,
4779                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4780                         "SNOW 3G Generated auth tag not as expected");
4781         }
4782         return 0;
4783 }
4784
4785 static int
4786 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
4787         uint8_t op_mode, uint8_t verify)
4788 {
4789         struct crypto_testsuite_params *ts_params = &testsuite_params;
4790         struct crypto_unittest_params *ut_params = &unittest_params;
4791
4792         int retval;
4793
4794         const uint8_t *plaintext = NULL;
4795         const uint8_t *ciphertext = NULL;
4796         const uint8_t *digest = NULL;
4797         unsigned int plaintext_pad_len;
4798         unsigned int plaintext_len;
4799         unsigned int ciphertext_pad_len;
4800         unsigned int ciphertext_len;
4801         uint8_t buffer[10000];
4802         uint8_t digest_buffer[10000];
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 == IN_PLACE) {
4811                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4812                         printf("Device doesn't support in-place scatter-gather "
4813                                         "in both input and output mbufs.\n");
4814                         return -ENOTSUP;
4815                 }
4816         } else {
4817                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4818                         printf("Device doesn't support out-of-place scatter-gather "
4819                                         "in both input and output mbufs.\n");
4820                         return -ENOTSUP;
4821                 }
4822                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4823                         printf("Device doesn't support digest encrypted.\n");
4824                         return -ENOTSUP;
4825                 }
4826         }
4827
4828         /* Create SNOW 3G session */
4829         retval = create_wireless_algo_auth_cipher_session(
4830                         ts_params->valid_devs[0],
4831                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4832                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4833                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4834                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4835                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4836                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4837                         tdata->key.data, tdata->key.len,
4838                         tdata->auth_iv.len, tdata->digest.len,
4839                         tdata->cipher_iv.len);
4840
4841         if (retval < 0)
4842                 return retval;
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         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4850                         plaintext_pad_len, 15, 0);
4851         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4852                         "Failed to allocate input buffer in mempool");
4853
4854         if (op_mode == OUT_OF_PLACE) {
4855                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4856                                 plaintext_pad_len, 15, 0);
4857                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4858                                 "Failed to allocate output buffer in mempool");
4859         }
4860
4861         if (verify) {
4862                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
4863                         tdata->ciphertext.data);
4864                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4865                                         ciphertext_len, buffer);
4866                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4867                         ciphertext_len);
4868         } else {
4869                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4870                         tdata->plaintext.data);
4871                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4872                                         plaintext_len, buffer);
4873                 debug_hexdump(stdout, "plaintext:", plaintext,
4874                         plaintext_len);
4875         }
4876         memset(buffer, 0, sizeof(buffer));
4877
4878         /* Create SNOW 3G operation */
4879         retval = create_wireless_algo_auth_cipher_operation(
4880                 tdata->digest.data, tdata->digest.len,
4881                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4882                 tdata->auth_iv.data, tdata->auth_iv.len,
4883                 (tdata->digest.offset_bytes == 0 ?
4884                 (verify ? ciphertext_pad_len : plaintext_pad_len)
4885                         : tdata->digest.offset_bytes),
4886                 tdata->validCipherLenInBits.len,
4887                 tdata->cipher.offset_bits,
4888                 tdata->validAuthLenInBits.len,
4889                 tdata->auth.offset_bits,
4890                 op_mode, 1, verify);
4891
4892         if (retval < 0)
4893                 return retval;
4894
4895         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4896                         ut_params->op);
4897
4898         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4899
4900         ut_params->obuf = (op_mode == IN_PLACE ?
4901                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4902
4903         if (verify) {
4904                 if (ut_params->obuf)
4905                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
4906                                         plaintext_len, buffer);
4907                 else
4908                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4909                                         plaintext_len, buffer);
4910
4911                 debug_hexdump(stdout, "plaintext:", plaintext,
4912                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4913                 debug_hexdump(stdout, "plaintext expected:",
4914                         tdata->plaintext.data,
4915                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4916         } else {
4917                 if (ut_params->obuf)
4918                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4919                                         ciphertext_len, buffer);
4920                 else
4921                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4922                                         ciphertext_len, buffer);
4923
4924                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4925                         ciphertext_len);
4926                 debug_hexdump(stdout, "ciphertext expected:",
4927                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4928
4929                 if (ut_params->obuf)
4930                         digest = rte_pktmbuf_read(ut_params->obuf,
4931                                 (tdata->digest.offset_bytes == 0 ?
4932                                 plaintext_pad_len : tdata->digest.offset_bytes),
4933                                 tdata->digest.len, digest_buffer);
4934                 else
4935                         digest = rte_pktmbuf_read(ut_params->ibuf,
4936                                 (tdata->digest.offset_bytes == 0 ?
4937                                 plaintext_pad_len : tdata->digest.offset_bytes),
4938                                 tdata->digest.len, digest_buffer);
4939
4940                 debug_hexdump(stdout, "digest:", digest,
4941                         tdata->digest.len);
4942                 debug_hexdump(stdout, "digest expected:",
4943                         tdata->digest.data, tdata->digest.len);
4944         }
4945
4946         /* Validate obuf */
4947         if (verify) {
4948                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4949                         plaintext,
4950                         tdata->plaintext.data,
4951                         tdata->plaintext.len >> 3,
4952                         "SNOW 3G Plaintext data not as expected");
4953         } else {
4954                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4955                         ciphertext,
4956                         tdata->ciphertext.data,
4957                         tdata->validDataLenInBits.len,
4958                         "SNOW 3G Ciphertext data not as expected");
4959
4960                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4961                         digest,
4962                         tdata->digest.data,
4963                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4964                         "SNOW 3G Generated auth tag not as expected");
4965         }
4966         return 0;
4967 }
4968
4969 static int
4970 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
4971         uint8_t op_mode, uint8_t verify)
4972 {
4973         struct crypto_testsuite_params *ts_params = &testsuite_params;
4974         struct crypto_unittest_params *ut_params = &unittest_params;
4975
4976         int retval;
4977
4978         uint8_t *plaintext = NULL, *ciphertext = NULL;
4979         unsigned int plaintext_pad_len;
4980         unsigned int plaintext_len;
4981         unsigned int ciphertext_pad_len;
4982         unsigned int ciphertext_len;
4983
4984         struct rte_cryptodev_info dev_info;
4985
4986         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4987
4988         uint64_t feat_flags = dev_info.feature_flags;
4989
4990         if (op_mode == OUT_OF_PLACE) {
4991                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4992                         printf("Device doesn't support digest encrypted.\n");
4993                         return -ENOTSUP;
4994                 }
4995         }
4996
4997         /* Create KASUMI session */
4998         retval = create_wireless_algo_auth_cipher_session(
4999                         ts_params->valid_devs[0],
5000                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5001                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5002                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5003                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5004                         RTE_CRYPTO_AUTH_KASUMI_F9,
5005                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5006                         tdata->key.data, tdata->key.len,
5007                         0, tdata->digest.len,
5008                         tdata->cipher_iv.len);
5009
5010         if (retval < 0)
5011                 return retval;
5012
5013         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5014         if (op_mode == OUT_OF_PLACE)
5015                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5016
5017         /* clear mbuf payload */
5018         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5019                 rte_pktmbuf_tailroom(ut_params->ibuf));
5020         if (op_mode == OUT_OF_PLACE)
5021                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5022                         rte_pktmbuf_tailroom(ut_params->obuf));
5023
5024         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5025         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5026         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5027         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5028
5029         if (verify) {
5030                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5031                                         ciphertext_pad_len);
5032                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5033                 if (op_mode == OUT_OF_PLACE)
5034                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5035                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5036                         ciphertext_len);
5037         } else {
5038                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5039                                         plaintext_pad_len);
5040                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5041                 if (op_mode == OUT_OF_PLACE)
5042                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5043                 debug_hexdump(stdout, "plaintext:", plaintext,
5044                         plaintext_len);
5045         }
5046
5047         /* Create KASUMI operation */
5048         retval = create_wireless_algo_auth_cipher_operation(
5049                 tdata->digest.data, tdata->digest.len,
5050                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5051                 NULL, 0,
5052                 (tdata->digest.offset_bytes == 0 ?
5053                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5054                         : tdata->digest.offset_bytes),
5055                 tdata->validCipherLenInBits.len,
5056                 tdata->validCipherOffsetInBits.len,
5057                 tdata->validAuthLenInBits.len,
5058                 0,
5059                 op_mode, 0, verify);
5060
5061         if (retval < 0)
5062                 return retval;
5063
5064         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5065                         ut_params->op);
5066
5067         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5068
5069         ut_params->obuf = (op_mode == IN_PLACE ?
5070                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5071
5072
5073         if (verify) {
5074                 if (ut_params->obuf)
5075                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5076                                                         uint8_t *);
5077                 else
5078                         plaintext = ciphertext;
5079
5080                 debug_hexdump(stdout, "plaintext:", plaintext,
5081                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5082                 debug_hexdump(stdout, "plaintext expected:",
5083                         tdata->plaintext.data,
5084                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5085         } else {
5086                 if (ut_params->obuf)
5087                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5088                                                         uint8_t *);
5089                 else
5090                         ciphertext = plaintext;
5091
5092                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5093                         ciphertext_len);
5094                 debug_hexdump(stdout, "ciphertext expected:",
5095                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5096
5097                 ut_params->digest = rte_pktmbuf_mtod(
5098                         ut_params->obuf, uint8_t *) +
5099                         (tdata->digest.offset_bytes == 0 ?
5100                         plaintext_pad_len : tdata->digest.offset_bytes);
5101
5102                 debug_hexdump(stdout, "digest:", ut_params->digest,
5103                         tdata->digest.len);
5104                 debug_hexdump(stdout, "digest expected:",
5105                         tdata->digest.data, tdata->digest.len);
5106         }
5107
5108         /* Validate obuf */
5109         if (verify) {
5110                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5111                         plaintext,
5112                         tdata->plaintext.data,
5113                         tdata->plaintext.len >> 3,
5114                         "KASUMI Plaintext data not as expected");
5115         } else {
5116                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5117                         ciphertext,
5118                         tdata->ciphertext.data,
5119                         tdata->ciphertext.len >> 3,
5120                         "KASUMI Ciphertext data not as expected");
5121
5122                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5123                         ut_params->digest,
5124                         tdata->digest.data,
5125                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5126                         "KASUMI Generated auth tag not as expected");
5127         }
5128         return 0;
5129 }
5130
5131 static int
5132 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5133         uint8_t op_mode, uint8_t verify)
5134 {
5135         struct crypto_testsuite_params *ts_params = &testsuite_params;
5136         struct crypto_unittest_params *ut_params = &unittest_params;
5137
5138         int retval;
5139
5140         const uint8_t *plaintext = NULL;
5141         const uint8_t *ciphertext = NULL;
5142         const uint8_t *digest = NULL;
5143         unsigned int plaintext_pad_len;
5144         unsigned int plaintext_len;
5145         unsigned int ciphertext_pad_len;
5146         unsigned int ciphertext_len;
5147         uint8_t buffer[10000];
5148         uint8_t digest_buffer[10000];
5149
5150         struct rte_cryptodev_info dev_info;
5151
5152         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5153
5154         uint64_t feat_flags = dev_info.feature_flags;
5155
5156         if (op_mode == IN_PLACE) {
5157                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5158                         printf("Device doesn't support in-place scatter-gather "
5159                                         "in both input and output mbufs.\n");
5160                         return -ENOTSUP;
5161                 }
5162         } else {
5163                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5164                         printf("Device doesn't support out-of-place scatter-gather "
5165                                         "in both input and output mbufs.\n");
5166                         return -ENOTSUP;
5167                 }
5168                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5169                         printf("Device doesn't support digest encrypted.\n");
5170                         return -ENOTSUP;
5171                 }
5172         }
5173
5174         /* Create KASUMI session */
5175         retval = create_wireless_algo_auth_cipher_session(
5176                         ts_params->valid_devs[0],
5177                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5178                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5179                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5180                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5181                         RTE_CRYPTO_AUTH_KASUMI_F9,
5182                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5183                         tdata->key.data, tdata->key.len,
5184                         0, tdata->digest.len,
5185                         tdata->cipher_iv.len);
5186
5187         if (retval < 0)
5188                 return retval;
5189
5190         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5191         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5192         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5193         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5194
5195         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5196                         plaintext_pad_len, 15, 0);
5197         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5198                         "Failed to allocate input buffer in mempool");
5199
5200         if (op_mode == OUT_OF_PLACE) {
5201                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5202                                 plaintext_pad_len, 15, 0);
5203                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5204                                 "Failed to allocate output buffer in mempool");
5205         }
5206
5207         if (verify) {
5208                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5209                         tdata->ciphertext.data);
5210                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5211                                         ciphertext_len, buffer);
5212                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5213                         ciphertext_len);
5214         } else {
5215                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5216                         tdata->plaintext.data);
5217                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5218                                         plaintext_len, buffer);
5219                 debug_hexdump(stdout, "plaintext:", plaintext,
5220                         plaintext_len);
5221         }
5222         memset(buffer, 0, sizeof(buffer));
5223
5224         /* Create KASUMI operation */
5225         retval = create_wireless_algo_auth_cipher_operation(
5226                 tdata->digest.data, tdata->digest.len,
5227                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5228                 NULL, 0,
5229                 (tdata->digest.offset_bytes == 0 ?
5230                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5231                         : tdata->digest.offset_bytes),
5232                 tdata->validCipherLenInBits.len,
5233                 tdata->validCipherOffsetInBits.len,
5234                 tdata->validAuthLenInBits.len,
5235                 0,
5236                 op_mode, 1, verify);
5237
5238         if (retval < 0)
5239                 return retval;
5240
5241         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5242                         ut_params->op);
5243
5244         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5245
5246         ut_params->obuf = (op_mode == IN_PLACE ?
5247                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5248
5249         if (verify) {
5250                 if (ut_params->obuf)
5251                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5252                                         plaintext_len, buffer);
5253                 else
5254                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5255                                         plaintext_len, buffer);
5256
5257                 debug_hexdump(stdout, "plaintext:", plaintext,
5258                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5259                 debug_hexdump(stdout, "plaintext expected:",
5260                         tdata->plaintext.data,
5261                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5262         } else {
5263                 if (ut_params->obuf)
5264                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5265                                         ciphertext_len, buffer);
5266                 else
5267                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5268                                         ciphertext_len, buffer);
5269
5270                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5271                         ciphertext_len);
5272                 debug_hexdump(stdout, "ciphertext expected:",
5273                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5274
5275                 if (ut_params->obuf)
5276                         digest = rte_pktmbuf_read(ut_params->obuf,
5277                                 (tdata->digest.offset_bytes == 0 ?
5278                                 plaintext_pad_len : tdata->digest.offset_bytes),
5279                                 tdata->digest.len, digest_buffer);
5280                 else
5281                         digest = rte_pktmbuf_read(ut_params->ibuf,
5282                                 (tdata->digest.offset_bytes == 0 ?
5283                                 plaintext_pad_len : tdata->digest.offset_bytes),
5284                                 tdata->digest.len, digest_buffer);
5285
5286                 debug_hexdump(stdout, "digest:", digest,
5287                         tdata->digest.len);
5288                 debug_hexdump(stdout, "digest expected:",
5289                         tdata->digest.data, tdata->digest.len);
5290         }
5291
5292         /* Validate obuf */
5293         if (verify) {
5294                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5295                         plaintext,
5296                         tdata->plaintext.data,
5297                         tdata->plaintext.len >> 3,
5298                         "KASUMI Plaintext data not as expected");
5299         } else {
5300                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5301                         ciphertext,
5302                         tdata->ciphertext.data,
5303                         tdata->validDataLenInBits.len,
5304                         "KASUMI Ciphertext data not as expected");
5305
5306                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5307                         digest,
5308                         tdata->digest.data,
5309                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5310                         "KASUMI Generated auth tag not as expected");
5311         }
5312         return 0;
5313 }
5314
5315 static int
5316 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5317 {
5318         struct crypto_testsuite_params *ts_params = &testsuite_params;
5319         struct crypto_unittest_params *ut_params = &unittest_params;
5320
5321         int retval;
5322
5323         uint8_t *plaintext, *ciphertext;
5324         unsigned plaintext_pad_len;
5325         unsigned plaintext_len;
5326
5327         /* Create KASUMI session */
5328         retval = create_wireless_algo_cipher_auth_session(
5329                         ts_params->valid_devs[0],
5330                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5331                         RTE_CRYPTO_AUTH_OP_GENERATE,
5332                         RTE_CRYPTO_AUTH_KASUMI_F9,
5333                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5334                         tdata->key.data, tdata->key.len,
5335                         0, tdata->digest.len,
5336                         tdata->cipher_iv.len);
5337         if (retval < 0)
5338                 return retval;
5339
5340         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5341
5342         /* clear mbuf payload */
5343         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5344                         rte_pktmbuf_tailroom(ut_params->ibuf));
5345
5346         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5347         /* Append data which is padded to a multiple of */
5348         /* the algorithms block size */
5349         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5350         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5351                                 plaintext_pad_len);
5352         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5353
5354         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5355
5356         /* Create KASUMI operation */
5357         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5358                                 tdata->digest.len, NULL, 0,
5359                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5360                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5361                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5362                                 tdata->validCipherOffsetInBits.len,
5363                                 tdata->validAuthLenInBits.len,
5364                                 0
5365                                 );
5366         if (retval < 0)
5367                 return retval;
5368
5369         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5370                         ut_params->op);
5371         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5372
5373         if (ut_params->op->sym->m_dst)
5374                 ut_params->obuf = ut_params->op->sym->m_dst;
5375         else
5376                 ut_params->obuf = ut_params->op->sym->m_src;
5377
5378         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5379                                 tdata->validCipherOffsetInBits.len >> 3);
5380
5381         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5382                         + plaintext_pad_len;
5383
5384         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5385                                 (tdata->validCipherOffsetInBits.len >> 3);
5386         /* Validate obuf */
5387         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5388                 ciphertext,
5389                 reference_ciphertext,
5390                 tdata->validCipherLenInBits.len,
5391                 "KASUMI Ciphertext data not as expected");
5392
5393         /* Validate obuf */
5394         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5395                 ut_params->digest,
5396                 tdata->digest.data,
5397                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5398                 "KASUMI Generated auth tag not as expected");
5399         return 0;
5400 }
5401
5402 static int
5403 test_zuc_encryption(const struct wireless_test_data *tdata)
5404 {
5405         struct crypto_testsuite_params *ts_params = &testsuite_params;
5406         struct crypto_unittest_params *ut_params = &unittest_params;
5407
5408         int retval;
5409         uint8_t *plaintext, *ciphertext;
5410         unsigned plaintext_pad_len;
5411         unsigned plaintext_len;
5412
5413         struct rte_cryptodev_sym_capability_idx cap_idx;
5414
5415         /* Check if device supports ZUC EEA3 */
5416         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5417         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5418
5419         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5420                         &cap_idx) == NULL)
5421                 return -ENOTSUP;
5422
5423         /* Create ZUC session */
5424         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5425                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5426                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5427                                         tdata->key.data, tdata->key.len,
5428                                         tdata->cipher_iv.len);
5429         if (retval < 0)
5430                 return retval;
5431
5432         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5433
5434         /* Clear mbuf payload */
5435         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5436                rte_pktmbuf_tailroom(ut_params->ibuf));
5437
5438         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5439         /* Append data which is padded to a multiple */
5440         /* of the algorithms block size */
5441         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5442         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5443                                 plaintext_pad_len);
5444         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5445
5446         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5447
5448         /* Create ZUC operation */
5449         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5450                                         tdata->cipher_iv.len,
5451                                         tdata->plaintext.len,
5452                                         0);
5453         if (retval < 0)
5454                 return retval;
5455
5456         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5457                                                 ut_params->op);
5458         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5459
5460         ut_params->obuf = ut_params->op->sym->m_dst;
5461         if (ut_params->obuf)
5462                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
5463         else
5464                 ciphertext = plaintext;
5465
5466         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5467
5468         /* Validate obuf */
5469         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5470                 ciphertext,
5471                 tdata->ciphertext.data,
5472                 tdata->validCipherLenInBits.len,
5473                 "ZUC Ciphertext data not as expected");
5474         return 0;
5475 }
5476
5477 static int
5478 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
5479 {
5480         struct crypto_testsuite_params *ts_params = &testsuite_params;
5481         struct crypto_unittest_params *ut_params = &unittest_params;
5482
5483         int retval;
5484
5485         unsigned int plaintext_pad_len;
5486         unsigned int plaintext_len;
5487         const uint8_t *ciphertext;
5488         uint8_t ciphertext_buffer[2048];
5489         struct rte_cryptodev_info dev_info;
5490
5491         struct rte_cryptodev_sym_capability_idx cap_idx;
5492
5493         /* Check if device supports ZUC EEA3 */
5494         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5495         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5496
5497         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5498                         &cap_idx) == NULL)
5499                 return -ENOTSUP;
5500
5501         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5502
5503         uint64_t feat_flags = dev_info.feature_flags;
5504
5505         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5506                 printf("Device doesn't support in-place scatter-gather. "
5507                                 "Test Skipped.\n");
5508                 return -ENOTSUP;
5509         }
5510
5511         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5512
5513         /* Append data which is padded to a multiple */
5514         /* of the algorithms block size */
5515         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5516
5517         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5518                         plaintext_pad_len, 10, 0);
5519
5520         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5521                         tdata->plaintext.data);
5522
5523         /* Create ZUC session */
5524         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5525                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5526                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5527                         tdata->key.data, tdata->key.len,
5528                         tdata->cipher_iv.len);
5529         if (retval < 0)
5530                 return retval;
5531
5532         /* Clear mbuf payload */
5533
5534         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
5535
5536         /* Create ZUC operation */
5537         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5538                         tdata->cipher_iv.len, tdata->plaintext.len,
5539                         0);
5540         if (retval < 0)
5541                 return retval;
5542
5543         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5544                                                 ut_params->op);
5545         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5546
5547         ut_params->obuf = ut_params->op->sym->m_dst;
5548         if (ut_params->obuf)
5549                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
5550                         0, plaintext_len, ciphertext_buffer);
5551         else
5552                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
5553                         0, plaintext_len, ciphertext_buffer);
5554
5555         /* Validate obuf */
5556         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5557
5558         /* Validate obuf */
5559         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5560                 ciphertext,
5561                 tdata->ciphertext.data,
5562                 tdata->validCipherLenInBits.len,
5563                 "ZUC Ciphertext data not as expected");
5564
5565         return 0;
5566 }
5567
5568 static int
5569 test_zuc_authentication(const struct wireless_test_data *tdata)
5570 {
5571         struct crypto_testsuite_params *ts_params = &testsuite_params;
5572         struct crypto_unittest_params *ut_params = &unittest_params;
5573
5574         int retval;
5575         unsigned plaintext_pad_len;
5576         unsigned plaintext_len;
5577         uint8_t *plaintext;
5578
5579         struct rte_cryptodev_sym_capability_idx cap_idx;
5580
5581         /* Check if device supports ZUC EIA3 */
5582         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5583         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5584
5585         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5586                         &cap_idx) == NULL)
5587                 return -ENOTSUP;
5588
5589         /* Create ZUC session */
5590         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
5591                         tdata->key.data, tdata->key.len,
5592                         tdata->auth_iv.len, tdata->digest.len,
5593                         RTE_CRYPTO_AUTH_OP_GENERATE,
5594                         RTE_CRYPTO_AUTH_ZUC_EIA3);
5595         if (retval < 0)
5596                 return retval;
5597
5598         /* alloc mbuf and set payload */
5599         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5600
5601         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5602         rte_pktmbuf_tailroom(ut_params->ibuf));
5603
5604         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5605         /* Append data which is padded to a multiple of */
5606         /* the algorithms block size */
5607         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5608         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5609                                 plaintext_pad_len);
5610         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5611
5612         /* Create ZUC operation */
5613         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
5614                         tdata->auth_iv.data, tdata->auth_iv.len,
5615                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5616                         tdata->validAuthLenInBits.len,
5617                         0);
5618         if (retval < 0)
5619                 return retval;
5620
5621         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5622                                 ut_params->op);
5623         ut_params->obuf = ut_params->op->sym->m_src;
5624         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5625         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5626                         + plaintext_pad_len;
5627
5628         /* Validate obuf */
5629         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5630         ut_params->digest,
5631         tdata->digest.data,
5632         DIGEST_BYTE_LENGTH_KASUMI_F9,
5633         "ZUC Generated auth tag not as expected");
5634
5635         return 0;
5636 }
5637
5638 static int
5639 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
5640         uint8_t op_mode, uint8_t verify)
5641 {
5642         struct crypto_testsuite_params *ts_params = &testsuite_params;
5643         struct crypto_unittest_params *ut_params = &unittest_params;
5644
5645         int retval;
5646
5647         uint8_t *plaintext = NULL, *ciphertext = NULL;
5648         unsigned int plaintext_pad_len;
5649         unsigned int plaintext_len;
5650         unsigned int ciphertext_pad_len;
5651         unsigned int ciphertext_len;
5652
5653         struct rte_cryptodev_info dev_info;
5654         struct rte_cryptodev_sym_capability_idx cap_idx;
5655
5656         /* Check if device supports ZUC EIA3 */
5657         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5658         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5659
5660         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5661                         &cap_idx) == NULL)
5662                 return -ENOTSUP;
5663
5664         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5665
5666         uint64_t feat_flags = dev_info.feature_flags;
5667
5668         if (op_mode == OUT_OF_PLACE) {
5669                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5670                         printf("Device doesn't support digest encrypted.\n");
5671                         return -ENOTSUP;
5672                 }
5673         }
5674
5675         /* Create ZUC session */
5676         retval = create_wireless_algo_auth_cipher_session(
5677                         ts_params->valid_devs[0],
5678                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5679                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5680                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5681                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5682                         RTE_CRYPTO_AUTH_ZUC_EIA3,
5683                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5684                         tdata->key.data, tdata->key.len,
5685                         tdata->auth_iv.len, tdata->digest.len,
5686                         tdata->cipher_iv.len);
5687
5688         if (retval < 0)
5689                 return retval;
5690
5691         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5692         if (op_mode == OUT_OF_PLACE)
5693                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5694
5695         /* clear mbuf payload */
5696         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5697                 rte_pktmbuf_tailroom(ut_params->ibuf));
5698         if (op_mode == OUT_OF_PLACE)
5699                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5700                         rte_pktmbuf_tailroom(ut_params->obuf));
5701
5702         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5703         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5704         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5705         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5706
5707         if (verify) {
5708                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5709                                         ciphertext_pad_len);
5710                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5711                 if (op_mode == OUT_OF_PLACE)
5712                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5713                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5714                         ciphertext_len);
5715         } else {
5716                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5717                                         plaintext_pad_len);
5718                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5719                 if (op_mode == OUT_OF_PLACE)
5720                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5721                 debug_hexdump(stdout, "plaintext:", plaintext,
5722                         plaintext_len);
5723         }
5724
5725         /* Create ZUC operation */
5726         retval = create_wireless_algo_auth_cipher_operation(
5727                 tdata->digest.data, tdata->digest.len,
5728                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5729                 tdata->auth_iv.data, tdata->auth_iv.len,
5730                 (tdata->digest.offset_bytes == 0 ?
5731                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5732                         : tdata->digest.offset_bytes),
5733                 tdata->validCipherLenInBits.len,
5734                 tdata->validCipherOffsetInBits.len,
5735                 tdata->validAuthLenInBits.len,
5736                 0,
5737                 op_mode, 0, verify);
5738
5739         if (retval < 0)
5740                 return retval;
5741
5742         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5743                         ut_params->op);
5744
5745         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5746
5747         ut_params->obuf = (op_mode == IN_PLACE ?
5748                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5749
5750
5751         if (verify) {
5752                 if (ut_params->obuf)
5753                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5754                                                         uint8_t *);
5755                 else
5756                         plaintext = ciphertext;
5757
5758                 debug_hexdump(stdout, "plaintext:", plaintext,
5759                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5760                 debug_hexdump(stdout, "plaintext expected:",
5761                         tdata->plaintext.data,
5762                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5763         } else {
5764                 if (ut_params->obuf)
5765                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5766                                                         uint8_t *);
5767                 else
5768                         ciphertext = plaintext;
5769
5770                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5771                         ciphertext_len);
5772                 debug_hexdump(stdout, "ciphertext expected:",
5773                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5774
5775                 ut_params->digest = rte_pktmbuf_mtod(
5776                         ut_params->obuf, uint8_t *) +
5777                         (tdata->digest.offset_bytes == 0 ?
5778                         plaintext_pad_len : tdata->digest.offset_bytes);
5779
5780                 debug_hexdump(stdout, "digest:", ut_params->digest,
5781                         tdata->digest.len);
5782                 debug_hexdump(stdout, "digest expected:",
5783                         tdata->digest.data, tdata->digest.len);
5784         }
5785
5786         /* Validate obuf */
5787         if (verify) {
5788                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5789                         plaintext,
5790                         tdata->plaintext.data,
5791                         tdata->plaintext.len >> 3,
5792                         "ZUC Plaintext data not as expected");
5793         } else {
5794                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5795                         ciphertext,
5796                         tdata->ciphertext.data,
5797                         tdata->ciphertext.len >> 3,
5798                         "ZUC Ciphertext data not as expected");
5799
5800                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5801                         ut_params->digest,
5802                         tdata->digest.data,
5803                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5804                         "ZUC Generated auth tag not as expected");
5805         }
5806         return 0;
5807 }
5808
5809 static int
5810 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
5811         uint8_t op_mode, uint8_t verify)
5812 {
5813         struct crypto_testsuite_params *ts_params = &testsuite_params;
5814         struct crypto_unittest_params *ut_params = &unittest_params;
5815
5816         int retval;
5817
5818         const uint8_t *plaintext = NULL;
5819         const uint8_t *ciphertext = NULL;
5820         const uint8_t *digest = NULL;
5821         unsigned int plaintext_pad_len;
5822         unsigned int plaintext_len;
5823         unsigned int ciphertext_pad_len;
5824         unsigned int ciphertext_len;
5825         uint8_t buffer[10000];
5826         uint8_t digest_buffer[10000];
5827
5828         struct rte_cryptodev_info dev_info;
5829         struct rte_cryptodev_sym_capability_idx cap_idx;
5830
5831         /* Check if device supports ZUC EIA3 */
5832         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5833         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5834
5835         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5836                         &cap_idx) == NULL)
5837                 return -ENOTSUP;
5838
5839         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5840
5841         uint64_t feat_flags = dev_info.feature_flags;
5842
5843         if (op_mode == IN_PLACE) {
5844                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5845                         printf("Device doesn't support in-place scatter-gather "
5846                                         "in both input and output mbufs.\n");
5847                         return -ENOTSUP;
5848                 }
5849         } else {
5850                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5851                         printf("Device doesn't support out-of-place scatter-gather "
5852                                         "in both input and output mbufs.\n");
5853                         return -ENOTSUP;
5854                 }
5855                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5856                         printf("Device doesn't support digest encrypted.\n");
5857                         return -ENOTSUP;
5858                 }
5859         }
5860
5861         /* Create ZUC session */
5862         retval = create_wireless_algo_auth_cipher_session(
5863                         ts_params->valid_devs[0],
5864                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5865                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5866                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5867                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5868                         RTE_CRYPTO_AUTH_ZUC_EIA3,
5869                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5870                         tdata->key.data, tdata->key.len,
5871                         tdata->auth_iv.len, tdata->digest.len,
5872                         tdata->cipher_iv.len);
5873
5874         if (retval < 0)
5875                 return retval;
5876
5877         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5878         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5879         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5880         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5881
5882         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5883                         plaintext_pad_len, 15, 0);
5884         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5885                         "Failed to allocate input buffer in mempool");
5886
5887         if (op_mode == OUT_OF_PLACE) {
5888                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5889                                 plaintext_pad_len, 15, 0);
5890                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5891                                 "Failed to allocate output buffer in mempool");
5892         }
5893
5894         if (verify) {
5895                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5896                         tdata->ciphertext.data);
5897                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5898                                         ciphertext_len, buffer);
5899                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5900                         ciphertext_len);
5901         } else {
5902                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5903                         tdata->plaintext.data);
5904                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5905                                         plaintext_len, buffer);
5906                 debug_hexdump(stdout, "plaintext:", plaintext,
5907                         plaintext_len);
5908         }
5909         memset(buffer, 0, sizeof(buffer));
5910
5911         /* Create ZUC operation */
5912         retval = create_wireless_algo_auth_cipher_operation(
5913                 tdata->digest.data, tdata->digest.len,
5914                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5915                 NULL, 0,
5916                 (tdata->digest.offset_bytes == 0 ?
5917                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5918                         : tdata->digest.offset_bytes),
5919                 tdata->validCipherLenInBits.len,
5920                 tdata->validCipherOffsetInBits.len,
5921                 tdata->validAuthLenInBits.len,
5922                 0,
5923                 op_mode, 1, verify);
5924
5925         if (retval < 0)
5926                 return retval;
5927
5928         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5929                         ut_params->op);
5930
5931         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5932
5933         ut_params->obuf = (op_mode == IN_PLACE ?
5934                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5935
5936         if (verify) {
5937                 if (ut_params->obuf)
5938                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5939                                         plaintext_len, buffer);
5940                 else
5941                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5942                                         plaintext_len, buffer);
5943
5944                 debug_hexdump(stdout, "plaintext:", plaintext,
5945                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5946                 debug_hexdump(stdout, "plaintext expected:",
5947                         tdata->plaintext.data,
5948                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5949         } else {
5950                 if (ut_params->obuf)
5951                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5952                                         ciphertext_len, buffer);
5953                 else
5954                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5955                                         ciphertext_len, buffer);
5956
5957                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5958                         ciphertext_len);
5959                 debug_hexdump(stdout, "ciphertext expected:",
5960                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5961
5962                 if (ut_params->obuf)
5963                         digest = rte_pktmbuf_read(ut_params->obuf,
5964                                 (tdata->digest.offset_bytes == 0 ?
5965                                 plaintext_pad_len : tdata->digest.offset_bytes),
5966                                 tdata->digest.len, digest_buffer);
5967                 else
5968                         digest = rte_pktmbuf_read(ut_params->ibuf,
5969                                 (tdata->digest.offset_bytes == 0 ?
5970                                 plaintext_pad_len : tdata->digest.offset_bytes),
5971                                 tdata->digest.len, digest_buffer);
5972
5973                 debug_hexdump(stdout, "digest:", digest,
5974                         tdata->digest.len);
5975                 debug_hexdump(stdout, "digest expected:",
5976                         tdata->digest.data, tdata->digest.len);
5977         }
5978
5979         /* Validate obuf */
5980         if (verify) {
5981                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5982                         plaintext,
5983                         tdata->plaintext.data,
5984                         tdata->plaintext.len >> 3,
5985                         "ZUC Plaintext data not as expected");
5986         } else {
5987                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5988                         ciphertext,
5989                         tdata->ciphertext.data,
5990                         tdata->validDataLenInBits.len,
5991                         "ZUC Ciphertext data not as expected");
5992
5993                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5994                         digest,
5995                         tdata->digest.data,
5996                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5997                         "ZUC Generated auth tag not as expected");
5998         }
5999         return 0;
6000 }
6001
6002 static int
6003 test_kasumi_encryption_test_case_1(void)
6004 {
6005         return test_kasumi_encryption(&kasumi_test_case_1);
6006 }
6007
6008 static int
6009 test_kasumi_encryption_test_case_1_sgl(void)
6010 {
6011         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6012 }
6013
6014 static int
6015 test_kasumi_encryption_test_case_1_oop(void)
6016 {
6017         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6018 }
6019
6020 static int
6021 test_kasumi_encryption_test_case_1_oop_sgl(void)
6022 {
6023         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6024 }
6025
6026 static int
6027 test_kasumi_encryption_test_case_2(void)
6028 {
6029         return test_kasumi_encryption(&kasumi_test_case_2);
6030 }
6031
6032 static int
6033 test_kasumi_encryption_test_case_3(void)
6034 {
6035         return test_kasumi_encryption(&kasumi_test_case_3);
6036 }
6037
6038 static int
6039 test_kasumi_encryption_test_case_4(void)
6040 {
6041         return test_kasumi_encryption(&kasumi_test_case_4);
6042 }
6043
6044 static int
6045 test_kasumi_encryption_test_case_5(void)
6046 {
6047         return test_kasumi_encryption(&kasumi_test_case_5);
6048 }
6049
6050 static int
6051 test_kasumi_decryption_test_case_1(void)
6052 {
6053         return test_kasumi_decryption(&kasumi_test_case_1);
6054 }
6055
6056 static int
6057 test_kasumi_decryption_test_case_1_oop(void)
6058 {
6059         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6060 }
6061
6062 static int
6063 test_kasumi_decryption_test_case_2(void)
6064 {
6065         return test_kasumi_decryption(&kasumi_test_case_2);
6066 }
6067
6068 static int
6069 test_kasumi_decryption_test_case_3(void)
6070 {
6071         return test_kasumi_decryption(&kasumi_test_case_3);
6072 }
6073
6074 static int
6075 test_kasumi_decryption_test_case_4(void)
6076 {
6077         return test_kasumi_decryption(&kasumi_test_case_4);
6078 }
6079
6080 static int
6081 test_kasumi_decryption_test_case_5(void)
6082 {
6083         return test_kasumi_decryption(&kasumi_test_case_5);
6084 }
6085 static int
6086 test_snow3g_encryption_test_case_1(void)
6087 {
6088         return test_snow3g_encryption(&snow3g_test_case_1);
6089 }
6090
6091 static int
6092 test_snow3g_encryption_test_case_1_oop(void)
6093 {
6094         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6095 }
6096
6097 static int
6098 test_snow3g_encryption_test_case_1_oop_sgl(void)
6099 {
6100         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6101 }
6102
6103
6104 static int
6105 test_snow3g_encryption_test_case_1_offset_oop(void)
6106 {
6107         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6108 }
6109
6110 static int
6111 test_snow3g_encryption_test_case_2(void)
6112 {
6113         return test_snow3g_encryption(&snow3g_test_case_2);
6114 }
6115
6116 static int
6117 test_snow3g_encryption_test_case_3(void)
6118 {
6119         return test_snow3g_encryption(&snow3g_test_case_3);
6120 }
6121
6122 static int
6123 test_snow3g_encryption_test_case_4(void)
6124 {
6125         return test_snow3g_encryption(&snow3g_test_case_4);
6126 }
6127
6128 static int
6129 test_snow3g_encryption_test_case_5(void)
6130 {
6131         return test_snow3g_encryption(&snow3g_test_case_5);
6132 }
6133
6134 static int
6135 test_snow3g_decryption_test_case_1(void)
6136 {
6137         return test_snow3g_decryption(&snow3g_test_case_1);
6138 }
6139
6140 static int
6141 test_snow3g_decryption_test_case_1_oop(void)
6142 {
6143         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6144 }
6145
6146 static int
6147 test_snow3g_decryption_test_case_2(void)
6148 {
6149         return test_snow3g_decryption(&snow3g_test_case_2);
6150 }
6151
6152 static int
6153 test_snow3g_decryption_test_case_3(void)
6154 {
6155         return test_snow3g_decryption(&snow3g_test_case_3);
6156 }
6157
6158 static int
6159 test_snow3g_decryption_test_case_4(void)
6160 {
6161         return test_snow3g_decryption(&snow3g_test_case_4);
6162 }
6163
6164 static int
6165 test_snow3g_decryption_test_case_5(void)
6166 {
6167         return test_snow3g_decryption(&snow3g_test_case_5);
6168 }
6169
6170 /*
6171  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6172  * Pattern digest from snow3g_test_data must be allocated as
6173  * 4 last bytes in plaintext.
6174  */
6175 static void
6176 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6177                 struct snow3g_hash_test_data *output)
6178 {
6179         if ((pattern != NULL) && (output != NULL)) {
6180                 output->key.len = pattern->key.len;
6181
6182                 memcpy(output->key.data,
6183                 pattern->key.data, pattern->key.len);
6184
6185                 output->auth_iv.len = pattern->auth_iv.len;
6186
6187                 memcpy(output->auth_iv.data,
6188                 pattern->auth_iv.data, pattern->auth_iv.len);
6189
6190                 output->plaintext.len = pattern->plaintext.len;
6191
6192                 memcpy(output->plaintext.data,
6193                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6194
6195                 output->digest.len = pattern->digest.len;
6196
6197                 memcpy(output->digest.data,
6198                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6199                 pattern->digest.len);
6200
6201                 output->validAuthLenInBits.len =
6202                 pattern->validAuthLenInBits.len;
6203         }
6204 }
6205
6206 /*
6207  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6208  */
6209 static int
6210 test_snow3g_decryption_with_digest_test_case_1(void)
6211 {
6212         struct snow3g_hash_test_data snow3g_hash_data;
6213
6214         /*
6215          * Function prepare data for hash veryfication test case.
6216          * Digest is allocated in 4 last bytes in plaintext, pattern.
6217          */
6218         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6219
6220         return test_snow3g_decryption(&snow3g_test_case_7) &
6221                         test_snow3g_authentication_verify(&snow3g_hash_data);
6222 }
6223
6224 static int
6225 test_snow3g_cipher_auth_test_case_1(void)
6226 {
6227         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6228 }
6229
6230 static int
6231 test_snow3g_auth_cipher_test_case_1(void)
6232 {
6233         return test_snow3g_auth_cipher(
6234                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6235 }
6236
6237 static int
6238 test_snow3g_auth_cipher_test_case_2(void)
6239 {
6240         return test_snow3g_auth_cipher(
6241                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6242 }
6243
6244 static int
6245 test_snow3g_auth_cipher_test_case_2_oop(void)
6246 {
6247         return test_snow3g_auth_cipher(
6248                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6249 }
6250
6251 static int
6252 test_snow3g_auth_cipher_part_digest_enc(void)
6253 {
6254         return test_snow3g_auth_cipher(
6255                 &snow3g_auth_cipher_partial_digest_encryption,
6256                         IN_PLACE, 0);
6257 }
6258
6259 static int
6260 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6261 {
6262         return test_snow3g_auth_cipher(
6263                 &snow3g_auth_cipher_partial_digest_encryption,
6264                         OUT_OF_PLACE, 0);
6265 }
6266
6267 static int
6268 test_snow3g_auth_cipher_test_case_3_sgl(void)
6269 {
6270         return test_snow3g_auth_cipher_sgl(
6271                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6272 }
6273
6274 static int
6275 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6276 {
6277         return test_snow3g_auth_cipher_sgl(
6278                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6279 }
6280
6281 static int
6282 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6283 {
6284         return test_snow3g_auth_cipher_sgl(
6285                 &snow3g_auth_cipher_partial_digest_encryption,
6286                         IN_PLACE, 0);
6287 }
6288
6289 static int
6290 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6291 {
6292         return test_snow3g_auth_cipher_sgl(
6293                 &snow3g_auth_cipher_partial_digest_encryption,
6294                         OUT_OF_PLACE, 0);
6295 }
6296
6297 static int
6298 test_snow3g_auth_cipher_verify_test_case_1(void)
6299 {
6300         return test_snow3g_auth_cipher(
6301                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6302 }
6303
6304 static int
6305 test_snow3g_auth_cipher_verify_test_case_2(void)
6306 {
6307         return test_snow3g_auth_cipher(
6308                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6309 }
6310
6311 static int
6312 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6313 {
6314         return test_snow3g_auth_cipher(
6315                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6316 }
6317
6318 static int
6319 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6320 {
6321         return test_snow3g_auth_cipher(
6322                 &snow3g_auth_cipher_partial_digest_encryption,
6323                         IN_PLACE, 1);
6324 }
6325
6326 static int
6327 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6328 {
6329         return test_snow3g_auth_cipher(
6330                 &snow3g_auth_cipher_partial_digest_encryption,
6331                         OUT_OF_PLACE, 1);
6332 }
6333
6334 static int
6335 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
6336 {
6337         return test_snow3g_auth_cipher_sgl(
6338                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
6339 }
6340
6341 static int
6342 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
6343 {
6344         return test_snow3g_auth_cipher_sgl(
6345                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
6346 }
6347
6348 static int
6349 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
6350 {
6351         return test_snow3g_auth_cipher_sgl(
6352                 &snow3g_auth_cipher_partial_digest_encryption,
6353                         IN_PLACE, 1);
6354 }
6355
6356 static int
6357 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
6358 {
6359         return test_snow3g_auth_cipher_sgl(
6360                 &snow3g_auth_cipher_partial_digest_encryption,
6361                         OUT_OF_PLACE, 1);
6362 }
6363
6364 static int
6365 test_snow3g_auth_cipher_with_digest_test_case_1(void)
6366 {
6367         return test_snow3g_auth_cipher(
6368                 &snow3g_test_case_7, IN_PLACE, 0);
6369 }
6370
6371 static int
6372 test_kasumi_auth_cipher_test_case_1(void)
6373 {
6374         return test_kasumi_auth_cipher(
6375                 &kasumi_test_case_3, IN_PLACE, 0);
6376 }
6377
6378 static int
6379 test_kasumi_auth_cipher_test_case_2(void)
6380 {
6381         return test_kasumi_auth_cipher(
6382                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6383 }
6384
6385 static int
6386 test_kasumi_auth_cipher_test_case_2_oop(void)
6387 {
6388         return test_kasumi_auth_cipher(
6389                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6390 }
6391
6392 static int
6393 test_kasumi_auth_cipher_test_case_2_sgl(void)
6394 {
6395         return test_kasumi_auth_cipher_sgl(
6396                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6397 }
6398
6399 static int
6400 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
6401 {
6402         return test_kasumi_auth_cipher_sgl(
6403                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6404 }
6405
6406 static int
6407 test_kasumi_auth_cipher_verify_test_case_1(void)
6408 {
6409         return test_kasumi_auth_cipher(
6410                 &kasumi_test_case_3, IN_PLACE, 1);
6411 }
6412
6413 static int
6414 test_kasumi_auth_cipher_verify_test_case_2(void)
6415 {
6416         return test_kasumi_auth_cipher(
6417                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6418 }
6419
6420 static int
6421 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
6422 {
6423         return test_kasumi_auth_cipher(
6424                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6425 }
6426
6427 static int
6428 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
6429 {
6430         return test_kasumi_auth_cipher_sgl(
6431                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6432 }
6433
6434 static int
6435 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
6436 {
6437         return test_kasumi_auth_cipher_sgl(
6438                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6439 }
6440
6441 static int
6442 test_kasumi_cipher_auth_test_case_1(void)
6443 {
6444         return test_kasumi_cipher_auth(&kasumi_test_case_6);
6445 }
6446
6447 static int
6448 test_zuc_encryption_test_case_1(void)
6449 {
6450         return test_zuc_encryption(&zuc_test_case_cipher_193b);
6451 }
6452
6453 static int
6454 test_zuc_encryption_test_case_2(void)
6455 {
6456         return test_zuc_encryption(&zuc_test_case_cipher_800b);
6457 }
6458
6459 static int
6460 test_zuc_encryption_test_case_3(void)
6461 {
6462         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
6463 }
6464
6465 static int
6466 test_zuc_encryption_test_case_4(void)
6467 {
6468         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
6469 }
6470
6471 static int
6472 test_zuc_encryption_test_case_5(void)
6473 {
6474         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
6475 }
6476
6477 static int
6478 test_zuc_encryption_test_case_6_sgl(void)
6479 {
6480         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
6481 }
6482
6483 static int
6484 test_zuc_hash_generate_test_case_1(void)
6485 {
6486         return test_zuc_authentication(&zuc_test_case_auth_1b);
6487 }
6488
6489 static int
6490 test_zuc_hash_generate_test_case_2(void)
6491 {
6492         return test_zuc_authentication(&zuc_test_case_auth_90b);
6493 }
6494
6495 static int
6496 test_zuc_hash_generate_test_case_3(void)
6497 {
6498         return test_zuc_authentication(&zuc_test_case_auth_577b);
6499 }
6500
6501 static int
6502 test_zuc_hash_generate_test_case_4(void)
6503 {
6504         return test_zuc_authentication(&zuc_test_case_auth_2079b);
6505 }
6506
6507 static int
6508 test_zuc_hash_generate_test_case_5(void)
6509 {
6510         return test_zuc_authentication(&zuc_test_auth_5670b);
6511 }
6512
6513 static int
6514 test_zuc_hash_generate_test_case_6(void)
6515 {
6516         return test_zuc_authentication(&zuc_test_case_auth_128b);
6517 }
6518
6519 static int
6520 test_zuc_hash_generate_test_case_7(void)
6521 {
6522         return test_zuc_authentication(&zuc_test_case_auth_2080b);
6523 }
6524
6525 static int
6526 test_zuc_hash_generate_test_case_8(void)
6527 {
6528         return test_zuc_authentication(&zuc_test_case_auth_584b);
6529 }
6530
6531 static int
6532 test_zuc_cipher_auth_test_case_1(void)
6533 {
6534         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
6535 }
6536
6537 static int
6538 test_zuc_cipher_auth_test_case_2(void)
6539 {
6540         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
6541 }
6542
6543 static int
6544 test_zuc_auth_cipher_test_case_1(void)
6545 {
6546         return test_zuc_auth_cipher(
6547                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6548 }
6549
6550 static int
6551 test_zuc_auth_cipher_test_case_1_oop(void)
6552 {
6553         return test_zuc_auth_cipher(
6554                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6555 }
6556
6557 static int
6558 test_zuc_auth_cipher_test_case_1_sgl(void)
6559 {
6560         return test_zuc_auth_cipher_sgl(
6561                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6562 }
6563
6564 static int
6565 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
6566 {
6567         return test_zuc_auth_cipher_sgl(
6568                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6569 }
6570
6571 static int
6572 test_zuc_auth_cipher_verify_test_case_1(void)
6573 {
6574         return test_zuc_auth_cipher(
6575                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6576 }
6577
6578 static int
6579 test_zuc_auth_cipher_verify_test_case_1_oop(void)
6580 {
6581         return test_zuc_auth_cipher(
6582                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6583 }
6584
6585 static int
6586 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
6587 {
6588         return test_zuc_auth_cipher_sgl(
6589                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6590 }
6591
6592 static int
6593 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
6594 {
6595         return test_zuc_auth_cipher_sgl(
6596                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6597 }
6598
6599 static int
6600 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
6601 {
6602         uint8_t dev_id = testsuite_params.valid_devs[0];
6603
6604         struct rte_cryptodev_sym_capability_idx cap_idx;
6605
6606         /* Check if device supports particular cipher algorithm */
6607         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6608         cap_idx.algo.cipher = tdata->cipher_algo;
6609         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6610                 return -ENOTSUP;
6611
6612         /* Check if device supports particular hash algorithm */
6613         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6614         cap_idx.algo.auth = tdata->auth_algo;
6615         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6616                 return -ENOTSUP;
6617
6618         return 0;
6619 }
6620
6621 static int
6622 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
6623         uint8_t op_mode, uint8_t verify)
6624 {
6625         struct crypto_testsuite_params *ts_params = &testsuite_params;
6626         struct crypto_unittest_params *ut_params = &unittest_params;
6627
6628         int retval;
6629
6630         uint8_t *plaintext = NULL, *ciphertext = NULL;
6631         unsigned int plaintext_pad_len;
6632         unsigned int plaintext_len;
6633         unsigned int ciphertext_pad_len;
6634         unsigned int ciphertext_len;
6635
6636         struct rte_cryptodev_info dev_info;
6637         struct rte_crypto_op *op;
6638
6639         /* Check if device supports particular algorithms separately */
6640         if (test_mixed_check_if_unsupported(tdata))
6641                 return -ENOTSUP;
6642
6643         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6644
6645         uint64_t feat_flags = dev_info.feature_flags;
6646
6647         if (op_mode == OUT_OF_PLACE) {
6648                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6649                         printf("Device doesn't support digest encrypted.\n");
6650                         return -ENOTSUP;
6651                 }
6652         }
6653
6654         /* Create the session */
6655         if (verify)
6656                 retval = create_wireless_algo_cipher_auth_session(
6657                                 ts_params->valid_devs[0],
6658                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6659                                 RTE_CRYPTO_AUTH_OP_VERIFY,
6660                                 tdata->auth_algo,
6661                                 tdata->cipher_algo,
6662                                 tdata->auth_key.data, tdata->auth_key.len,
6663                                 tdata->auth_iv.len, tdata->digest_enc.len,
6664                                 tdata->cipher_iv.len);
6665         else
6666                 retval = create_wireless_algo_auth_cipher_session(
6667                                 ts_params->valid_devs[0],
6668                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6669                                 RTE_CRYPTO_AUTH_OP_GENERATE,
6670                                 tdata->auth_algo,
6671                                 tdata->cipher_algo,
6672                                 tdata->auth_key.data, tdata->auth_key.len,
6673                                 tdata->auth_iv.len, tdata->digest_enc.len,
6674                                 tdata->cipher_iv.len);
6675         if (retval < 0)
6676                 return retval;
6677
6678         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6679         if (op_mode == OUT_OF_PLACE)
6680                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6681
6682         /* clear mbuf payload */
6683         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6684                 rte_pktmbuf_tailroom(ut_params->ibuf));
6685         if (op_mode == OUT_OF_PLACE)
6686                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6687                                 rte_pktmbuf_tailroom(ut_params->obuf));
6688
6689         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
6690         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
6691         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6692         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6693
6694         if (verify) {
6695                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6696                                 ciphertext_pad_len);
6697                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6698                 if (op_mode == OUT_OF_PLACE)
6699                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6700                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6701                                 ciphertext_len);
6702         } else {
6703                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6704                                 plaintext_pad_len);
6705                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6706                 if (op_mode == OUT_OF_PLACE)
6707                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6708                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6709         }
6710
6711         /* Create the operation */
6712         retval = create_wireless_algo_auth_cipher_operation(
6713                         tdata->digest_enc.data, tdata->digest_enc.len,
6714                         tdata->cipher_iv.data, tdata->cipher_iv.len,
6715                         tdata->auth_iv.data, tdata->auth_iv.len,
6716                         (tdata->digest_enc.offset == 0 ?
6717                                 plaintext_pad_len
6718                                 : tdata->digest_enc.offset),
6719                         tdata->validCipherLen.len_bits,
6720                         tdata->cipher.offset_bits,
6721                         tdata->validAuthLen.len_bits,
6722                         tdata->auth.offset_bits,
6723                         op_mode, 0, verify);
6724
6725         if (retval < 0)
6726                 return retval;
6727
6728         op = process_crypto_request(ts_params->valid_devs[0],
6729                         ut_params->op);
6730
6731         /* Check if the op failed because the device doesn't */
6732         /* support this particular combination of algorithms */
6733         if (op == NULL && ut_params->op->status ==
6734                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
6735                 printf("Device doesn't support this mixed combination. "
6736                                 "Test Skipped.\n");
6737                 return -ENOTSUP;
6738         }
6739         ut_params->op = op;
6740
6741         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6742
6743         ut_params->obuf = (op_mode == IN_PLACE ?
6744                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6745
6746         if (verify) {
6747                 if (ut_params->obuf)
6748                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6749                                                         uint8_t *);
6750                 else
6751                         plaintext = ciphertext +
6752                                         (tdata->cipher.offset_bits >> 3);
6753
6754                 debug_hexdump(stdout, "plaintext:", plaintext,
6755                                 tdata->plaintext.len_bits >> 3);
6756                 debug_hexdump(stdout, "plaintext expected:",
6757                                 tdata->plaintext.data,
6758                                 tdata->plaintext.len_bits >> 3);
6759         } else {
6760                 if (ut_params->obuf)
6761                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6762                                         uint8_t *);
6763                 else
6764                         ciphertext = plaintext;
6765
6766                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6767                                 ciphertext_len);
6768                 debug_hexdump(stdout, "ciphertext expected:",
6769                                 tdata->ciphertext.data,
6770                                 tdata->ciphertext.len_bits >> 3);
6771
6772                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6773                                 + (tdata->digest_enc.offset == 0 ?
6774                 plaintext_pad_len : tdata->digest_enc.offset);
6775
6776                 debug_hexdump(stdout, "digest:", ut_params->digest,
6777                                 tdata->digest_enc.len);
6778                 debug_hexdump(stdout, "digest expected:",
6779                                 tdata->digest_enc.data,
6780                                 tdata->digest_enc.len);
6781         }
6782
6783         /* Validate obuf */
6784         if (verify) {
6785                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6786                                 plaintext,
6787                                 tdata->plaintext.data,
6788                                 tdata->plaintext.len_bits >> 3,
6789                                 "Plaintext data not as expected");
6790         } else {
6791                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6792                                 ciphertext,
6793                                 tdata->ciphertext.data,
6794                                 tdata->validDataLen.len_bits,
6795                                 "Ciphertext data not as expected");
6796
6797                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6798                                 ut_params->digest,
6799                                 tdata->digest_enc.data,
6800                                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
6801                                 "Generated auth tag not as expected");
6802         }
6803
6804         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6805                         "crypto op processing failed");
6806
6807         return 0;
6808 }
6809
6810 static int
6811 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
6812         uint8_t op_mode, uint8_t verify)
6813 {
6814         struct crypto_testsuite_params *ts_params = &testsuite_params;
6815         struct crypto_unittest_params *ut_params = &unittest_params;
6816
6817         int retval;
6818
6819         const uint8_t *plaintext = NULL;
6820         const uint8_t *ciphertext = NULL;
6821         const uint8_t *digest = NULL;
6822         unsigned int plaintext_pad_len;
6823         unsigned int plaintext_len;
6824         unsigned int ciphertext_pad_len;
6825         unsigned int ciphertext_len;
6826         uint8_t buffer[10000];
6827         uint8_t digest_buffer[10000];
6828
6829         struct rte_cryptodev_info dev_info;
6830         struct rte_crypto_op *op;
6831
6832         /* Check if device supports particular algorithms */
6833         if (test_mixed_check_if_unsupported(tdata))
6834                 return -ENOTSUP;
6835
6836         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6837
6838         uint64_t feat_flags = dev_info.feature_flags;
6839
6840         if (op_mode == IN_PLACE) {
6841                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6842                         printf("Device doesn't support in-place scatter-gather "
6843                                         "in both input and output mbufs.\n");
6844                         return -ENOTSUP;
6845                 }
6846         } else {
6847                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6848                         printf("Device doesn't support out-of-place scatter-gather "
6849                                         "in both input and output mbufs.\n");
6850                         return -ENOTSUP;
6851                 }
6852                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6853                         printf("Device doesn't support digest encrypted.\n");
6854                         return -ENOTSUP;
6855                 }
6856         }
6857
6858         /* Create the session */
6859         if (verify)
6860                 retval = create_wireless_algo_cipher_auth_session(
6861                                 ts_params->valid_devs[0],
6862                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6863                                 RTE_CRYPTO_AUTH_OP_VERIFY,
6864                                 tdata->auth_algo,
6865                                 tdata->cipher_algo,
6866                                 tdata->auth_key.data, tdata->auth_key.len,
6867                                 tdata->auth_iv.len, tdata->digest_enc.len,
6868                                 tdata->cipher_iv.len);
6869         else
6870                 retval = create_wireless_algo_auth_cipher_session(
6871                                 ts_params->valid_devs[0],
6872                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6873                                 RTE_CRYPTO_AUTH_OP_GENERATE,
6874                                 tdata->auth_algo,
6875                                 tdata->cipher_algo,
6876                                 tdata->auth_key.data, tdata->auth_key.len,
6877                                 tdata->auth_iv.len, tdata->digest_enc.len,
6878                                 tdata->cipher_iv.len);
6879         if (retval < 0)
6880                 return retval;
6881
6882         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
6883         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
6884         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6885         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6886
6887         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6888                         ciphertext_pad_len, 15, 0);
6889         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6890                         "Failed to allocate input buffer in mempool");
6891
6892         if (op_mode == OUT_OF_PLACE) {
6893                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6894                                 plaintext_pad_len, 15, 0);
6895                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6896                                 "Failed to allocate output buffer in mempool");
6897         }
6898
6899         if (verify) {
6900                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6901                         tdata->ciphertext.data);
6902                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6903                                         ciphertext_len, buffer);
6904                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6905                         ciphertext_len);
6906         } else {
6907                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6908                         tdata->plaintext.data);
6909                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6910                                         plaintext_len, buffer);
6911                 debug_hexdump(stdout, "plaintext:", plaintext,
6912                         plaintext_len);
6913         }
6914         memset(buffer, 0, sizeof(buffer));
6915
6916         /* Create the operation */
6917         retval = create_wireless_algo_auth_cipher_operation(
6918                         tdata->digest_enc.data, tdata->digest_enc.len,
6919                         tdata->cipher_iv.data, tdata->cipher_iv.len,
6920                         tdata->auth_iv.data, tdata->auth_iv.len,
6921                         (tdata->digest_enc.offset == 0 ?
6922                                 plaintext_pad_len
6923                                 : tdata->digest_enc.offset),
6924                         tdata->validCipherLen.len_bits,
6925                         tdata->cipher.offset_bits,
6926                         tdata->validAuthLen.len_bits,
6927                         tdata->auth.offset_bits,
6928                         op_mode, 1, verify);
6929
6930         if (retval < 0)
6931                 return retval;
6932
6933         op = process_crypto_request(ts_params->valid_devs[0],
6934                         ut_params->op);
6935
6936         /* Check if the op failed because the device doesn't */
6937         /* support this particular combination of algorithms */
6938         if (op == NULL && ut_params->op->status ==
6939                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
6940                 printf("Device doesn't support this mixed combination. "
6941                                 "Test Skipped.\n");
6942                 return -ENOTSUP;
6943         }
6944
6945         ut_params->op = op;
6946
6947         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6948
6949         ut_params->obuf = (op_mode == IN_PLACE ?
6950                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6951
6952         if (verify) {
6953                 if (ut_params->obuf)
6954                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6955                                         plaintext_len, buffer);
6956                 else
6957                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6958                                         plaintext_len, buffer);
6959
6960                 debug_hexdump(stdout, "plaintext:", plaintext,
6961                                 (tdata->plaintext.len_bits >> 3) -
6962                                 tdata->digest_enc.len);
6963                 debug_hexdump(stdout, "plaintext expected:",
6964                                 tdata->plaintext.data,
6965                                 (tdata->plaintext.len_bits >> 3) -
6966                                 tdata->digest_enc.len);
6967         } else {
6968                 if (ut_params->obuf)
6969                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6970                                         ciphertext_len, buffer);
6971                 else
6972                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6973                                         ciphertext_len, buffer);
6974
6975                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6976                         ciphertext_len);
6977                 debug_hexdump(stdout, "ciphertext expected:",
6978                         tdata->ciphertext.data,
6979                         tdata->ciphertext.len_bits >> 3);
6980
6981                 if (ut_params->obuf)
6982                         digest = rte_pktmbuf_read(ut_params->obuf,
6983                                         (tdata->digest_enc.offset == 0 ?
6984                                                 plaintext_pad_len :
6985                                                 tdata->digest_enc.offset),
6986                                         tdata->digest_enc.len, digest_buffer);
6987                 else
6988                         digest = rte_pktmbuf_read(ut_params->ibuf,
6989                                         (tdata->digest_enc.offset == 0 ?
6990                                                 plaintext_pad_len :
6991                                                 tdata->digest_enc.offset),
6992                                         tdata->digest_enc.len, digest_buffer);
6993
6994                 debug_hexdump(stdout, "digest:", digest,
6995                                 tdata->digest_enc.len);
6996                 debug_hexdump(stdout, "digest expected:",
6997                                 tdata->digest_enc.data, tdata->digest_enc.len);
6998         }
6999
7000         /* Validate obuf */
7001         if (verify) {
7002                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7003                                 plaintext,
7004                                 tdata->plaintext.data,
7005                                 tdata->plaintext.len_bits >> 3,
7006                                 "Plaintext data not as expected");
7007         } else {
7008                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7009                                 ciphertext,
7010                                 tdata->ciphertext.data,
7011                                 tdata->validDataLen.len_bits,
7012                                 "Ciphertext data not as expected");
7013                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7014                                 digest,
7015                                 tdata->digest_enc.data,
7016                                 tdata->digest_enc.len,
7017                                 "Generated auth tag not as expected");
7018         }
7019
7020         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7021                         "crypto op processing failed");
7022
7023         return 0;
7024 }
7025
7026 /** AUTH AES CMAC + CIPHER AES CTR */
7027
7028 static int
7029 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7030 {
7031         return test_mixed_auth_cipher(
7032                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7033 }
7034
7035 static int
7036 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7037 {
7038         return test_mixed_auth_cipher(
7039                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7040 }
7041
7042 static int
7043 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7044 {
7045         return test_mixed_auth_cipher_sgl(
7046                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7047 }
7048
7049 static int
7050 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7051 {
7052         return test_mixed_auth_cipher_sgl(
7053                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7054 }
7055
7056 static int
7057 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7058 {
7059         return test_mixed_auth_cipher(
7060                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7061 }
7062
7063 static int
7064 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7065 {
7066         return test_mixed_auth_cipher(
7067                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7068 }
7069
7070 static int
7071 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7072 {
7073         return test_mixed_auth_cipher_sgl(
7074                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7075 }
7076
7077 static int
7078 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7079 {
7080         return test_mixed_auth_cipher_sgl(
7081                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7082 }
7083
7084 /** MIXED AUTH + CIPHER */
7085
7086 static int
7087 test_auth_zuc_cipher_snow_test_case_1(void)
7088 {
7089         return test_mixed_auth_cipher(
7090                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7091 }
7092
7093 static int
7094 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7095 {
7096         return test_mixed_auth_cipher(
7097                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7098 }
7099
7100 static int
7101 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7102 {
7103         return test_mixed_auth_cipher(
7104                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7105 }
7106
7107 static int
7108 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7109 {
7110         return test_mixed_auth_cipher(
7111                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7112 }
7113
7114 static int
7115 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7116 {
7117         return test_mixed_auth_cipher(
7118                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7119 }
7120
7121 static int
7122 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7123 {
7124         return test_mixed_auth_cipher(
7125                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7126 }
7127
7128 static int
7129 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7130 {
7131         return test_mixed_auth_cipher(
7132                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7133 }
7134
7135 static int
7136 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7137 {
7138         return test_mixed_auth_cipher(
7139                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7140 }
7141
7142 static int
7143 test_auth_snow_cipher_zuc_test_case_1(void)
7144 {
7145         return test_mixed_auth_cipher(
7146                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7147 }
7148
7149 static int
7150 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7151 {
7152         return test_mixed_auth_cipher(
7153                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7154 }
7155
7156 static int
7157 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7158 {
7159         return test_mixed_auth_cipher(
7160                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7161 }
7162
7163 static int
7164 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7165 {
7166         return test_mixed_auth_cipher(
7167                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7168 }
7169
7170 static int
7171 test_auth_null_cipher_snow_test_case_1(void)
7172 {
7173         return test_mixed_auth_cipher(
7174                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7175 }
7176
7177 static int
7178 test_verify_auth_null_cipher_snow_test_case_1(void)
7179 {
7180         return test_mixed_auth_cipher(
7181                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7182 }
7183
7184 static int
7185 test_auth_null_cipher_zuc_test_case_1(void)
7186 {
7187         return test_mixed_auth_cipher(
7188                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7189 }
7190
7191 static int
7192 test_verify_auth_null_cipher_zuc_test_case_1(void)
7193 {
7194         return test_mixed_auth_cipher(
7195                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7196 }
7197
7198 static int
7199 test_auth_snow_cipher_null_test_case_1(void)
7200 {
7201         return test_mixed_auth_cipher(
7202                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7203 }
7204
7205 static int
7206 test_verify_auth_snow_cipher_null_test_case_1(void)
7207 {
7208         return test_mixed_auth_cipher(
7209                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7210 }
7211
7212 static int
7213 test_auth_zuc_cipher_null_test_case_1(void)
7214 {
7215         return test_mixed_auth_cipher(
7216                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7217 }
7218
7219 static int
7220 test_verify_auth_zuc_cipher_null_test_case_1(void)
7221 {
7222         return test_mixed_auth_cipher(
7223                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7224 }
7225
7226 static int
7227 test_auth_null_cipher_aes_ctr_test_case_1(void)
7228 {
7229         return test_mixed_auth_cipher(
7230                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7231 }
7232
7233 static int
7234 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7235 {
7236         return test_mixed_auth_cipher(
7237                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7238 }
7239
7240 static int
7241 test_auth_aes_cmac_cipher_null_test_case_1(void)
7242 {
7243         return test_mixed_auth_cipher(
7244                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7245 }
7246
7247 static int
7248 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7249 {
7250         return test_mixed_auth_cipher(
7251                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7252 }
7253
7254 static int
7255 test_3DES_chain_qat_all(void)
7256 {
7257         struct crypto_testsuite_params *ts_params = &testsuite_params;
7258         int status;
7259
7260         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7261                 ts_params->op_mpool,
7262                 ts_params->session_mpool, ts_params->session_priv_mpool,
7263                 ts_params->valid_devs[0],
7264                 rte_cryptodev_driver_id_get(
7265                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
7266                 BLKCIPHER_3DES_CHAIN_TYPE);
7267
7268         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7269
7270         return TEST_SUCCESS;
7271 }
7272
7273 static int
7274 test_DES_cipheronly_qat_all(void)
7275 {
7276         struct crypto_testsuite_params *ts_params = &testsuite_params;
7277         int status;
7278
7279         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7280                 ts_params->op_mpool,
7281                 ts_params->session_mpool, ts_params->session_priv_mpool,
7282                 ts_params->valid_devs[0],
7283                 rte_cryptodev_driver_id_get(
7284                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
7285                 BLKCIPHER_DES_CIPHERONLY_TYPE);
7286
7287         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7288
7289         return TEST_SUCCESS;
7290 }
7291
7292 static int
7293 test_DES_cipheronly_openssl_all(void)
7294 {
7295         struct crypto_testsuite_params *ts_params = &testsuite_params;
7296         int status;
7297
7298         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7299                 ts_params->op_mpool,
7300                 ts_params->session_mpool, ts_params->session_priv_mpool,
7301                 ts_params->valid_devs[0],
7302                 rte_cryptodev_driver_id_get(
7303                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
7304                 BLKCIPHER_DES_CIPHERONLY_TYPE);
7305
7306         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7307
7308         return TEST_SUCCESS;
7309 }
7310
7311 static int
7312 test_DES_docsis_openssl_all(void)
7313 {
7314         struct crypto_testsuite_params *ts_params = &testsuite_params;
7315         int status;
7316
7317         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7318                 ts_params->op_mpool,
7319                 ts_params->session_mpool, ts_params->session_priv_mpool,
7320                 ts_params->valid_devs[0],
7321                 rte_cryptodev_driver_id_get(
7322                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
7323                 BLKCIPHER_DES_DOCSIS_TYPE);
7324
7325         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7326
7327         return TEST_SUCCESS;
7328 }
7329
7330 static int
7331 test_DES_cipheronly_mb_all(void)
7332 {
7333         struct crypto_testsuite_params *ts_params = &testsuite_params;
7334         int status;
7335
7336         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7337                 ts_params->op_mpool,
7338                 ts_params->session_mpool, ts_params->session_priv_mpool,
7339                 ts_params->valid_devs[0],
7340                 rte_cryptodev_driver_id_get(
7341                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
7342                 BLKCIPHER_DES_CIPHERONLY_TYPE);
7343
7344         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7345
7346         return TEST_SUCCESS;
7347 }
7348 static int
7349 test_3DES_cipheronly_mb_all(void)
7350 {
7351         struct crypto_testsuite_params *ts_params = &testsuite_params;
7352         int status;
7353
7354         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7355                 ts_params->op_mpool,
7356                 ts_params->session_mpool, ts_params->session_priv_mpool,
7357                 ts_params->valid_devs[0],
7358                 rte_cryptodev_driver_id_get(
7359                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
7360                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
7361
7362         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7363
7364         return TEST_SUCCESS;
7365 }
7366
7367 static int
7368 test_DES_docsis_mb_all(void)
7369 {
7370         struct crypto_testsuite_params *ts_params = &testsuite_params;
7371         int status;
7372
7373         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7374                 ts_params->op_mpool,
7375                 ts_params->session_mpool, ts_params->session_priv_mpool,
7376                 ts_params->valid_devs[0],
7377                 rte_cryptodev_driver_id_get(
7378                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
7379                 BLKCIPHER_DES_DOCSIS_TYPE);
7380
7381         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7382
7383         return TEST_SUCCESS;
7384 }
7385
7386 static int
7387 test_3DES_chain_caam_jr_all(void)
7388 {
7389         struct crypto_testsuite_params *ts_params = &testsuite_params;
7390         int status;
7391
7392         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7393                 ts_params->op_mpool,
7394                 ts_params->session_mpool, ts_params->session_priv_mpool,
7395                 ts_params->valid_devs[0],
7396                 rte_cryptodev_driver_id_get(
7397                 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
7398                 BLKCIPHER_3DES_CHAIN_TYPE);
7399
7400         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7401
7402         return TEST_SUCCESS;
7403 }
7404
7405 static int
7406 test_3DES_cipheronly_caam_jr_all(void)
7407 {
7408         struct crypto_testsuite_params *ts_params = &testsuite_params;
7409         int status;
7410
7411         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7412                 ts_params->op_mpool,
7413                 ts_params->session_mpool, ts_params->session_priv_mpool,
7414                 ts_params->valid_devs[0],
7415                 rte_cryptodev_driver_id_get(
7416                 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
7417                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
7418
7419         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7420
7421         return TEST_SUCCESS;
7422 }
7423
7424 static int
7425 test_3DES_chain_dpaa_sec_all(void)
7426 {
7427         struct crypto_testsuite_params *ts_params = &testsuite_params;
7428         int status;
7429
7430         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7431                 ts_params->op_mpool,
7432                 ts_params->session_mpool, ts_params->session_priv_mpool,
7433                 ts_params->valid_devs[0],
7434                 rte_cryptodev_driver_id_get(
7435                 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
7436                 BLKCIPHER_3DES_CHAIN_TYPE);
7437
7438         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7439
7440         return TEST_SUCCESS;
7441 }
7442
7443 static int
7444 test_3DES_cipheronly_dpaa_sec_all(void)
7445 {
7446         struct crypto_testsuite_params *ts_params = &testsuite_params;
7447         int status;
7448
7449         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7450                 ts_params->op_mpool,
7451                 ts_params->session_mpool, ts_params->session_priv_mpool,
7452                 ts_params->valid_devs[0],
7453                 rte_cryptodev_driver_id_get(
7454                 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
7455                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
7456
7457         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7458
7459         return TEST_SUCCESS;
7460 }
7461
7462 static int
7463 test_3DES_chain_dpaa2_sec_all(void)
7464 {
7465         struct crypto_testsuite_params *ts_params = &testsuite_params;
7466         int status;
7467
7468         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7469                 ts_params->op_mpool,
7470                 ts_params->session_mpool, ts_params->session_priv_mpool,
7471                 ts_params->valid_devs[0],
7472                 rte_cryptodev_driver_id_get(
7473                 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
7474                 BLKCIPHER_3DES_CHAIN_TYPE);
7475
7476         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7477
7478         return TEST_SUCCESS;
7479 }
7480
7481 static int
7482 test_3DES_cipheronly_dpaa2_sec_all(void)
7483 {
7484         struct crypto_testsuite_params *ts_params = &testsuite_params;
7485         int status;
7486
7487         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7488                 ts_params->op_mpool,
7489                 ts_params->session_mpool, ts_params->session_priv_mpool,
7490                 ts_params->valid_devs[0],
7491                 rte_cryptodev_driver_id_get(
7492                 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
7493                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
7494
7495         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7496
7497         return TEST_SUCCESS;
7498 }
7499
7500 static int
7501 test_3DES_chain_ccp_all(void)
7502 {
7503         struct crypto_testsuite_params *ts_params = &testsuite_params;
7504         int status;
7505
7506         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7507                 ts_params->op_mpool,
7508                 ts_params->session_mpool, ts_params->session_priv_mpool,
7509                 ts_params->valid_devs[0],
7510                 rte_cryptodev_driver_id_get(
7511                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
7512                 BLKCIPHER_3DES_CHAIN_TYPE);
7513
7514         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7515
7516         return TEST_SUCCESS;
7517 }
7518
7519 static int
7520 test_3DES_cipheronly_ccp_all(void)
7521 {
7522         struct crypto_testsuite_params *ts_params = &testsuite_params;
7523         int status;
7524
7525         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7526                 ts_params->op_mpool,
7527                 ts_params->session_mpool, ts_params->session_priv_mpool,
7528                 ts_params->valid_devs[0],
7529                 rte_cryptodev_driver_id_get(
7530                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
7531                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
7532
7533         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7534
7535         return TEST_SUCCESS;
7536 }
7537
7538 static int
7539 test_3DES_cipheronly_qat_all(void)
7540 {
7541         struct crypto_testsuite_params *ts_params = &testsuite_params;
7542         int status;
7543
7544         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7545                 ts_params->op_mpool,
7546                 ts_params->session_mpool, ts_params->session_priv_mpool,
7547                 ts_params->valid_devs[0],
7548                 rte_cryptodev_driver_id_get(
7549                 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
7550                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
7551
7552         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7553
7554         return TEST_SUCCESS;
7555 }
7556
7557 static int
7558 test_3DES_chain_openssl_all(void)
7559 {
7560         struct crypto_testsuite_params *ts_params = &testsuite_params;
7561         int status;
7562
7563         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7564                 ts_params->op_mpool,
7565                 ts_params->session_mpool, ts_params->session_priv_mpool,
7566                 ts_params->valid_devs[0],
7567                 rte_cryptodev_driver_id_get(
7568                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
7569                 BLKCIPHER_3DES_CHAIN_TYPE);
7570
7571         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7572
7573         return TEST_SUCCESS;
7574 }
7575
7576 static int
7577 test_3DES_cipheronly_openssl_all(void)
7578 {
7579         struct crypto_testsuite_params *ts_params = &testsuite_params;
7580         int status;
7581
7582         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
7583                 ts_params->op_mpool,
7584                 ts_params->session_mpool, ts_params->session_priv_mpool,
7585                 ts_params->valid_devs[0],
7586                 rte_cryptodev_driver_id_get(
7587                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
7588                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
7589
7590         TEST_ASSERT_EQUAL(status, 0, "Test failed");
7591
7592         return TEST_SUCCESS;
7593 }
7594
7595 /* ***** AEAD algorithm Tests ***** */
7596
7597 static int
7598 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7599                 enum rte_crypto_aead_operation op,
7600                 const uint8_t *key, const uint8_t key_len,
7601                 const uint16_t aad_len, const uint8_t auth_len,
7602                 uint8_t iv_len)
7603 {
7604         uint8_t aead_key[key_len];
7605
7606         struct crypto_testsuite_params *ts_params = &testsuite_params;
7607         struct crypto_unittest_params *ut_params = &unittest_params;
7608
7609         memcpy(aead_key, key, key_len);
7610
7611         /* Setup AEAD Parameters */
7612         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7613         ut_params->aead_xform.next = NULL;
7614         ut_params->aead_xform.aead.algo = algo;
7615         ut_params->aead_xform.aead.op = op;
7616         ut_params->aead_xform.aead.key.data = aead_key;
7617         ut_params->aead_xform.aead.key.length = key_len;
7618         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7619         ut_params->aead_xform.aead.iv.length = iv_len;
7620         ut_params->aead_xform.aead.digest_length = auth_len;
7621         ut_params->aead_xform.aead.aad_length = aad_len;
7622
7623         debug_hexdump(stdout, "key:", key, key_len);
7624
7625         /* Create Crypto session*/
7626         ut_params->sess = rte_cryptodev_sym_session_create(
7627                         ts_params->session_mpool);
7628
7629         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7630                         &ut_params->aead_xform,
7631                         ts_params->session_priv_mpool);
7632
7633         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7634
7635         return 0;
7636 }
7637
7638 static int
7639 create_aead_xform(struct rte_crypto_op *op,
7640                 enum rte_crypto_aead_algorithm algo,
7641                 enum rte_crypto_aead_operation aead_op,
7642                 uint8_t *key, const uint8_t key_len,
7643                 const uint8_t aad_len, const uint8_t auth_len,
7644                 uint8_t iv_len)
7645 {
7646         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
7647                         "failed to allocate space for crypto transform");
7648
7649         struct rte_crypto_sym_op *sym_op = op->sym;
7650
7651         /* Setup AEAD Parameters */
7652         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
7653         sym_op->xform->next = NULL;
7654         sym_op->xform->aead.algo = algo;
7655         sym_op->xform->aead.op = aead_op;
7656         sym_op->xform->aead.key.data = key;
7657         sym_op->xform->aead.key.length = key_len;
7658         sym_op->xform->aead.iv.offset = IV_OFFSET;
7659         sym_op->xform->aead.iv.length = iv_len;
7660         sym_op->xform->aead.digest_length = auth_len;
7661         sym_op->xform->aead.aad_length = aad_len;
7662
7663         debug_hexdump(stdout, "key:", key, key_len);
7664
7665         return 0;
7666 }
7667
7668 static int
7669 create_aead_operation(enum rte_crypto_aead_operation op,
7670                 const struct aead_test_data *tdata)
7671 {
7672         struct crypto_testsuite_params *ts_params = &testsuite_params;
7673         struct crypto_unittest_params *ut_params = &unittest_params;
7674
7675         uint8_t *plaintext, *ciphertext;
7676         unsigned int aad_pad_len, plaintext_pad_len;
7677
7678         /* Generate Crypto op data structure */
7679         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7680                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7681         TEST_ASSERT_NOT_NULL(ut_params->op,
7682                         "Failed to allocate symmetric crypto operation struct");
7683
7684         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7685
7686         /* Append aad data */
7687         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
7688                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
7689                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7690                                 aad_pad_len);
7691                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7692                                 "no room to append aad");
7693
7694                 sym_op->aead.aad.phys_addr =
7695                                 rte_pktmbuf_iova(ut_params->ibuf);
7696                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
7697                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
7698                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7699                         tdata->aad.len);
7700
7701                 /* Append IV at the end of the crypto operation*/
7702                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7703                                 uint8_t *, IV_OFFSET);
7704
7705                 /* Copy IV 1 byte after the IV pointer, according to the API */
7706                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
7707                 debug_hexdump(stdout, "iv:", iv_ptr,
7708                         tdata->iv.len);
7709         } else {
7710                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
7711                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7712                                 aad_pad_len);
7713                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7714                                 "no room to append aad");
7715
7716                 sym_op->aead.aad.phys_addr =
7717                                 rte_pktmbuf_iova(ut_params->ibuf);
7718                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
7719                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7720                         tdata->aad.len);
7721
7722                 /* Append IV at the end of the crypto operation*/
7723                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7724                                 uint8_t *, IV_OFFSET);
7725
7726                 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
7727                 debug_hexdump(stdout, "iv:", iv_ptr,
7728                         tdata->iv.len);
7729         }
7730
7731         /* Append plaintext/ciphertext */
7732         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7733                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7734                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7735                                 plaintext_pad_len);
7736                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7737
7738                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
7739                 debug_hexdump(stdout, "plaintext:", plaintext,
7740                                 tdata->plaintext.len);
7741
7742                 if (ut_params->obuf) {
7743                         ciphertext = (uint8_t *)rte_pktmbuf_append(
7744                                         ut_params->obuf,
7745                                         plaintext_pad_len + aad_pad_len);
7746                         TEST_ASSERT_NOT_NULL(ciphertext,
7747                                         "no room to append ciphertext");
7748
7749                         memset(ciphertext + aad_pad_len, 0,
7750                                         tdata->ciphertext.len);
7751                 }
7752         } else {
7753                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
7754                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7755                                 plaintext_pad_len);
7756                 TEST_ASSERT_NOT_NULL(ciphertext,
7757                                 "no room to append ciphertext");
7758
7759                 memcpy(ciphertext, tdata->ciphertext.data,
7760                                 tdata->ciphertext.len);
7761                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7762                                 tdata->ciphertext.len);
7763
7764                 if (ut_params->obuf) {
7765                         plaintext = (uint8_t *)rte_pktmbuf_append(
7766                                         ut_params->obuf,
7767                                         plaintext_pad_len + aad_pad_len);
7768                         TEST_ASSERT_NOT_NULL(plaintext,
7769                                         "no room to append plaintext");
7770
7771                         memset(plaintext + aad_pad_len, 0,
7772                                         tdata->plaintext.len);
7773                 }
7774         }
7775
7776         /* Append digest data */
7777         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7778                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7779                                 ut_params->obuf ? ut_params->obuf :
7780                                                 ut_params->ibuf,
7781                                                 tdata->auth_tag.len);
7782                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7783                                 "no room to append digest");
7784                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
7785                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7786                                 ut_params->obuf ? ut_params->obuf :
7787                                                 ut_params->ibuf,
7788                                                 plaintext_pad_len +
7789                                                 aad_pad_len);
7790         } else {
7791                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7792                                 ut_params->ibuf, tdata->auth_tag.len);
7793                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7794                                 "no room to append digest");
7795                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7796                                 ut_params->ibuf,
7797                                 plaintext_pad_len + aad_pad_len);
7798
7799                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
7800                         tdata->auth_tag.len);
7801                 debug_hexdump(stdout, "digest:",
7802                         sym_op->aead.digest.data,
7803                         tdata->auth_tag.len);
7804         }
7805
7806         sym_op->aead.data.length = tdata->plaintext.len;
7807         sym_op->aead.data.offset = aad_pad_len;
7808
7809         return 0;
7810 }
7811
7812 static int
7813 test_authenticated_encryption(const struct aead_test_data *tdata)
7814 {
7815         struct crypto_testsuite_params *ts_params = &testsuite_params;
7816         struct crypto_unittest_params *ut_params = &unittest_params;
7817         struct rte_cryptodev_sym_capability_idx cap_idx;
7818
7819         int retval;
7820         uint8_t *ciphertext, *auth_tag;
7821         uint16_t plaintext_pad_len;
7822         uint32_t i;
7823
7824         /* Create AEAD session */
7825         retval = create_aead_session(ts_params->valid_devs[0],
7826                         tdata->algo,
7827                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
7828                         tdata->key.data, tdata->key.len,
7829                         tdata->aad.len, tdata->auth_tag.len,
7830                         tdata->iv.len);
7831
7832         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7833         cap_idx.algo.aead = tdata->algo;
7834
7835         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
7836                         &cap_idx) == NULL) {
7837                 return -ENOTSUP;
7838         }
7839
7840         if (retval < 0)
7841                 return retval;
7842
7843         if (tdata->aad.len > MBUF_SIZE) {
7844                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
7845                 /* Populate full size of add data */
7846                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
7847                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
7848         } else
7849                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7850
7851         /* clear mbuf payload */
7852         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7853                         rte_pktmbuf_tailroom(ut_params->ibuf));
7854
7855         /* Create AEAD operation */
7856         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
7857         if (retval < 0)
7858                 return retval;
7859
7860         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7861
7862         ut_params->op->sym->m_src = ut_params->ibuf;
7863
7864         /* Process crypto operation */
7865         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7866                         ut_params->op), "failed to process sym crypto op");
7867
7868         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7869                         "crypto op processing failed");
7870
7871         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7872
7873         if (ut_params->op->sym->m_dst) {
7874                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7875                                 uint8_t *);
7876                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7877                                 uint8_t *, plaintext_pad_len);
7878         } else {
7879                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7880                                 uint8_t *,
7881                                 ut_params->op->sym->cipher.data.offset);
7882                 auth_tag = ciphertext + plaintext_pad_len;
7883         }
7884
7885         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7886         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7887
7888         /* Validate obuf */
7889         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7890                         ciphertext,
7891                         tdata->ciphertext.data,
7892                         tdata->ciphertext.len,
7893                         "Ciphertext data not as expected");
7894
7895         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7896                         auth_tag,
7897                         tdata->auth_tag.data,
7898                         tdata->auth_tag.len,
7899                         "Generated auth tag not as expected");
7900
7901         return 0;
7902
7903 }
7904
7905 #ifdef RTE_LIBRTE_SECURITY
7906 /* Basic algorithm run function for async inplace mode.
7907  * Creates a session from input parameters and runs one operation
7908  * on input_vec. Checks the output of the crypto operation against
7909  * output_vec.
7910  */
7911 static int
7912 test_pdcp_proto(int i, int oop,
7913         enum rte_crypto_cipher_operation opc,
7914         enum rte_crypto_auth_operation opa,
7915         uint8_t *input_vec,
7916         unsigned int input_vec_len,
7917         uint8_t *output_vec,
7918         unsigned int output_vec_len)
7919 {
7920         struct crypto_testsuite_params *ts_params = &testsuite_params;
7921         struct crypto_unittest_params *ut_params = &unittest_params;
7922         uint8_t *plaintext;
7923         int ret = TEST_SUCCESS;
7924
7925         /* Generate test mbuf data */
7926         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7927
7928         /* clear mbuf payload */
7929         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7930                         rte_pktmbuf_tailroom(ut_params->ibuf));
7931
7932         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7933                                                   input_vec_len);
7934         memcpy(plaintext, input_vec, input_vec_len);
7935
7936         /* Out of place support */
7937         if (oop) {
7938                 /*
7939                  * For out-op-place we need to alloc another mbuf
7940                  */
7941                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7942                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
7943         }
7944
7945         /* Set crypto type as IPSEC */
7946         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7947
7948         /* Setup Cipher Parameters */
7949         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7950         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
7951         ut_params->cipher_xform.cipher.op = opc;
7952         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
7953         ut_params->cipher_xform.cipher.key.length =
7954                                         pdcp_test_params[i].cipher_key_len;
7955         ut_params->cipher_xform.cipher.iv.length = 0;
7956
7957         /* Setup HMAC Parameters if ICV header is required */
7958         if (pdcp_test_params[i].auth_alg != 0) {
7959                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7960                 ut_params->auth_xform.next = NULL;
7961                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
7962                 ut_params->auth_xform.auth.op = opa;
7963                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
7964                 ut_params->auth_xform.auth.key.length =
7965                                         pdcp_test_params[i].auth_key_len;
7966
7967                 ut_params->cipher_xform.next = &ut_params->auth_xform;
7968         } else {
7969                 ut_params->cipher_xform.next = NULL;
7970         }
7971
7972         struct rte_security_session_conf sess_conf = {
7973                 .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
7974                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
7975                 {.pdcp = {
7976                         .bearer = pdcp_test_bearer[i],
7977                         .domain = pdcp_test_params[i].domain,
7978                         .pkt_dir = pdcp_test_packet_direction[i],
7979                         .sn_size = pdcp_test_data_sn_size[i],
7980                         .hfn = pdcp_test_hfn[i],
7981                         .hfn_threshold = pdcp_test_hfn_threshold[i],
7982                 } },
7983                 .crypto_xform = &ut_params->cipher_xform
7984         };
7985
7986         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7987                                 rte_cryptodev_get_sec_ctx(
7988                                 ts_params->valid_devs[0]);
7989
7990         /* Create security session */
7991         ut_params->sec_session = rte_security_session_create(ctx,
7992                                 &sess_conf, ts_params->session_priv_mpool);
7993
7994         if (!ut_params->sec_session) {
7995                 printf("TestCase %s()-%d line %d failed %s: ",
7996                         __func__, i, __LINE__, "Failed to allocate session");
7997                 ret = TEST_FAILED;
7998                 goto on_err;
7999         }
8000
8001         /* Generate crypto op data structure */
8002         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8003                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8004         if (!ut_params->op) {
8005                 printf("TestCase %s()-%d line %d failed %s: ",
8006                         __func__, i, __LINE__,
8007                         "Failed to allocate symmetric crypto operation struct");
8008                 ret = TEST_FAILED;
8009                 goto on_err;
8010         }
8011
8012         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8013
8014         /* set crypto operation source mbuf */
8015         ut_params->op->sym->m_src = ut_params->ibuf;
8016         if (oop)
8017                 ut_params->op->sym->m_dst = ut_params->obuf;
8018
8019         /* Process crypto operation */
8020         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8021                 == NULL) {
8022                 printf("TestCase %s()-%d line %d failed %s: ",
8023                         __func__, i, __LINE__,
8024                         "failed to process sym crypto op");
8025                 ret = TEST_FAILED;
8026                 goto on_err;
8027         }
8028
8029         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8030                 printf("TestCase %s()-%d line %d failed %s: ",
8031                         __func__, i, __LINE__, "crypto op processing failed");
8032                 ret = TEST_FAILED;
8033                 goto on_err;
8034         }
8035
8036         /* Validate obuf */
8037         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8038                         uint8_t *);
8039         if (oop) {
8040                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8041                                 uint8_t *);
8042         }
8043
8044         if (memcmp(ciphertext, output_vec, output_vec_len)) {
8045                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8046                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8047                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8048                 ret = TEST_FAILED;
8049                 goto on_err;
8050         }
8051
8052 on_err:
8053         rte_crypto_op_free(ut_params->op);
8054         ut_params->op = NULL;
8055
8056         if (ut_params->sec_session)
8057                 rte_security_session_destroy(ctx, ut_params->sec_session);
8058         ut_params->sec_session = NULL;
8059
8060         rte_pktmbuf_free(ut_params->ibuf);
8061         ut_params->ibuf = NULL;
8062         if (oop) {
8063                 rte_pktmbuf_free(ut_params->obuf);
8064                 ut_params->obuf = NULL;
8065         }
8066
8067         return ret;
8068 }
8069
8070 static int
8071 test_pdcp_proto_SGL(int i, int oop,
8072         enum rte_crypto_cipher_operation opc,
8073         enum rte_crypto_auth_operation opa,
8074         uint8_t *input_vec,
8075         unsigned int input_vec_len,
8076         uint8_t *output_vec,
8077         unsigned int output_vec_len,
8078         uint32_t fragsz,
8079         uint32_t fragsz_oop)
8080 {
8081         struct crypto_testsuite_params *ts_params = &testsuite_params;
8082         struct crypto_unittest_params *ut_params = &unittest_params;
8083         uint8_t *plaintext;
8084         struct rte_mbuf *buf, *buf_oop = NULL;
8085         int ret = TEST_SUCCESS;
8086         int to_trn = 0;
8087         int to_trn_tbl[16];
8088         int segs = 1;
8089         unsigned int trn_data = 0;
8090
8091         if (fragsz > input_vec_len)
8092                 fragsz = input_vec_len;
8093
8094         uint16_t plaintext_len = fragsz;
8095         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8096
8097         if (fragsz_oop > output_vec_len)
8098                 frag_size_oop = output_vec_len;
8099
8100         int ecx = 0;
8101         if (input_vec_len % fragsz != 0) {
8102                 if (input_vec_len / fragsz + 1 > 16)
8103                         return 1;
8104         } else if (input_vec_len / fragsz > 16)
8105                 return 1;
8106
8107         /* Out of place support */
8108         if (oop) {
8109                 /*
8110                  * For out-op-place we need to alloc another mbuf
8111                  */
8112                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8113                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8114                 buf_oop = ut_params->obuf;
8115         }
8116
8117         /* Generate test mbuf data */
8118         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8119
8120         /* clear mbuf payload */
8121         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8122                         rte_pktmbuf_tailroom(ut_params->ibuf));
8123
8124         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8125                                                   plaintext_len);
8126         memcpy(plaintext, input_vec, plaintext_len);
8127         trn_data += plaintext_len;
8128
8129         buf = ut_params->ibuf;
8130
8131         /*
8132          * Loop until no more fragments
8133          */
8134
8135         while (trn_data < input_vec_len) {
8136                 ++segs;
8137                 to_trn = (input_vec_len - trn_data < fragsz) ?
8138                                 (input_vec_len - trn_data) : fragsz;
8139
8140                 to_trn_tbl[ecx++] = to_trn;
8141
8142                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8143                 buf = buf->next;
8144
8145                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8146                                 rte_pktmbuf_tailroom(buf));
8147
8148                 /* OOP */
8149                 if (oop && !fragsz_oop) {
8150                         buf_oop->next =
8151                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8152                         buf_oop = buf_oop->next;
8153                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8154                                         0, rte_pktmbuf_tailroom(buf_oop));
8155                         rte_pktmbuf_append(buf_oop, to_trn);
8156                 }
8157
8158                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8159                                 to_trn);
8160
8161                 memcpy(plaintext, input_vec + trn_data, to_trn);
8162                 trn_data += to_trn;
8163         }
8164
8165         ut_params->ibuf->nb_segs = segs;
8166
8167         segs = 1;
8168         if (fragsz_oop && oop) {
8169                 to_trn = 0;
8170                 ecx = 0;
8171
8172                 trn_data = frag_size_oop;
8173                 while (trn_data < output_vec_len) {
8174                         ++segs;
8175                         to_trn =
8176                                 (output_vec_len - trn_data <
8177                                                 frag_size_oop) ?
8178                                 (output_vec_len - trn_data) :
8179                                                 frag_size_oop;
8180
8181                         to_trn_tbl[ecx++] = to_trn;
8182
8183                         buf_oop->next =
8184                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8185                         buf_oop = buf_oop->next;
8186                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8187                                         0, rte_pktmbuf_tailroom(buf_oop));
8188                         rte_pktmbuf_append(buf_oop, to_trn);
8189
8190                         trn_data += to_trn;
8191                 }
8192                 ut_params->obuf->nb_segs = segs;
8193         }
8194
8195         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
8196
8197         /* Setup Cipher Parameters */
8198         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8199         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8200         ut_params->cipher_xform.cipher.op = opc;
8201         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8202         ut_params->cipher_xform.cipher.key.length =
8203                                         pdcp_test_params[i].cipher_key_len;
8204         ut_params->cipher_xform.cipher.iv.length = 0;
8205
8206         /* Setup HMAC Parameters if ICV header is required */
8207         if (pdcp_test_params[i].auth_alg != 0) {
8208                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8209                 ut_params->auth_xform.next = NULL;
8210                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8211                 ut_params->auth_xform.auth.op = opa;
8212                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8213                 ut_params->auth_xform.auth.key.length =
8214                                         pdcp_test_params[i].auth_key_len;
8215
8216                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8217         } else {
8218                 ut_params->cipher_xform.next = NULL;
8219         }
8220
8221         struct rte_security_session_conf sess_conf = {
8222                 .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
8223                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8224                 {.pdcp = {
8225                         .bearer = pdcp_test_bearer[i],
8226                         .domain = pdcp_test_params[i].domain,
8227                         .pkt_dir = pdcp_test_packet_direction[i],
8228                         .sn_size = pdcp_test_data_sn_size[i],
8229                         .hfn = pdcp_test_hfn[i],
8230                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8231                 } },
8232                 .crypto_xform = &ut_params->cipher_xform
8233         };
8234
8235         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8236                                 rte_cryptodev_get_sec_ctx(
8237                                 ts_params->valid_devs[0]);
8238
8239         /* Create security session */
8240         ut_params->sec_session = rte_security_session_create(ctx,
8241                                 &sess_conf, ts_params->session_priv_mpool);
8242
8243         if (!ut_params->sec_session) {
8244                 printf("TestCase %s()-%d line %d failed %s: ",
8245                         __func__, i, __LINE__, "Failed to allocate session");
8246                 ret = TEST_FAILED;
8247                 goto on_err;
8248         }
8249
8250         /* Generate crypto op data structure */
8251         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8252                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8253         if (!ut_params->op) {
8254                 printf("TestCase %s()-%d line %d failed %s: ",
8255                         __func__, i, __LINE__,
8256                         "Failed to allocate symmetric crypto operation struct");
8257                 ret = TEST_FAILED;
8258                 goto on_err;
8259         }
8260
8261         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8262
8263         /* set crypto operation source mbuf */
8264         ut_params->op->sym->m_src = ut_params->ibuf;
8265         if (oop)
8266                 ut_params->op->sym->m_dst = ut_params->obuf;
8267
8268         /* Process crypto operation */
8269         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8270                 == NULL) {
8271                 printf("TestCase %s()-%d line %d failed %s: ",
8272                         __func__, i, __LINE__,
8273                         "failed to process sym crypto op");
8274                 ret = TEST_FAILED;
8275                 goto on_err;
8276         }
8277
8278         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8279                 printf("TestCase %s()-%d line %d failed %s: ",
8280                         __func__, i, __LINE__, "crypto op processing failed");
8281                 ret = TEST_FAILED;
8282                 goto on_err;
8283         }
8284
8285         /* Validate obuf */
8286         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8287                         uint8_t *);
8288         if (oop) {
8289                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8290                                 uint8_t *);
8291         }
8292         if (fragsz_oop)
8293                 fragsz = frag_size_oop;
8294         if (memcmp(ciphertext, output_vec, fragsz)) {
8295                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8296                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8297                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8298                 ret = TEST_FAILED;
8299                 goto on_err;
8300         }
8301
8302         buf = ut_params->op->sym->m_src->next;
8303         if (oop)
8304                 buf = ut_params->op->sym->m_dst->next;
8305
8306         unsigned int off = fragsz;
8307
8308         ecx = 0;
8309         while (buf) {
8310                 ciphertext = rte_pktmbuf_mtod(buf,
8311                                 uint8_t *);
8312                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8313                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8314                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8315                         rte_hexdump(stdout, "reference", output_vec + off,
8316                                         to_trn_tbl[ecx]);
8317                         ret = TEST_FAILED;
8318                         goto on_err;
8319                 }
8320                 off += to_trn_tbl[ecx++];
8321                 buf = buf->next;
8322         }
8323 on_err:
8324         rte_crypto_op_free(ut_params->op);
8325         ut_params->op = NULL;
8326
8327         if (ut_params->sec_session)
8328                 rte_security_session_destroy(ctx, ut_params->sec_session);
8329         ut_params->sec_session = NULL;
8330
8331         rte_pktmbuf_free(ut_params->ibuf);
8332         ut_params->ibuf = NULL;
8333         if (oop) {
8334                 rte_pktmbuf_free(ut_params->obuf);
8335                 ut_params->obuf = NULL;
8336         }
8337
8338         return ret;
8339 }
8340
8341 int
8342 test_pdcp_proto_cplane_encap(int i)
8343 {
8344         return test_pdcp_proto(i, 0,
8345                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8346                 RTE_CRYPTO_AUTH_OP_GENERATE,
8347                 pdcp_test_data_in[i],
8348                 pdcp_test_data_in_len[i],
8349                 pdcp_test_data_out[i],
8350                 pdcp_test_data_in_len[i]+4);
8351 }
8352
8353 int
8354 test_pdcp_proto_uplane_encap(int i)
8355 {
8356         return test_pdcp_proto(i, 0,
8357                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8358                 RTE_CRYPTO_AUTH_OP_GENERATE,
8359                 pdcp_test_data_in[i],
8360                 pdcp_test_data_in_len[i],
8361                 pdcp_test_data_out[i],
8362                 pdcp_test_data_in_len[i]);
8363
8364 }
8365
8366 int
8367 test_pdcp_proto_uplane_encap_with_int(int i)
8368 {
8369         return test_pdcp_proto(i, 0,
8370                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8371                 RTE_CRYPTO_AUTH_OP_GENERATE,
8372                 pdcp_test_data_in[i],
8373                 pdcp_test_data_in_len[i],
8374                 pdcp_test_data_out[i],
8375                 pdcp_test_data_in_len[i] + 4);
8376 }
8377
8378 int
8379 test_pdcp_proto_cplane_decap(int i)
8380 {
8381         return test_pdcp_proto(i, 0,
8382                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
8383                 RTE_CRYPTO_AUTH_OP_VERIFY,
8384                 pdcp_test_data_out[i],
8385                 pdcp_test_data_in_len[i] + 4,
8386                 pdcp_test_data_in[i],
8387                 pdcp_test_data_in_len[i]);
8388 }
8389
8390 int
8391 test_pdcp_proto_uplane_decap(int i)
8392 {
8393         return test_pdcp_proto(i, 0,
8394                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
8395                 RTE_CRYPTO_AUTH_OP_VERIFY,
8396                 pdcp_test_data_out[i],
8397                 pdcp_test_data_in_len[i],
8398                 pdcp_test_data_in[i],
8399                 pdcp_test_data_in_len[i]);
8400 }
8401
8402 int
8403 test_pdcp_proto_uplane_decap_with_int(int i)
8404 {
8405         return test_pdcp_proto(i, 0,
8406                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
8407                 RTE_CRYPTO_AUTH_OP_VERIFY,
8408                 pdcp_test_data_out[i],
8409                 pdcp_test_data_in_len[i] + 4,
8410                 pdcp_test_data_in[i],
8411                 pdcp_test_data_in_len[i]);
8412 }
8413
8414 static int
8415 test_PDCP_PROTO_SGL_in_place_32B(void)
8416 {
8417         /* i can be used for running any PDCP case
8418          * In this case it is uplane 12-bit AES-SNOW DL encap
8419          */
8420         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8421         return test_pdcp_proto_SGL(i, IN_PLACE,
8422                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8423                         RTE_CRYPTO_AUTH_OP_GENERATE,
8424                         pdcp_test_data_in[i],
8425                         pdcp_test_data_in_len[i],
8426                         pdcp_test_data_out[i],
8427                         pdcp_test_data_in_len[i]+4,
8428                         32, 0);
8429 }
8430 static int
8431 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8432 {
8433         /* i can be used for running any PDCP case
8434          * In this case it is uplane 18-bit NULL-NULL DL encap
8435          */
8436         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8437         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8438                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8439                         RTE_CRYPTO_AUTH_OP_GENERATE,
8440                         pdcp_test_data_in[i],
8441                         pdcp_test_data_in_len[i],
8442                         pdcp_test_data_out[i],
8443                         pdcp_test_data_in_len[i]+4,
8444                         32, 128);
8445 }
8446 static int
8447 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8448 {
8449         /* i can be used for running any PDCP case
8450          * In this case it is uplane 18-bit AES DL encap
8451          */
8452         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8453                         + DOWNLINK;
8454         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8455                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8456                         RTE_CRYPTO_AUTH_OP_GENERATE,
8457                         pdcp_test_data_in[i],
8458                         pdcp_test_data_in_len[i],
8459                         pdcp_test_data_out[i],
8460                         pdcp_test_data_in_len[i],
8461                         32, 40);
8462 }
8463 static int
8464 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8465 {
8466         /* i can be used for running any PDCP case
8467          * In this case it is cplane 12-bit AES-ZUC DL encap
8468          */
8469         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8470         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8471                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8472                         RTE_CRYPTO_AUTH_OP_GENERATE,
8473                         pdcp_test_data_in[i],
8474                         pdcp_test_data_in_len[i],
8475                         pdcp_test_data_out[i],
8476                         pdcp_test_data_in_len[i]+4,
8477                         128, 32);
8478 }
8479 #endif
8480
8481 static int
8482 test_AES_GCM_authenticated_encryption_test_case_1(void)
8483 {
8484         return test_authenticated_encryption(&gcm_test_case_1);
8485 }
8486
8487 static int
8488 test_AES_GCM_authenticated_encryption_test_case_2(void)
8489 {
8490         return test_authenticated_encryption(&gcm_test_case_2);
8491 }
8492
8493 static int
8494 test_AES_GCM_authenticated_encryption_test_case_3(void)
8495 {
8496         return test_authenticated_encryption(&gcm_test_case_3);
8497 }
8498
8499 static int
8500 test_AES_GCM_authenticated_encryption_test_case_4(void)
8501 {
8502         return test_authenticated_encryption(&gcm_test_case_4);
8503 }
8504
8505 static int
8506 test_AES_GCM_authenticated_encryption_test_case_5(void)
8507 {
8508         return test_authenticated_encryption(&gcm_test_case_5);
8509 }
8510
8511 static int
8512 test_AES_GCM_authenticated_encryption_test_case_6(void)
8513 {
8514         return test_authenticated_encryption(&gcm_test_case_6);
8515 }
8516
8517 static int
8518 test_AES_GCM_authenticated_encryption_test_case_7(void)
8519 {
8520         return test_authenticated_encryption(&gcm_test_case_7);
8521 }
8522
8523 static int
8524 test_AES_GCM_authenticated_encryption_test_case_8(void)
8525 {
8526         return test_authenticated_encryption(&gcm_test_case_8);
8527 }
8528
8529 static int
8530 test_AES_GCM_auth_encryption_test_case_192_1(void)
8531 {
8532         return test_authenticated_encryption(&gcm_test_case_192_1);
8533 }
8534
8535 static int
8536 test_AES_GCM_auth_encryption_test_case_192_2(void)
8537 {
8538         return test_authenticated_encryption(&gcm_test_case_192_2);
8539 }
8540
8541 static int
8542 test_AES_GCM_auth_encryption_test_case_192_3(void)
8543 {
8544         return test_authenticated_encryption(&gcm_test_case_192_3);
8545 }
8546
8547 static int
8548 test_AES_GCM_auth_encryption_test_case_192_4(void)
8549 {
8550         return test_authenticated_encryption(&gcm_test_case_192_4);
8551 }
8552
8553 static int
8554 test_AES_GCM_auth_encryption_test_case_192_5(void)
8555 {
8556         return test_authenticated_encryption(&gcm_test_case_192_5);
8557 }
8558
8559 static int
8560 test_AES_GCM_auth_encryption_test_case_192_6(void)
8561 {
8562         return test_authenticated_encryption(&gcm_test_case_192_6);
8563 }
8564
8565 static int
8566 test_AES_GCM_auth_encryption_test_case_192_7(void)
8567 {
8568         return test_authenticated_encryption(&gcm_test_case_192_7);
8569 }
8570
8571 static int
8572 test_AES_GCM_auth_encryption_test_case_256_1(void)
8573 {
8574         return test_authenticated_encryption(&gcm_test_case_256_1);
8575 }
8576
8577 static int
8578 test_AES_GCM_auth_encryption_test_case_256_2(void)
8579 {
8580         return test_authenticated_encryption(&gcm_test_case_256_2);
8581 }
8582
8583 static int
8584 test_AES_GCM_auth_encryption_test_case_256_3(void)
8585 {
8586         return test_authenticated_encryption(&gcm_test_case_256_3);
8587 }
8588
8589 static int
8590 test_AES_GCM_auth_encryption_test_case_256_4(void)
8591 {
8592         return test_authenticated_encryption(&gcm_test_case_256_4);
8593 }
8594
8595 static int
8596 test_AES_GCM_auth_encryption_test_case_256_5(void)
8597 {
8598         return test_authenticated_encryption(&gcm_test_case_256_5);
8599 }
8600
8601 static int
8602 test_AES_GCM_auth_encryption_test_case_256_6(void)
8603 {
8604         return test_authenticated_encryption(&gcm_test_case_256_6);
8605 }
8606
8607 static int
8608 test_AES_GCM_auth_encryption_test_case_256_7(void)
8609 {
8610         return test_authenticated_encryption(&gcm_test_case_256_7);
8611 }
8612
8613 static int
8614 test_AES_GCM_auth_encryption_test_case_aad_1(void)
8615 {
8616         return test_authenticated_encryption(&gcm_test_case_aad_1);
8617 }
8618
8619 static int
8620 test_AES_GCM_auth_encryption_test_case_aad_2(void)
8621 {
8622         return test_authenticated_encryption(&gcm_test_case_aad_2);
8623 }
8624
8625 static int
8626 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
8627 {
8628         struct aead_test_data tdata;
8629         int res;
8630
8631         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8632         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8633         tdata.iv.data[0] += 1;
8634         res = test_authenticated_encryption(&tdata);
8635         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8636         return TEST_SUCCESS;
8637 }
8638
8639 static int
8640 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
8641 {
8642         struct aead_test_data tdata;
8643         int res;
8644
8645         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8646         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8647         tdata.plaintext.data[0] += 1;
8648         res = test_authenticated_encryption(&tdata);
8649         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8650         return TEST_SUCCESS;
8651 }
8652
8653 static int
8654 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
8655 {
8656         struct aead_test_data tdata;
8657         int res;
8658
8659         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8660         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8661         tdata.ciphertext.data[0] += 1;
8662         res = test_authenticated_encryption(&tdata);
8663         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8664         return TEST_SUCCESS;
8665 }
8666
8667 static int
8668 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
8669 {
8670         struct aead_test_data tdata;
8671         int res;
8672
8673         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8674         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8675         tdata.aad.len += 1;
8676         res = test_authenticated_encryption(&tdata);
8677         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8678         return TEST_SUCCESS;
8679 }
8680
8681 static int
8682 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
8683 {
8684         struct aead_test_data tdata;
8685         uint8_t aad[gcm_test_case_7.aad.len];
8686         int res;
8687
8688         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8689         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8690         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
8691         aad[0] += 1;
8692         tdata.aad.data = aad;
8693         res = test_authenticated_encryption(&tdata);
8694         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8695         return TEST_SUCCESS;
8696 }
8697
8698 static int
8699 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
8700 {
8701         struct aead_test_data tdata;
8702         int res;
8703
8704         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8705         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8706         tdata.auth_tag.data[0] += 1;
8707         res = test_authenticated_encryption(&tdata);
8708         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
8709         return TEST_SUCCESS;
8710 }
8711
8712 static int
8713 test_authenticated_decryption(const struct aead_test_data *tdata)
8714 {
8715         struct crypto_testsuite_params *ts_params = &testsuite_params;
8716         struct crypto_unittest_params *ut_params = &unittest_params;
8717         struct rte_cryptodev_sym_capability_idx cap_idx;
8718
8719         int retval;
8720         uint8_t *plaintext;
8721         uint32_t i;
8722
8723         /* Create AEAD session */
8724         retval = create_aead_session(ts_params->valid_devs[0],
8725                         tdata->algo,
8726                         RTE_CRYPTO_AEAD_OP_DECRYPT,
8727                         tdata->key.data, tdata->key.len,
8728                         tdata->aad.len, tdata->auth_tag.len,
8729                         tdata->iv.len);
8730         if (retval < 0)
8731                 return retval;
8732
8733         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8734         cap_idx.algo.aead = tdata->algo;
8735
8736         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
8737                         &cap_idx) == NULL) {
8738                 return -ENOTSUP;
8739         }
8740
8741         /* alloc mbuf and set payload */
8742         if (tdata->aad.len > MBUF_SIZE) {
8743                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8744                 /* Populate full size of add data */
8745                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8746                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8747         } else
8748                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8749
8750         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8751                         rte_pktmbuf_tailroom(ut_params->ibuf));
8752
8753         /* Create AEAD operation */
8754         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
8755         if (retval < 0)
8756                 return retval;
8757
8758         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8759
8760         ut_params->op->sym->m_src = ut_params->ibuf;
8761
8762         /* Process crypto operation */
8763         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8764                         ut_params->op), "failed to process sym crypto op");
8765
8766         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8767                         "crypto op processing failed");
8768
8769         if (ut_params->op->sym->m_dst)
8770                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8771                                 uint8_t *);
8772         else
8773                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8774                                 uint8_t *,
8775                                 ut_params->op->sym->cipher.data.offset);
8776
8777         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
8778
8779         /* Validate obuf */
8780         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8781                         plaintext,
8782                         tdata->plaintext.data,
8783                         tdata->plaintext.len,
8784                         "Plaintext data not as expected");
8785
8786         TEST_ASSERT_EQUAL(ut_params->op->status,
8787                         RTE_CRYPTO_OP_STATUS_SUCCESS,
8788                         "Authentication failed");
8789
8790         return 0;
8791 }
8792
8793 static int
8794 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
8795 {
8796         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
8797 }
8798
8799 static int
8800 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
8801 {
8802         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
8803 }
8804
8805 static int
8806 test_AES_GCM_authenticated_decryption_test_case_1(void)
8807 {
8808         return test_authenticated_decryption(&gcm_test_case_1);
8809 }
8810
8811 static int
8812 test_AES_GCM_authenticated_decryption_test_case_2(void)
8813 {
8814         return test_authenticated_decryption(&gcm_test_case_2);
8815 }
8816
8817 static int
8818 test_AES_GCM_authenticated_decryption_test_case_3(void)
8819 {
8820         return test_authenticated_decryption(&gcm_test_case_3);
8821 }
8822
8823 static int
8824 test_AES_GCM_authenticated_decryption_test_case_4(void)
8825 {
8826         return test_authenticated_decryption(&gcm_test_case_4);
8827 }
8828
8829 static int
8830 test_AES_GCM_authenticated_decryption_test_case_5(void)
8831 {
8832         return test_authenticated_decryption(&gcm_test_case_5);
8833 }
8834
8835 static int
8836 test_AES_GCM_authenticated_decryption_test_case_6(void)
8837 {
8838         return test_authenticated_decryption(&gcm_test_case_6);
8839 }
8840
8841 static int
8842 test_AES_GCM_authenticated_decryption_test_case_7(void)
8843 {
8844         return test_authenticated_decryption(&gcm_test_case_7);
8845 }
8846
8847 static int
8848 test_AES_GCM_authenticated_decryption_test_case_8(void)
8849 {
8850         return test_authenticated_decryption(&gcm_test_case_8);
8851 }
8852
8853 static int
8854 test_AES_GCM_auth_decryption_test_case_192_1(void)
8855 {
8856         return test_authenticated_decryption(&gcm_test_case_192_1);
8857 }
8858
8859 static int
8860 test_AES_GCM_auth_decryption_test_case_192_2(void)
8861 {
8862         return test_authenticated_decryption(&gcm_test_case_192_2);
8863 }
8864
8865 static int
8866 test_AES_GCM_auth_decryption_test_case_192_3(void)
8867 {
8868         return test_authenticated_decryption(&gcm_test_case_192_3);
8869 }
8870
8871 static int
8872 test_AES_GCM_auth_decryption_test_case_192_4(void)
8873 {
8874         return test_authenticated_decryption(&gcm_test_case_192_4);
8875 }
8876
8877 static int
8878 test_AES_GCM_auth_decryption_test_case_192_5(void)
8879 {
8880         return test_authenticated_decryption(&gcm_test_case_192_5);
8881 }
8882
8883 static int
8884 test_AES_GCM_auth_decryption_test_case_192_6(void)
8885 {
8886         return test_authenticated_decryption(&gcm_test_case_192_6);
8887 }
8888
8889 static int
8890 test_AES_GCM_auth_decryption_test_case_192_7(void)
8891 {
8892         return test_authenticated_decryption(&gcm_test_case_192_7);
8893 }
8894
8895 static int
8896 test_AES_GCM_auth_decryption_test_case_256_1(void)
8897 {
8898         return test_authenticated_decryption(&gcm_test_case_256_1);
8899 }
8900
8901 static int
8902 test_AES_GCM_auth_decryption_test_case_256_2(void)
8903 {
8904         return test_authenticated_decryption(&gcm_test_case_256_2);
8905 }
8906
8907 static int
8908 test_AES_GCM_auth_decryption_test_case_256_3(void)
8909 {
8910         return test_authenticated_decryption(&gcm_test_case_256_3);
8911 }
8912
8913 static int
8914 test_AES_GCM_auth_decryption_test_case_256_4(void)
8915 {
8916         return test_authenticated_decryption(&gcm_test_case_256_4);
8917 }
8918
8919 static int
8920 test_AES_GCM_auth_decryption_test_case_256_5(void)
8921 {
8922         return test_authenticated_decryption(&gcm_test_case_256_5);
8923 }
8924
8925 static int
8926 test_AES_GCM_auth_decryption_test_case_256_6(void)
8927 {
8928         return test_authenticated_decryption(&gcm_test_case_256_6);
8929 }
8930
8931 static int
8932 test_AES_GCM_auth_decryption_test_case_256_7(void)
8933 {
8934         return test_authenticated_decryption(&gcm_test_case_256_7);
8935 }
8936
8937 static int
8938 test_AES_GCM_auth_decryption_test_case_aad_1(void)
8939 {
8940         return test_authenticated_decryption(&gcm_test_case_aad_1);
8941 }
8942
8943 static int
8944 test_AES_GCM_auth_decryption_test_case_aad_2(void)
8945 {
8946         return test_authenticated_decryption(&gcm_test_case_aad_2);
8947 }
8948
8949 static int
8950 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
8951 {
8952         struct aead_test_data tdata;
8953         int res;
8954
8955         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8956         tdata.iv.data[0] += 1;
8957         res = test_authenticated_decryption(&tdata);
8958         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8959         return TEST_SUCCESS;
8960 }
8961
8962 static int
8963 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
8964 {
8965         struct aead_test_data tdata;
8966         int res;
8967
8968         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8969         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8970         tdata.plaintext.data[0] += 1;
8971         res = test_authenticated_decryption(&tdata);
8972         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8973         return TEST_SUCCESS;
8974 }
8975
8976 static int
8977 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
8978 {
8979         struct aead_test_data tdata;
8980         int res;
8981
8982         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8983         tdata.ciphertext.data[0] += 1;
8984         res = test_authenticated_decryption(&tdata);
8985         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8986         return TEST_SUCCESS;
8987 }
8988
8989 static int
8990 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
8991 {
8992         struct aead_test_data tdata;
8993         int res;
8994
8995         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8996         tdata.aad.len += 1;
8997         res = test_authenticated_decryption(&tdata);
8998         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8999         return TEST_SUCCESS;
9000 }
9001
9002 static int
9003 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
9004 {
9005         struct aead_test_data tdata;
9006         uint8_t aad[gcm_test_case_7.aad.len];
9007         int res;
9008
9009         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9010         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9011         aad[0] += 1;
9012         tdata.aad.data = aad;
9013         res = test_authenticated_decryption(&tdata);
9014         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9015         return TEST_SUCCESS;
9016 }
9017
9018 static int
9019 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
9020 {
9021         struct aead_test_data tdata;
9022         int res;
9023
9024         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9025         tdata.auth_tag.data[0] += 1;
9026         res = test_authenticated_decryption(&tdata);
9027         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
9028         return TEST_SUCCESS;
9029 }
9030
9031 static int
9032 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
9033 {
9034         struct crypto_testsuite_params *ts_params = &testsuite_params;
9035         struct crypto_unittest_params *ut_params = &unittest_params;
9036
9037         int retval;
9038         uint8_t *ciphertext, *auth_tag;
9039         uint16_t plaintext_pad_len;
9040
9041         /* Create AEAD session */
9042         retval = create_aead_session(ts_params->valid_devs[0],
9043                         tdata->algo,
9044                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
9045                         tdata->key.data, tdata->key.len,
9046                         tdata->aad.len, tdata->auth_tag.len,
9047                         tdata->iv.len);
9048         if (retval < 0)
9049                 return retval;
9050
9051         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9052         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9053
9054         /* clear mbuf payload */
9055         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9056                         rte_pktmbuf_tailroom(ut_params->ibuf));
9057         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
9058                         rte_pktmbuf_tailroom(ut_params->obuf));
9059
9060         /* Create AEAD operation */
9061         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
9062         if (retval < 0)
9063                 return retval;
9064
9065         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9066
9067         ut_params->op->sym->m_src = ut_params->ibuf;
9068         ut_params->op->sym->m_dst = ut_params->obuf;
9069
9070         /* Process crypto operation */
9071         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9072                         ut_params->op), "failed to process sym crypto op");
9073
9074         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9075                         "crypto op processing failed");
9076
9077         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9078
9079         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
9080                         ut_params->op->sym->cipher.data.offset);
9081         auth_tag = ciphertext + plaintext_pad_len;
9082
9083         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9084         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9085
9086         /* Validate obuf */
9087         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9088                         ciphertext,
9089                         tdata->ciphertext.data,
9090                         tdata->ciphertext.len,
9091                         "Ciphertext data not as expected");
9092
9093         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9094                         auth_tag,
9095                         tdata->auth_tag.data,
9096                         tdata->auth_tag.len,
9097                         "Generated auth tag not as expected");
9098
9099         return 0;
9100
9101 }
9102
9103 static int
9104 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
9105 {
9106         return test_authenticated_encryption_oop(&gcm_test_case_5);
9107 }
9108
9109 static int
9110 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
9111 {
9112         struct crypto_testsuite_params *ts_params = &testsuite_params;
9113         struct crypto_unittest_params *ut_params = &unittest_params;
9114
9115         int retval;
9116         uint8_t *plaintext;
9117
9118         /* Create AEAD session */
9119         retval = create_aead_session(ts_params->valid_devs[0],
9120                         tdata->algo,
9121                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9122                         tdata->key.data, tdata->key.len,
9123                         tdata->aad.len, tdata->auth_tag.len,
9124                         tdata->iv.len);
9125         if (retval < 0)
9126                 return retval;
9127
9128         /* alloc mbuf and set payload */
9129         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9130         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9131
9132         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9133                         rte_pktmbuf_tailroom(ut_params->ibuf));
9134         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
9135                         rte_pktmbuf_tailroom(ut_params->obuf));
9136
9137         /* Create AEAD operation */
9138         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9139         if (retval < 0)
9140                 return retval;
9141
9142         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9143
9144         ut_params->op->sym->m_src = ut_params->ibuf;
9145         ut_params->op->sym->m_dst = ut_params->obuf;
9146
9147         /* Process crypto operation */
9148         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9149                         ut_params->op), "failed to process sym crypto op");
9150
9151         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9152                         "crypto op processing failed");
9153
9154         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
9155                         ut_params->op->sym->cipher.data.offset);
9156
9157         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9158
9159         /* Validate obuf */
9160         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9161                         plaintext,
9162                         tdata->plaintext.data,
9163                         tdata->plaintext.len,
9164                         "Plaintext data not as expected");
9165
9166         TEST_ASSERT_EQUAL(ut_params->op->status,
9167                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9168                         "Authentication failed");
9169         return 0;
9170 }
9171
9172 static int
9173 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
9174 {
9175         return test_authenticated_decryption_oop(&gcm_test_case_5);
9176 }
9177
9178 static int
9179 test_authenticated_encryption_sessionless(
9180                 const struct aead_test_data *tdata)
9181 {
9182         struct crypto_testsuite_params *ts_params = &testsuite_params;
9183         struct crypto_unittest_params *ut_params = &unittest_params;
9184
9185         int retval;
9186         uint8_t *ciphertext, *auth_tag;
9187         uint16_t plaintext_pad_len;
9188         uint8_t key[tdata->key.len + 1];
9189
9190         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9191
9192         /* clear mbuf payload */
9193         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9194                         rte_pktmbuf_tailroom(ut_params->ibuf));
9195
9196         /* Create AEAD operation */
9197         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
9198         if (retval < 0)
9199                 return retval;
9200
9201         /* Create GCM xform */
9202         memcpy(key, tdata->key.data, tdata->key.len);
9203         retval = create_aead_xform(ut_params->op,
9204                         tdata->algo,
9205                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
9206                         key, tdata->key.len,
9207                         tdata->aad.len, tdata->auth_tag.len,
9208                         tdata->iv.len);
9209         if (retval < 0)
9210                 return retval;
9211
9212         ut_params->op->sym->m_src = ut_params->ibuf;
9213
9214         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9215                         RTE_CRYPTO_OP_SESSIONLESS,
9216                         "crypto op session type not sessionless");
9217
9218         /* Process crypto operation */
9219         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9220                         ut_params->op), "failed to process sym crypto op");
9221
9222         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9223
9224         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9225                         "crypto op status not success");
9226
9227         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9228
9229         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9230                         ut_params->op->sym->cipher.data.offset);
9231         auth_tag = ciphertext + plaintext_pad_len;
9232
9233         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9234         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9235
9236         /* Validate obuf */
9237         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9238                         ciphertext,
9239                         tdata->ciphertext.data,
9240                         tdata->ciphertext.len,
9241                         "Ciphertext data not as expected");
9242
9243         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9244                         auth_tag,
9245                         tdata->auth_tag.data,
9246                         tdata->auth_tag.len,
9247                         "Generated auth tag not as expected");
9248
9249         return 0;
9250
9251 }
9252
9253 static int
9254 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
9255 {
9256         return test_authenticated_encryption_sessionless(
9257                         &gcm_test_case_5);
9258 }
9259
9260 static int
9261 test_authenticated_decryption_sessionless(
9262                 const struct aead_test_data *tdata)
9263 {
9264         struct crypto_testsuite_params *ts_params = &testsuite_params;
9265         struct crypto_unittest_params *ut_params = &unittest_params;
9266
9267         int retval;
9268         uint8_t *plaintext;
9269         uint8_t key[tdata->key.len + 1];
9270
9271         /* alloc mbuf and set payload */
9272         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9273
9274         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9275                         rte_pktmbuf_tailroom(ut_params->ibuf));
9276
9277         /* Create AEAD operation */
9278         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9279         if (retval < 0)
9280                 return retval;
9281
9282         /* Create AEAD xform */
9283         memcpy(key, tdata->key.data, tdata->key.len);
9284         retval = create_aead_xform(ut_params->op,
9285                         tdata->algo,
9286                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9287                         key, tdata->key.len,
9288                         tdata->aad.len, tdata->auth_tag.len,
9289                         tdata->iv.len);
9290         if (retval < 0)
9291                 return retval;
9292
9293         ut_params->op->sym->m_src = ut_params->ibuf;
9294
9295         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9296                         RTE_CRYPTO_OP_SESSIONLESS,
9297                         "crypto op session type not sessionless");
9298
9299         /* Process crypto operation */
9300         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9301                         ut_params->op), "failed to process sym crypto op");
9302
9303         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9304
9305         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9306                         "crypto op status not success");
9307
9308         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9309                         ut_params->op->sym->cipher.data.offset);
9310
9311         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9312
9313         /* Validate obuf */
9314         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9315                         plaintext,
9316                         tdata->plaintext.data,
9317                         tdata->plaintext.len,
9318                         "Plaintext data not as expected");
9319
9320         TEST_ASSERT_EQUAL(ut_params->op->status,
9321                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9322                         "Authentication failed");
9323         return 0;
9324 }
9325
9326 static int
9327 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
9328 {
9329         return test_authenticated_decryption_sessionless(
9330                         &gcm_test_case_5);
9331 }
9332
9333 static int
9334 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
9335 {
9336         return test_authenticated_encryption(&ccm_test_case_128_1);
9337 }
9338
9339 static int
9340 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
9341 {
9342         return test_authenticated_encryption(&ccm_test_case_128_2);
9343 }
9344
9345 static int
9346 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
9347 {
9348         return test_authenticated_encryption(&ccm_test_case_128_3);
9349 }
9350
9351 static int
9352 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
9353 {
9354         return test_authenticated_decryption(&ccm_test_case_128_1);
9355 }
9356
9357 static int
9358 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
9359 {
9360         return test_authenticated_decryption(&ccm_test_case_128_2);
9361 }
9362
9363 static int
9364 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
9365 {
9366         return test_authenticated_decryption(&ccm_test_case_128_3);
9367 }
9368
9369 static int
9370 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
9371 {
9372         return test_authenticated_encryption(&ccm_test_case_192_1);
9373 }
9374
9375 static int
9376 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
9377 {
9378         return test_authenticated_encryption(&ccm_test_case_192_2);
9379 }
9380
9381 static int
9382 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
9383 {
9384         return test_authenticated_encryption(&ccm_test_case_192_3);
9385 }
9386
9387 static int
9388 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
9389 {
9390         return test_authenticated_decryption(&ccm_test_case_192_1);
9391 }
9392
9393 static int
9394 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
9395 {
9396         return test_authenticated_decryption(&ccm_test_case_192_2);
9397 }
9398
9399 static int
9400 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
9401 {
9402         return test_authenticated_decryption(&ccm_test_case_192_3);
9403 }
9404
9405 static int
9406 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
9407 {
9408         return test_authenticated_encryption(&ccm_test_case_256_1);
9409 }
9410
9411 static int
9412 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
9413 {
9414         return test_authenticated_encryption(&ccm_test_case_256_2);
9415 }
9416
9417 static int
9418 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
9419 {
9420         return test_authenticated_encryption(&ccm_test_case_256_3);
9421 }
9422
9423 static int
9424 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
9425 {
9426         return test_authenticated_decryption(&ccm_test_case_256_1);
9427 }
9428
9429 static int
9430 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
9431 {
9432         return test_authenticated_decryption(&ccm_test_case_256_2);
9433 }
9434
9435 static int
9436 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
9437 {
9438         return test_authenticated_decryption(&ccm_test_case_256_3);
9439 }
9440
9441 static int
9442 test_stats(void)
9443 {
9444         struct crypto_testsuite_params *ts_params = &testsuite_params;
9445         struct rte_cryptodev_stats stats;
9446         struct rte_cryptodev *dev;
9447         cryptodev_stats_get_t temp_pfn;
9448
9449         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
9450         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
9451                         &stats) == -ENODEV),
9452                 "rte_cryptodev_stats_get invalid dev failed");
9453         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
9454                 "rte_cryptodev_stats_get invalid Param failed");
9455         dev = &rte_cryptodevs[ts_params->valid_devs[0]];
9456         temp_pfn = dev->dev_ops->stats_get;
9457         dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
9458         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
9459                         == -ENOTSUP),
9460                 "rte_cryptodev_stats_get invalid Param failed");
9461         dev->dev_ops->stats_get = temp_pfn;
9462
9463         /* Test expected values */
9464         ut_setup();
9465         test_AES_CBC_HMAC_SHA1_encrypt_digest();
9466         ut_teardown();
9467         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
9468                         &stats),
9469                 "rte_cryptodev_stats_get failed");
9470         TEST_ASSERT((stats.enqueued_count == 1),
9471                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9472         TEST_ASSERT((stats.dequeued_count == 1),
9473                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9474         TEST_ASSERT((stats.enqueue_err_count == 0),
9475                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9476         TEST_ASSERT((stats.dequeue_err_count == 0),
9477                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9478
9479         /* invalid device but should ignore and not reset device stats*/
9480         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
9481         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
9482                         &stats),
9483                 "rte_cryptodev_stats_get failed");
9484         TEST_ASSERT((stats.enqueued_count == 1),
9485                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9486
9487         /* check that a valid reset clears stats */
9488         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
9489         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
9490                         &stats),
9491                                           "rte_cryptodev_stats_get failed");
9492         TEST_ASSERT((stats.enqueued_count == 0),
9493                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9494         TEST_ASSERT((stats.dequeued_count == 0),
9495                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
9496
9497         return TEST_SUCCESS;
9498 }
9499
9500 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
9501                                    struct crypto_unittest_params *ut_params,
9502                                    enum rte_crypto_auth_operation op,
9503                                    const struct HMAC_MD5_vector *test_case)
9504 {
9505         uint8_t key[64];
9506
9507         memcpy(key, test_case->key.data, test_case->key.len);
9508
9509         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9510         ut_params->auth_xform.next = NULL;
9511         ut_params->auth_xform.auth.op = op;
9512
9513         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
9514
9515         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
9516         ut_params->auth_xform.auth.key.length = test_case->key.len;
9517         ut_params->auth_xform.auth.key.data = key;
9518
9519         ut_params->sess = rte_cryptodev_sym_session_create(
9520                         ts_params->session_mpool);
9521
9522         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9523                         ut_params->sess, &ut_params->auth_xform,
9524                         ts_params->session_priv_mpool);
9525
9526         if (ut_params->sess == NULL)
9527                 return TEST_FAILED;
9528
9529         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9530
9531         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9532                         rte_pktmbuf_tailroom(ut_params->ibuf));
9533
9534         return 0;
9535 }
9536
9537 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
9538                               const struct HMAC_MD5_vector *test_case,
9539                               uint8_t **plaintext)
9540 {
9541         uint16_t plaintext_pad_len;
9542
9543         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9544
9545         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
9546                                 16);
9547
9548         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9549                         plaintext_pad_len);
9550         memcpy(*plaintext, test_case->plaintext.data,
9551                         test_case->plaintext.len);
9552
9553         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
9554                         ut_params->ibuf, MD5_DIGEST_LEN);
9555         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
9556                         "no room to append digest");
9557         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
9558                         ut_params->ibuf, plaintext_pad_len);
9559
9560         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
9561                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
9562                            test_case->auth_tag.len);
9563         }
9564
9565         sym_op->auth.data.offset = 0;
9566         sym_op->auth.data.length = test_case->plaintext.len;
9567
9568         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9569         ut_params->op->sym->m_src = ut_params->ibuf;
9570
9571         return 0;
9572 }
9573
9574 static int
9575 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
9576 {
9577         uint16_t plaintext_pad_len;
9578         uint8_t *plaintext, *auth_tag;
9579
9580         struct crypto_testsuite_params *ts_params = &testsuite_params;
9581         struct crypto_unittest_params *ut_params = &unittest_params;
9582
9583         if (MD5_HMAC_create_session(ts_params, ut_params,
9584                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
9585                 return TEST_FAILED;
9586
9587         /* Generate Crypto op data structure */
9588         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9589                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9590         TEST_ASSERT_NOT_NULL(ut_params->op,
9591                         "Failed to allocate symmetric crypto operation struct");
9592
9593         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
9594                                 16);
9595
9596         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
9597                 return TEST_FAILED;
9598
9599         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9600                         ut_params->op), "failed to process sym crypto op");
9601
9602         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9603                         "crypto op processing failed");
9604
9605         if (ut_params->op->sym->m_dst) {
9606                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
9607                                 uint8_t *, plaintext_pad_len);
9608         } else {
9609                 auth_tag = plaintext + plaintext_pad_len;
9610         }
9611
9612         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9613                         auth_tag,
9614                         test_case->auth_tag.data,
9615                         test_case->auth_tag.len,
9616                         "HMAC_MD5 generated tag not as expected");
9617
9618         return TEST_SUCCESS;
9619 }
9620
9621 static int
9622 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
9623 {
9624         uint8_t *plaintext;
9625
9626         struct crypto_testsuite_params *ts_params = &testsuite_params;
9627         struct crypto_unittest_params *ut_params = &unittest_params;
9628
9629         if (MD5_HMAC_create_session(ts_params, ut_params,
9630                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
9631                 return TEST_FAILED;
9632         }
9633
9634         /* Generate Crypto op data structure */
9635         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9636                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9637         TEST_ASSERT_NOT_NULL(ut_params->op,
9638                         "Failed to allocate symmetric crypto operation struct");
9639
9640         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
9641                 return TEST_FAILED;
9642
9643         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9644                         ut_params->op), "failed to process sym crypto op");
9645
9646         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9647                         "HMAC_MD5 crypto op processing failed");
9648
9649         return TEST_SUCCESS;
9650 }
9651
9652 static int
9653 test_MD5_HMAC_generate_case_1(void)
9654 {
9655         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
9656 }
9657
9658 static int
9659 test_MD5_HMAC_verify_case_1(void)
9660 {
9661         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
9662 }
9663
9664 static int
9665 test_MD5_HMAC_generate_case_2(void)
9666 {
9667         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
9668 }
9669
9670 static int
9671 test_MD5_HMAC_verify_case_2(void)
9672 {
9673         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
9674 }
9675
9676 static int
9677 test_multi_session(void)
9678 {
9679         struct crypto_testsuite_params *ts_params = &testsuite_params;
9680         struct crypto_unittest_params *ut_params = &unittest_params;
9681
9682         struct rte_cryptodev_info dev_info;
9683         struct rte_cryptodev_sym_session **sessions;
9684
9685         uint16_t i;
9686
9687         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
9688                         aes_cbc_key, hmac_sha512_key);
9689
9690
9691         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9692
9693         sessions = rte_malloc(NULL,
9694                         (sizeof(struct rte_cryptodev_sym_session *) *
9695                         MAX_NB_SESSIONS) + 1, 0);
9696
9697         /* Create multiple crypto sessions*/
9698         for (i = 0; i < MAX_NB_SESSIONS; i++) {
9699
9700                 sessions[i] = rte_cryptodev_sym_session_create(
9701                                 ts_params->session_mpool);
9702
9703                 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9704                                 sessions[i], &ut_params->auth_xform,
9705                                 ts_params->session_priv_mpool);
9706                 TEST_ASSERT_NOT_NULL(sessions[i],
9707                                 "Session creation failed at session number %u",
9708                                 i);
9709
9710                 /* Attempt to send a request on each session */
9711                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
9712                         sessions[i],
9713                         ut_params,
9714                         ts_params,
9715                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
9716                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
9717                         aes_cbc_iv),
9718                         "Failed to perform decrypt on request number %u.", i);
9719                 /* free crypto operation structure */
9720                 if (ut_params->op)
9721                         rte_crypto_op_free(ut_params->op);
9722
9723                 /*
9724                  * free mbuf - both obuf and ibuf are usually the same,
9725                  * so check if they point at the same address is necessary,
9726                  * to avoid freeing the mbuf twice.
9727                  */
9728                 if (ut_params->obuf) {
9729                         rte_pktmbuf_free(ut_params->obuf);
9730                         if (ut_params->ibuf == ut_params->obuf)
9731                                 ut_params->ibuf = 0;
9732                         ut_params->obuf = 0;
9733                 }
9734                 if (ut_params->ibuf) {
9735                         rte_pktmbuf_free(ut_params->ibuf);
9736                         ut_params->ibuf = 0;
9737                 }
9738         }
9739
9740         /* Next session create should fail */
9741         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9742                         sessions[i], &ut_params->auth_xform,
9743                         ts_params->session_priv_mpool);
9744         TEST_ASSERT_NULL(sessions[i],
9745                         "Session creation succeeded unexpectedly!");
9746
9747         for (i = 0; i < MAX_NB_SESSIONS; i++) {
9748                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
9749                                 sessions[i]);
9750                 rte_cryptodev_sym_session_free(sessions[i]);
9751         }
9752
9753         rte_free(sessions);
9754
9755         return TEST_SUCCESS;
9756 }
9757
9758 struct multi_session_params {
9759         struct crypto_unittest_params ut_params;
9760         uint8_t *cipher_key;
9761         uint8_t *hmac_key;
9762         const uint8_t *cipher;
9763         const uint8_t *digest;
9764         uint8_t *iv;
9765 };
9766
9767 #define MB_SESSION_NUMBER 3
9768
9769 static int
9770 test_multi_session_random_usage(void)
9771 {
9772         struct crypto_testsuite_params *ts_params = &testsuite_params;
9773         struct rte_cryptodev_info dev_info;
9774         struct rte_cryptodev_sym_session **sessions;
9775         uint32_t i, j;
9776         struct multi_session_params ut_paramz[] = {
9777
9778                 {
9779                         .cipher_key = ms_aes_cbc_key0,
9780                         .hmac_key = ms_hmac_key0,
9781                         .cipher = ms_aes_cbc_cipher0,
9782                         .digest = ms_hmac_digest0,
9783                         .iv = ms_aes_cbc_iv0
9784                 },
9785                 {
9786                         .cipher_key = ms_aes_cbc_key1,
9787                         .hmac_key = ms_hmac_key1,
9788                         .cipher = ms_aes_cbc_cipher1,
9789                         .digest = ms_hmac_digest1,
9790                         .iv = ms_aes_cbc_iv1
9791                 },
9792                 {
9793                         .cipher_key = ms_aes_cbc_key2,
9794                         .hmac_key = ms_hmac_key2,
9795                         .cipher = ms_aes_cbc_cipher2,
9796                         .digest = ms_hmac_digest2,
9797                         .iv = ms_aes_cbc_iv2
9798                 },
9799
9800         };
9801
9802         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9803
9804         sessions = rte_malloc(NULL,
9805                         (sizeof(struct rte_cryptodev_sym_session *)
9806                                         * MAX_NB_SESSIONS) + 1, 0);
9807
9808         for (i = 0; i < MB_SESSION_NUMBER; i++) {
9809                 sessions[i] = rte_cryptodev_sym_session_create(
9810                                 ts_params->session_mpool);
9811
9812                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
9813                                 sizeof(struct crypto_unittest_params));
9814
9815                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
9816                                 &ut_paramz[i].ut_params,
9817                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
9818
9819                 /* Create multiple crypto sessions*/
9820                 rte_cryptodev_sym_session_init(
9821                                 ts_params->valid_devs[0],
9822                                 sessions[i],
9823                                 &ut_paramz[i].ut_params.auth_xform,
9824                                 ts_params->session_priv_mpool);
9825
9826                 TEST_ASSERT_NOT_NULL(sessions[i],
9827                                 "Session creation failed at session number %u",
9828                                 i);
9829
9830         }
9831
9832         srand(time(NULL));
9833         for (i = 0; i < 40000; i++) {
9834
9835                 j = rand() % MB_SESSION_NUMBER;
9836
9837                 TEST_ASSERT_SUCCESS(
9838                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
9839                                         sessions[j],
9840                                         &ut_paramz[j].ut_params,
9841                                         ts_params, ut_paramz[j].cipher,
9842                                         ut_paramz[j].digest,
9843                                         ut_paramz[j].iv),
9844                         "Failed to perform decrypt on request number %u.", i);
9845
9846                 if (ut_paramz[j].ut_params.op)
9847                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
9848
9849                 /*
9850                  * free mbuf - both obuf and ibuf are usually the same,
9851                  * so check if they point at the same address is necessary,
9852                  * to avoid freeing the mbuf twice.
9853                  */
9854                 if (ut_paramz[j].ut_params.obuf) {
9855                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
9856                         if (ut_paramz[j].ut_params.ibuf
9857                                         == ut_paramz[j].ut_params.obuf)
9858                                 ut_paramz[j].ut_params.ibuf = 0;
9859                         ut_paramz[j].ut_params.obuf = 0;
9860                 }
9861                 if (ut_paramz[j].ut_params.ibuf) {
9862                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
9863                         ut_paramz[j].ut_params.ibuf = 0;
9864                 }
9865         }
9866
9867         for (i = 0; i < MB_SESSION_NUMBER; i++) {
9868                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
9869                                 sessions[i]);
9870                 rte_cryptodev_sym_session_free(sessions[i]);
9871         }
9872
9873         rte_free(sessions);
9874
9875         return TEST_SUCCESS;
9876 }
9877
9878 static int
9879 test_null_cipher_only_operation(void)
9880 {
9881         struct crypto_testsuite_params *ts_params = &testsuite_params;
9882         struct crypto_unittest_params *ut_params = &unittest_params;
9883
9884         /* Generate test mbuf data and space for digest */
9885         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
9886                         catch_22_quote, QUOTE_512_BYTES, 0);
9887
9888         /* Setup Cipher Parameters */
9889         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9890         ut_params->cipher_xform.next = NULL;
9891
9892         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
9893         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9894
9895         ut_params->sess = rte_cryptodev_sym_session_create(
9896                         ts_params->session_mpool);
9897
9898         /* Create Crypto session*/
9899         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9900                                 ut_params->sess,
9901                                 &ut_params->cipher_xform,
9902                                 ts_params->session_priv_mpool);
9903         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9904
9905         /* Generate Crypto op data structure */
9906         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9907                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9908         TEST_ASSERT_NOT_NULL(ut_params->op,
9909                         "Failed to allocate symmetric crypto operation struct");
9910
9911         /* Set crypto operation data parameters */
9912         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9913
9914         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9915
9916         /* set crypto operation source mbuf */
9917         sym_op->m_src = ut_params->ibuf;
9918
9919         sym_op->cipher.data.offset = 0;
9920         sym_op->cipher.data.length = QUOTE_512_BYTES;
9921
9922         /* Process crypto operation */
9923         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9924                         ut_params->op);
9925         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
9926
9927         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9928                         "crypto operation processing failed");
9929
9930         /* Validate obuf */
9931         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9932                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
9933                         catch_22_quote,
9934                         QUOTE_512_BYTES,
9935                         "Ciphertext data not as expected");
9936
9937         return TEST_SUCCESS;
9938 }
9939 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
9940                         0xab, 0xab, 0xab, 0xab,
9941                         0xab, 0xab, 0xab, 0xab,
9942                         0xab, 0xab, 0xab, 0xab};
9943 static int
9944 test_null_auth_only_operation(void)
9945 {
9946         struct crypto_testsuite_params *ts_params = &testsuite_params;
9947         struct crypto_unittest_params *ut_params = &unittest_params;
9948         uint8_t *digest;
9949
9950         /* Generate test mbuf data and space for digest */
9951         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
9952                         catch_22_quote, QUOTE_512_BYTES, 0);
9953
9954         /* create a pointer for digest, but don't expect anything to be written
9955          * here in a NULL auth algo so no mbuf append done.
9956          */
9957         digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9958                         QUOTE_512_BYTES);
9959         /* prefill the memory pointed to by digest */
9960         memcpy(digest, orig_data, sizeof(orig_data));
9961
9962         /* Setup HMAC Parameters */
9963         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9964         ut_params->auth_xform.next = NULL;
9965
9966         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
9967         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
9968
9969         ut_params->sess = rte_cryptodev_sym_session_create(
9970                         ts_params->session_mpool);
9971
9972         /* Create Crypto session*/
9973         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9974                         ut_params->sess, &ut_params->auth_xform,
9975                         ts_params->session_priv_mpool);
9976         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9977
9978         /* Generate Crypto op data structure */
9979         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9980                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9981         TEST_ASSERT_NOT_NULL(ut_params->op,
9982                         "Failed to allocate symmetric crypto operation struct");
9983
9984         /* Set crypto operation data parameters */
9985         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9986
9987         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9988
9989         sym_op->m_src = ut_params->ibuf;
9990
9991         sym_op->auth.data.offset = 0;
9992         sym_op->auth.data.length = QUOTE_512_BYTES;
9993         sym_op->auth.digest.data = digest;
9994         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
9995                         QUOTE_512_BYTES);
9996
9997         /* Process crypto operation */
9998         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9999                         ut_params->op);
10000         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
10001
10002         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10003                         "crypto operation processing failed");
10004         /* Make sure memory pointed to by digest hasn't been overwritten */
10005         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10006                         orig_data,
10007                         digest,
10008                         sizeof(orig_data),
10009                         "Memory at digest ptr overwritten unexpectedly");
10010
10011         return TEST_SUCCESS;
10012 }
10013
10014
10015 static int
10016 test_null_cipher_auth_operation(void)
10017 {
10018         struct crypto_testsuite_params *ts_params = &testsuite_params;
10019         struct crypto_unittest_params *ut_params = &unittest_params;
10020         uint8_t *digest;
10021
10022         /* Generate test mbuf data and space for digest */
10023         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
10024                         catch_22_quote, QUOTE_512_BYTES, 0);
10025
10026         /* create a pointer for digest, but don't expect anything to be written
10027          * here in a NULL auth algo so no mbuf append done.
10028          */
10029         digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10030                         QUOTE_512_BYTES);
10031         /* prefill the memory pointed to by digest */
10032         memcpy(digest, orig_data, sizeof(orig_data));
10033
10034         /* Setup Cipher Parameters */
10035         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10036         ut_params->cipher_xform.next = &ut_params->auth_xform;
10037
10038         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
10039         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10040
10041         /* Setup HMAC Parameters */
10042         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10043         ut_params->auth_xform.next = NULL;
10044
10045         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
10046         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10047
10048         ut_params->sess = rte_cryptodev_sym_session_create(
10049                         ts_params->session_mpool);
10050
10051         /* Create Crypto session*/
10052         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10053                         ut_params->sess, &ut_params->cipher_xform,
10054                         ts_params->session_priv_mpool);
10055         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10056
10057         /* Generate Crypto op data structure */
10058         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10059                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10060         TEST_ASSERT_NOT_NULL(ut_params->op,
10061                         "Failed to allocate symmetric crypto operation struct");
10062
10063         /* Set crypto operation data parameters */
10064         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10065
10066         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10067
10068         sym_op->m_src = ut_params->ibuf;
10069
10070         sym_op->cipher.data.offset = 0;
10071         sym_op->cipher.data.length = QUOTE_512_BYTES;
10072
10073         sym_op->auth.data.offset = 0;
10074         sym_op->auth.data.length = QUOTE_512_BYTES;
10075         sym_op->auth.digest.data = digest;
10076         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
10077                         QUOTE_512_BYTES);
10078
10079         /* Process crypto operation */
10080         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
10081                         ut_params->op);
10082         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
10083
10084         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10085                         "crypto operation processing failed");
10086
10087         /* Validate obuf */
10088         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10089                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
10090                         catch_22_quote,
10091                         QUOTE_512_BYTES,
10092                         "Ciphertext data not as expected");
10093         /* Make sure memory pointed to by digest hasn't been overwritten */
10094         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10095                         orig_data,
10096                         digest,
10097                         sizeof(orig_data),
10098                         "Memory at digest ptr overwritten unexpectedly");
10099
10100         return TEST_SUCCESS;
10101 }
10102
10103 static int
10104 test_null_auth_cipher_operation(void)
10105 {
10106         struct crypto_testsuite_params *ts_params = &testsuite_params;
10107         struct crypto_unittest_params *ut_params = &unittest_params;
10108         uint8_t *digest;
10109
10110         /* Generate test mbuf data */
10111         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
10112                         catch_22_quote, QUOTE_512_BYTES, 0);
10113
10114         /* create a pointer for digest, but don't expect anything to be written
10115          * here in a NULL auth algo so no mbuf append done.
10116          */
10117         digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10118                                 QUOTE_512_BYTES);
10119         /* prefill the memory pointed to by digest */
10120         memcpy(digest, orig_data, sizeof(orig_data));
10121
10122         /* Setup Cipher Parameters */
10123         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10124         ut_params->cipher_xform.next = NULL;
10125
10126         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
10127         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10128
10129         /* Setup HMAC Parameters */
10130         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10131         ut_params->auth_xform.next = &ut_params->cipher_xform;
10132
10133         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
10134         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10135
10136         ut_params->sess = rte_cryptodev_sym_session_create(
10137                         ts_params->session_mpool);
10138
10139         /* Create Crypto session*/
10140         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10141                         ut_params->sess, &ut_params->cipher_xform,
10142                         ts_params->session_priv_mpool);
10143         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10144
10145         /* Generate Crypto op data structure */
10146         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10147                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10148         TEST_ASSERT_NOT_NULL(ut_params->op,
10149                         "Failed to allocate symmetric crypto operation struct");
10150
10151         /* Set crypto operation data parameters */
10152         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10153
10154         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10155
10156         sym_op->m_src = ut_params->ibuf;
10157
10158         sym_op->cipher.data.offset = 0;
10159         sym_op->cipher.data.length = QUOTE_512_BYTES;
10160
10161         sym_op->auth.data.offset = 0;
10162         sym_op->auth.data.length = QUOTE_512_BYTES;
10163         sym_op->auth.digest.data = digest;
10164         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
10165                                         QUOTE_512_BYTES);
10166
10167         /* Process crypto operation */
10168         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
10169                         ut_params->op);
10170         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
10171
10172         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10173                         "crypto operation processing failed");
10174
10175         /* Validate obuf */
10176         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10177                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
10178                         catch_22_quote,
10179                         QUOTE_512_BYTES,
10180                         "Ciphertext data not as expected");
10181         /* Make sure memory pointed to by digest hasn't been overwritten */
10182         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10183                         orig_data,
10184                         digest,
10185                         sizeof(orig_data),
10186                         "Memory at digest ptr overwritten unexpectedly");
10187
10188         return TEST_SUCCESS;
10189 }
10190
10191
10192 static int
10193 test_null_invalid_operation(void)
10194 {
10195         struct crypto_testsuite_params *ts_params = &testsuite_params;
10196         struct crypto_unittest_params *ut_params = &unittest_params;
10197         int ret;
10198
10199         /* Setup Cipher Parameters */
10200         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10201         ut_params->cipher_xform.next = NULL;
10202
10203         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
10204         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10205
10206         ut_params->sess = rte_cryptodev_sym_session_create(
10207                         ts_params->session_mpool);
10208
10209         /* Create Crypto session*/
10210         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10211                         ut_params->sess, &ut_params->cipher_xform,
10212                         ts_params->session_priv_mpool);
10213         TEST_ASSERT(ret < 0,
10214                         "Session creation succeeded unexpectedly");
10215
10216
10217         /* Setup HMAC Parameters */
10218         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10219         ut_params->auth_xform.next = NULL;
10220
10221         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
10222         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10223
10224         ut_params->sess = rte_cryptodev_sym_session_create(
10225                         ts_params->session_mpool);
10226
10227         /* Create Crypto session*/
10228         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10229                         ut_params->sess, &ut_params->auth_xform,
10230                         ts_params->session_priv_mpool);
10231         TEST_ASSERT(ret < 0,
10232                         "Session creation succeeded unexpectedly");
10233
10234         return TEST_SUCCESS;
10235 }
10236
10237
10238 #define NULL_BURST_LENGTH (32)
10239
10240 static int
10241 test_null_burst_operation(void)
10242 {
10243         struct crypto_testsuite_params *ts_params = &testsuite_params;
10244         struct crypto_unittest_params *ut_params = &unittest_params;
10245
10246         unsigned i, burst_len = NULL_BURST_LENGTH;
10247
10248         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
10249         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
10250
10251         /* Setup Cipher Parameters */
10252         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10253         ut_params->cipher_xform.next = &ut_params->auth_xform;
10254
10255         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
10256         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10257
10258         /* Setup HMAC Parameters */
10259         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10260         ut_params->auth_xform.next = NULL;
10261
10262         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
10263         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10264
10265         ut_params->sess = rte_cryptodev_sym_session_create(
10266                         ts_params->session_mpool);
10267
10268         /* Create Crypto session*/
10269         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10270                         ut_params->sess, &ut_params->cipher_xform,
10271                         ts_params->session_priv_mpool);
10272         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10273
10274         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
10275                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
10276                         burst_len, "failed to generate burst of crypto ops");
10277
10278         /* Generate an operation for each mbuf in burst */
10279         for (i = 0; i < burst_len; i++) {
10280                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10281
10282                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
10283
10284                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
10285                                 sizeof(unsigned));
10286                 *data = i;
10287
10288                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
10289
10290                 burst[i]->sym->m_src = m;
10291         }
10292
10293         /* Process crypto operation */
10294         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
10295                         0, burst, burst_len),
10296                         burst_len,
10297                         "Error enqueuing burst");
10298
10299         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
10300                         0, burst_dequeued, burst_len),
10301                         burst_len,
10302                         "Error dequeuing burst");
10303
10304
10305         for (i = 0; i < burst_len; i++) {
10306                 TEST_ASSERT_EQUAL(
10307                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
10308                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
10309                                         uint32_t *),
10310                         "data not as expected");
10311
10312                 rte_pktmbuf_free(burst[i]->sym->m_src);
10313                 rte_crypto_op_free(burst[i]);
10314         }
10315
10316         return TEST_SUCCESS;
10317 }
10318
10319 static void
10320 generate_gmac_large_plaintext(uint8_t *data)
10321 {
10322         uint16_t i;
10323
10324         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
10325                 memcpy(&data[i], &data[0], 32);
10326 }
10327
10328 static int
10329 create_gmac_operation(enum rte_crypto_auth_operation op,
10330                 const struct gmac_test_data *tdata)
10331 {
10332         struct crypto_testsuite_params *ts_params = &testsuite_params;
10333         struct crypto_unittest_params *ut_params = &unittest_params;
10334         struct rte_crypto_sym_op *sym_op;
10335
10336         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10337
10338         /* Generate Crypto op data structure */
10339         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10340                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10341         TEST_ASSERT_NOT_NULL(ut_params->op,
10342                         "Failed to allocate symmetric crypto operation struct");
10343
10344         sym_op = ut_params->op->sym;
10345
10346         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10347                         ut_params->ibuf, tdata->gmac_tag.len);
10348         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10349                         "no room to append digest");
10350
10351         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10352                         ut_params->ibuf, plaintext_pad_len);
10353
10354         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10355                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
10356                                 tdata->gmac_tag.len);
10357                 debug_hexdump(stdout, "digest:",
10358                                 sym_op->auth.digest.data,
10359                                 tdata->gmac_tag.len);
10360         }
10361
10362         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
10363                         uint8_t *, IV_OFFSET);
10364
10365         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
10366
10367         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
10368
10369         sym_op->cipher.data.length = 0;
10370         sym_op->cipher.data.offset = 0;
10371
10372         sym_op->auth.data.offset = 0;
10373         sym_op->auth.data.length = tdata->plaintext.len;
10374
10375         return 0;
10376 }
10377
10378 static int create_gmac_session(uint8_t dev_id,
10379                 const struct gmac_test_data *tdata,
10380                 enum rte_crypto_auth_operation auth_op)
10381 {
10382         uint8_t auth_key[tdata->key.len];
10383
10384         struct crypto_testsuite_params *ts_params = &testsuite_params;
10385         struct crypto_unittest_params *ut_params = &unittest_params;
10386
10387         memcpy(auth_key, tdata->key.data, tdata->key.len);
10388
10389         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10390         ut_params->auth_xform.next = NULL;
10391
10392         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
10393         ut_params->auth_xform.auth.op = auth_op;
10394         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
10395         ut_params->auth_xform.auth.key.length = tdata->key.len;
10396         ut_params->auth_xform.auth.key.data = auth_key;
10397         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
10398         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
10399
10400
10401         ut_params->sess = rte_cryptodev_sym_session_create(
10402                         ts_params->session_mpool);
10403
10404         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
10405                         &ut_params->auth_xform,
10406                         ts_params->session_priv_mpool);
10407
10408         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10409
10410         return 0;
10411 }
10412
10413 static int
10414 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
10415 {
10416         struct crypto_testsuite_params *ts_params = &testsuite_params;
10417         struct crypto_unittest_params *ut_params = &unittest_params;
10418
10419         int retval;
10420
10421         uint8_t *auth_tag, *plaintext;
10422         uint16_t plaintext_pad_len;
10423
10424         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
10425                               "No GMAC length in the source data");
10426
10427         retval = create_gmac_session(ts_params->valid_devs[0],
10428                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
10429
10430         if (retval < 0)
10431                 return retval;
10432
10433         if (tdata->plaintext.len > MBUF_SIZE)
10434                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10435         else
10436                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10437         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10438                         "Failed to allocate input buffer in mempool");
10439
10440         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10441                         rte_pktmbuf_tailroom(ut_params->ibuf));
10442
10443         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10444         /*
10445          * Runtime generate the large plain text instead of use hard code
10446          * plain text vector. It is done to avoid create huge source file
10447          * with the test vector.
10448          */
10449         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
10450                 generate_gmac_large_plaintext(tdata->plaintext.data);
10451
10452         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10453                                 plaintext_pad_len);
10454         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
10455
10456         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
10457         debug_hexdump(stdout, "plaintext:", plaintext,
10458                         tdata->plaintext.len);
10459
10460         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
10461                         tdata);
10462
10463         if (retval < 0)
10464                 return retval;
10465
10466         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10467
10468         ut_params->op->sym->m_src = ut_params->ibuf;
10469
10470         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10471                         ut_params->op), "failed to process sym crypto op");
10472
10473         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10474                         "crypto op processing failed");
10475
10476         if (ut_params->op->sym->m_dst) {
10477                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10478                                 uint8_t *, plaintext_pad_len);
10479         } else {
10480                 auth_tag = plaintext + plaintext_pad_len;
10481         }
10482
10483         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
10484
10485         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10486                         auth_tag,
10487                         tdata->gmac_tag.data,
10488                         tdata->gmac_tag.len,
10489                         "GMAC Generated auth tag not as expected");
10490
10491         return 0;
10492 }
10493
10494 static int
10495 test_AES_GMAC_authentication_test_case_1(void)
10496 {
10497         return test_AES_GMAC_authentication(&gmac_test_case_1);
10498 }
10499
10500 static int
10501 test_AES_GMAC_authentication_test_case_2(void)
10502 {
10503         return test_AES_GMAC_authentication(&gmac_test_case_2);
10504 }
10505
10506 static int
10507 test_AES_GMAC_authentication_test_case_3(void)
10508 {
10509         return test_AES_GMAC_authentication(&gmac_test_case_3);
10510 }
10511
10512 static int
10513 test_AES_GMAC_authentication_test_case_4(void)
10514 {
10515         return test_AES_GMAC_authentication(&gmac_test_case_4);
10516 }
10517
10518 static int
10519 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
10520 {
10521         struct crypto_testsuite_params *ts_params = &testsuite_params;
10522         struct crypto_unittest_params *ut_params = &unittest_params;
10523         int retval;
10524         uint32_t plaintext_pad_len;
10525         uint8_t *plaintext;
10526
10527         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
10528                               "No GMAC length in the source data");
10529
10530         retval = create_gmac_session(ts_params->valid_devs[0],
10531                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
10532
10533         if (retval < 0)
10534                 return retval;
10535
10536         if (tdata->plaintext.len > MBUF_SIZE)
10537                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10538         else
10539                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10540         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10541                         "Failed to allocate input buffer in mempool");
10542
10543         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10544                         rte_pktmbuf_tailroom(ut_params->ibuf));
10545
10546         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10547
10548         /*
10549          * Runtime generate the large plain text instead of use hard code
10550          * plain text vector. It is done to avoid create huge source file
10551          * with the test vector.
10552          */
10553         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
10554                 generate_gmac_large_plaintext(tdata->plaintext.data);
10555
10556         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10557                                 plaintext_pad_len);
10558         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
10559
10560         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
10561         debug_hexdump(stdout, "plaintext:", plaintext,
10562                         tdata->plaintext.len);
10563
10564         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
10565                         tdata);
10566
10567         if (retval < 0)
10568                 return retval;
10569
10570         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10571
10572         ut_params->op->sym->m_src = ut_params->ibuf;
10573
10574         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10575                         ut_params->op), "failed to process sym crypto op");
10576
10577         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10578                         "crypto op processing failed");
10579
10580         return 0;
10581
10582 }
10583
10584 static int
10585 test_AES_GMAC_authentication_verify_test_case_1(void)
10586 {
10587         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
10588 }
10589
10590 static int
10591 test_AES_GMAC_authentication_verify_test_case_2(void)
10592 {
10593         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
10594 }
10595
10596 static int
10597 test_AES_GMAC_authentication_verify_test_case_3(void)
10598 {
10599         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
10600 }
10601
10602 static int
10603 test_AES_GMAC_authentication_verify_test_case_4(void)
10604 {
10605         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
10606 }
10607
10608 struct test_crypto_vector {
10609         enum rte_crypto_cipher_algorithm crypto_algo;
10610         unsigned int cipher_offset;
10611         unsigned int cipher_len;
10612
10613         struct {
10614                 uint8_t data[64];
10615                 unsigned int len;
10616         } cipher_key;
10617
10618         struct {
10619                 uint8_t data[64];
10620                 unsigned int len;
10621         } iv;
10622
10623         struct {
10624                 const uint8_t *data;
10625                 unsigned int len;
10626         } plaintext;
10627
10628         struct {
10629                 const uint8_t *data;
10630                 unsigned int len;
10631         } ciphertext;
10632
10633         enum rte_crypto_auth_algorithm auth_algo;
10634         unsigned int auth_offset;
10635
10636         struct {
10637                 uint8_t data[128];
10638                 unsigned int len;
10639         } auth_key;
10640
10641         struct {
10642                 const uint8_t *data;
10643                 unsigned int len;
10644         } aad;
10645
10646         struct {
10647                 uint8_t data[128];
10648                 unsigned int len;
10649         } digest;
10650 };
10651
10652 static const struct test_crypto_vector
10653 hmac_sha1_test_crypto_vector = {
10654         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
10655         .plaintext = {
10656                 .data = plaintext_hash,
10657                 .len = 512
10658         },
10659         .auth_key = {
10660                 .data = {
10661                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
10662                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
10663                         0xDE, 0xF4, 0xDE, 0xAD
10664                 },
10665                 .len = 20
10666         },
10667         .digest = {
10668                 .data = {
10669                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
10670                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
10671                         0x3F, 0x91, 0x64, 0x59
10672                 },
10673                 .len = 20
10674         }
10675 };
10676
10677 static const struct test_crypto_vector
10678 aes128_gmac_test_vector = {
10679         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
10680         .plaintext = {
10681                 .data = plaintext_hash,
10682                 .len = 512
10683         },
10684         .iv = {
10685                 .data = {
10686                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
10687                         0x08, 0x09, 0x0A, 0x0B
10688                 },
10689                 .len = 12
10690         },
10691         .auth_key = {
10692                 .data = {
10693                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
10694                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
10695                 },
10696                 .len = 16
10697         },
10698         .digest = {
10699                 .data = {
10700                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
10701                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
10702                 },
10703                 .len = 16
10704         }
10705 };
10706
10707 static const struct test_crypto_vector
10708 aes128cbc_hmac_sha1_test_vector = {
10709         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
10710         .cipher_offset = 0,
10711         .cipher_len = 512,
10712         .cipher_key = {
10713                 .data = {
10714                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
10715                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
10716                 },
10717                 .len = 16
10718         },
10719         .iv = {
10720                 .data = {
10721                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
10722                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
10723                 },
10724                 .len = 16
10725         },
10726         .plaintext = {
10727                 .data = plaintext_hash,
10728                 .len = 512
10729         },
10730         .ciphertext = {
10731                 .data = ciphertext512_aes128cbc,
10732                 .len = 512
10733         },
10734         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
10735         .auth_offset = 0,
10736         .auth_key = {
10737                 .data = {
10738                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
10739                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
10740                         0xDE, 0xF4, 0xDE, 0xAD
10741                 },
10742                 .len = 20
10743         },
10744         .digest = {
10745                 .data = {
10746                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
10747                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
10748                         0x18, 0x8C, 0x1D, 0x32
10749                 },
10750                 .len = 20
10751         }
10752 };
10753
10754 static const struct test_crypto_vector
10755 aes128cbc_hmac_sha1_aad_test_vector = {
10756         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
10757         .cipher_offset = 12,
10758         .cipher_len = 496,
10759         .cipher_key = {
10760                 .data = {
10761                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
10762                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
10763                 },
10764                 .len = 16
10765         },
10766         .iv = {
10767                 .data = {
10768                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
10769                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
10770                 },
10771                 .len = 16
10772         },
10773         .plaintext = {
10774                 .data = plaintext_hash,
10775                 .len = 512
10776         },
10777         .ciphertext = {
10778                 .data = ciphertext512_aes128cbc_aad,
10779                 .len = 512
10780         },
10781         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
10782         .auth_offset = 0,
10783         .auth_key = {
10784                 .data = {
10785                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
10786                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
10787                         0xDE, 0xF4, 0xDE, 0xAD
10788                 },
10789                 .len = 20
10790         },
10791         .digest = {
10792                 .data = {
10793                         0x1F, 0x6A, 0xD2, 0x8B, 0x4B, 0xB3, 0xC0, 0x9E,
10794                         0x86, 0x9B, 0x3A, 0xF2, 0x00, 0x5B, 0x4F, 0x08,
10795                         0x62, 0x8D, 0x62, 0x65
10796                 },
10797                 .len = 20
10798         }
10799 };
10800
10801 static void
10802 data_corruption(uint8_t *data)
10803 {
10804         data[0] += 1;
10805 }
10806
10807 static void
10808 tag_corruption(uint8_t *data, unsigned int tag_offset)
10809 {
10810         data[tag_offset] += 1;
10811 }
10812
10813 static int
10814 create_auth_session(struct crypto_unittest_params *ut_params,
10815                 uint8_t dev_id,
10816                 const struct test_crypto_vector *reference,
10817                 enum rte_crypto_auth_operation auth_op)
10818 {
10819         struct crypto_testsuite_params *ts_params = &testsuite_params;
10820         uint8_t auth_key[reference->auth_key.len + 1];
10821
10822         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
10823
10824         /* Setup Authentication Parameters */
10825         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10826         ut_params->auth_xform.auth.op = auth_op;
10827         ut_params->auth_xform.next = NULL;
10828         ut_params->auth_xform.auth.algo = reference->auth_algo;
10829         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
10830         ut_params->auth_xform.auth.key.data = auth_key;
10831         ut_params->auth_xform.auth.digest_length = reference->digest.len;
10832
10833         /* Create Crypto session*/
10834         ut_params->sess = rte_cryptodev_sym_session_create(
10835                         ts_params->session_mpool);
10836
10837         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
10838                                 &ut_params->auth_xform,
10839                                 ts_params->session_priv_mpool);
10840
10841         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10842
10843         return 0;
10844 }
10845
10846 static int
10847 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
10848                 uint8_t dev_id,
10849                 const struct test_crypto_vector *reference,
10850                 enum rte_crypto_auth_operation auth_op,
10851                 enum rte_crypto_cipher_operation cipher_op)
10852 {
10853         struct crypto_testsuite_params *ts_params = &testsuite_params;
10854         uint8_t cipher_key[reference->cipher_key.len + 1];
10855         uint8_t auth_key[reference->auth_key.len + 1];
10856
10857         memcpy(cipher_key, reference->cipher_key.data,
10858                         reference->cipher_key.len);
10859         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
10860
10861         /* Setup Authentication Parameters */
10862         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10863         ut_params->auth_xform.auth.op = auth_op;
10864         ut_params->auth_xform.auth.algo = reference->auth_algo;
10865         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
10866         ut_params->auth_xform.auth.key.data = auth_key;
10867         ut_params->auth_xform.auth.digest_length = reference->digest.len;
10868
10869         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
10870                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
10871                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
10872         } else {
10873                 ut_params->auth_xform.next = &ut_params->cipher_xform;
10874
10875                 /* Setup Cipher Parameters */
10876                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10877                 ut_params->cipher_xform.next = NULL;
10878                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
10879                 ut_params->cipher_xform.cipher.op = cipher_op;
10880                 ut_params->cipher_xform.cipher.key.data = cipher_key;
10881                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
10882                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10883                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
10884         }
10885
10886         /* Create Crypto session*/
10887         ut_params->sess = rte_cryptodev_sym_session_create(
10888                         ts_params->session_mpool);
10889
10890         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
10891                                 &ut_params->auth_xform,
10892                                 ts_params->session_priv_mpool);
10893
10894         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10895
10896         return 0;
10897 }
10898
10899 static int
10900 create_auth_operation(struct crypto_testsuite_params *ts_params,
10901                 struct crypto_unittest_params *ut_params,
10902                 const struct test_crypto_vector *reference,
10903                 unsigned int auth_generate)
10904 {
10905         /* Generate Crypto op data structure */
10906         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10907                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10908         TEST_ASSERT_NOT_NULL(ut_params->op,
10909                         "Failed to allocate pktmbuf offload");
10910
10911         /* Set crypto operation data parameters */
10912         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10913
10914         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10915
10916         /* set crypto operation source mbuf */
10917         sym_op->m_src = ut_params->ibuf;
10918
10919         /* digest */
10920         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10921                         ut_params->ibuf, reference->digest.len);
10922
10923         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10924                         "no room to append auth tag");
10925
10926         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10927                         ut_params->ibuf, reference->plaintext.len);
10928
10929         if (auth_generate)
10930                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
10931         else
10932                 memcpy(sym_op->auth.digest.data,
10933                                 reference->digest.data,
10934                                 reference->digest.len);
10935
10936         debug_hexdump(stdout, "digest:",
10937                         sym_op->auth.digest.data,
10938                         reference->digest.len);
10939
10940         sym_op->auth.data.length = reference->plaintext.len;
10941         sym_op->auth.data.offset = 0;
10942
10943         return 0;
10944 }
10945
10946 static int
10947 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
10948                 struct crypto_unittest_params *ut_params,
10949                 const struct test_crypto_vector *reference,
10950                 unsigned int auth_generate)
10951 {
10952         /* Generate Crypto op data structure */
10953         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10954                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10955         TEST_ASSERT_NOT_NULL(ut_params->op,
10956                         "Failed to allocate pktmbuf offload");
10957
10958         /* Set crypto operation data parameters */
10959         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10960
10961         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10962
10963         /* set crypto operation source mbuf */
10964         sym_op->m_src = ut_params->ibuf;
10965
10966         /* digest */
10967         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10968                         ut_params->ibuf, reference->digest.len);
10969
10970         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10971                         "no room to append auth tag");
10972
10973         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10974                         ut_params->ibuf, reference->ciphertext.len);
10975
10976         if (auth_generate)
10977                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
10978         else
10979                 memcpy(sym_op->auth.digest.data,
10980                                 reference->digest.data,
10981                                 reference->digest.len);
10982
10983         debug_hexdump(stdout, "digest:",
10984                         sym_op->auth.digest.data,
10985                         reference->digest.len);
10986
10987         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
10988                         reference->iv.data, reference->iv.len);
10989
10990         sym_op->cipher.data.length = 0;
10991         sym_op->cipher.data.offset = 0;
10992
10993         sym_op->auth.data.length = reference->plaintext.len;
10994         sym_op->auth.data.offset = 0;
10995
10996         return 0;
10997 }
10998
10999 static int
11000 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
11001                 struct crypto_unittest_params *ut_params,
11002                 const struct test_crypto_vector *reference,
11003                 unsigned int auth_generate)
11004 {
11005         /* Generate Crypto op data structure */
11006         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11007                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11008         TEST_ASSERT_NOT_NULL(ut_params->op,
11009                         "Failed to allocate pktmbuf offload");
11010
11011         /* Set crypto operation data parameters */
11012         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11013
11014         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11015
11016         /* set crypto operation source mbuf */
11017         sym_op->m_src = ut_params->ibuf;
11018
11019         /* digest */
11020         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11021                         ut_params->ibuf, reference->digest.len);
11022
11023         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11024                         "no room to append auth tag");
11025
11026         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11027                         ut_params->ibuf, reference->ciphertext.len);
11028
11029         if (auth_generate)
11030                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11031         else
11032                 memcpy(sym_op->auth.digest.data,
11033                                 reference->digest.data,
11034                                 reference->digest.len);
11035
11036         debug_hexdump(stdout, "digest:",
11037                         sym_op->auth.digest.data,
11038                         reference->digest.len);
11039
11040         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
11041                         reference->iv.data, reference->iv.len);
11042
11043         sym_op->cipher.data.length = reference->cipher_len;
11044         sym_op->cipher.data.offset = reference->cipher_offset;
11045
11046         sym_op->auth.data.length = reference->plaintext.len;
11047         sym_op->auth.data.offset = reference->auth_offset;
11048
11049         return 0;
11050 }
11051
11052 static int
11053 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11054                 struct crypto_unittest_params *ut_params,
11055                 const struct test_crypto_vector *reference)
11056 {
11057         return create_auth_operation(ts_params, ut_params, reference, 0);
11058 }
11059
11060 static int
11061 create_auth_verify_GMAC_operation(
11062                 struct crypto_testsuite_params *ts_params,
11063                 struct crypto_unittest_params *ut_params,
11064                 const struct test_crypto_vector *reference)
11065 {
11066         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
11067 }
11068
11069 static int
11070 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11071                 struct crypto_unittest_params *ut_params,
11072                 const struct test_crypto_vector *reference)
11073 {
11074         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
11075 }
11076
11077 static int
11078 test_authentication_verify_fail_when_data_corruption(
11079                 struct crypto_testsuite_params *ts_params,
11080                 struct crypto_unittest_params *ut_params,
11081                 const struct test_crypto_vector *reference,
11082                 unsigned int data_corrupted)
11083 {
11084         int retval;
11085
11086         uint8_t *plaintext;
11087
11088         /* Create session */
11089         retval = create_auth_session(ut_params,
11090                         ts_params->valid_devs[0],
11091                         reference,
11092                         RTE_CRYPTO_AUTH_OP_VERIFY);
11093         if (retval < 0)
11094                 return retval;
11095
11096         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11097         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11098                         "Failed to allocate input buffer in mempool");
11099
11100         /* clear mbuf payload */
11101         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11102                         rte_pktmbuf_tailroom(ut_params->ibuf));
11103
11104         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11105                         reference->plaintext.len);
11106         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11107         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11108
11109         debug_hexdump(stdout, "plaintext:", plaintext,
11110                 reference->plaintext.len);
11111
11112         /* Create operation */
11113         retval = create_auth_verify_operation(ts_params, ut_params, reference);
11114
11115         if (retval < 0)
11116                 return retval;
11117
11118         if (data_corrupted)
11119                 data_corruption(plaintext);
11120         else
11121                 tag_corruption(plaintext, reference->plaintext.len);
11122
11123         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11124                         ut_params->op);
11125
11126         TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11127
11128         return 0;
11129 }
11130
11131 static int
11132 test_authentication_verify_GMAC_fail_when_corruption(
11133                 struct crypto_testsuite_params *ts_params,
11134                 struct crypto_unittest_params *ut_params,
11135                 const struct test_crypto_vector *reference,
11136                 unsigned int data_corrupted)
11137 {
11138         int retval;
11139         uint8_t *plaintext;
11140
11141         /* Create session */
11142         retval = create_auth_cipher_session(ut_params,
11143                         ts_params->valid_devs[0],
11144                         reference,
11145                         RTE_CRYPTO_AUTH_OP_VERIFY,
11146                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
11147         if (retval < 0)
11148                 return retval;
11149
11150         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11151         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11152                         "Failed to allocate input buffer in mempool");
11153
11154         /* clear mbuf payload */
11155         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11156                         rte_pktmbuf_tailroom(ut_params->ibuf));
11157
11158         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11159                         reference->plaintext.len);
11160         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11161         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11162
11163         debug_hexdump(stdout, "plaintext:", plaintext,
11164                 reference->plaintext.len);
11165
11166         /* Create operation */
11167         retval = create_auth_verify_GMAC_operation(ts_params,
11168                         ut_params,
11169                         reference);
11170
11171         if (retval < 0)
11172                 return retval;
11173
11174         if (data_corrupted)
11175                 data_corruption(plaintext);
11176         else
11177                 tag_corruption(plaintext, reference->aad.len);
11178
11179         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11180                         ut_params->op);
11181
11182         TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11183
11184         return 0;
11185 }
11186
11187 static int
11188 test_authenticated_decryption_fail_when_corruption(
11189                 struct crypto_testsuite_params *ts_params,
11190                 struct crypto_unittest_params *ut_params,
11191                 const struct test_crypto_vector *reference,
11192                 unsigned int data_corrupted)
11193 {
11194         int retval;
11195
11196         uint8_t *ciphertext;
11197
11198         /* Create session */
11199         retval = create_auth_cipher_session(ut_params,
11200                         ts_params->valid_devs[0],
11201                         reference,
11202                         RTE_CRYPTO_AUTH_OP_VERIFY,
11203                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
11204         if (retval < 0)
11205                 return retval;
11206
11207         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11208         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11209                         "Failed to allocate input buffer in mempool");
11210
11211         /* clear mbuf payload */
11212         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11213                         rte_pktmbuf_tailroom(ut_params->ibuf));
11214
11215         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11216                         reference->ciphertext.len);
11217         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
11218         memcpy(ciphertext, reference->ciphertext.data,
11219                         reference->ciphertext.len);
11220
11221         /* Create operation */
11222         retval = create_cipher_auth_verify_operation(ts_params,
11223                         ut_params,
11224                         reference);
11225
11226         if (retval < 0)
11227                 return retval;
11228
11229         if (data_corrupted)
11230                 data_corruption(ciphertext);
11231         else
11232                 tag_corruption(ciphertext, reference->ciphertext.len);
11233
11234         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11235                         ut_params->op);
11236
11237         TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11238
11239         return 0;
11240 }
11241
11242 static int
11243 test_authenticated_encryt_with_esn(
11244                 struct crypto_testsuite_params *ts_params,
11245                 struct crypto_unittest_params *ut_params,
11246                 const struct test_crypto_vector *reference)
11247 {
11248         int retval;
11249
11250         uint8_t *authciphertext, *plaintext, *auth_tag;
11251         uint16_t plaintext_pad_len;
11252         uint8_t cipher_key[reference->cipher_key.len + 1];
11253         uint8_t auth_key[reference->auth_key.len + 1];
11254
11255         /* Create session */
11256         memcpy(cipher_key, reference->cipher_key.data,
11257                         reference->cipher_key.len);
11258         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11259
11260         /* Setup Cipher Parameters */
11261         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11262         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
11263         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11264         ut_params->cipher_xform.cipher.key.data = cipher_key;
11265         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
11266         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
11267         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
11268
11269         ut_params->cipher_xform.next = &ut_params->auth_xform;
11270
11271         /* Setup Authentication Parameters */
11272         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11273         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11274         ut_params->auth_xform.auth.algo = reference->auth_algo;
11275         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11276         ut_params->auth_xform.auth.key.data = auth_key;
11277         ut_params->auth_xform.auth.digest_length = reference->digest.len;
11278         ut_params->auth_xform.next = NULL;
11279
11280         /* Create Crypto session*/
11281         ut_params->sess = rte_cryptodev_sym_session_create(
11282                         ts_params->session_mpool);
11283
11284         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11285                                 ut_params->sess,
11286                                 &ut_params->cipher_xform,
11287                                 ts_params->session_priv_mpool);
11288
11289         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11290
11291         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11292         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11293                         "Failed to allocate input buffer in mempool");
11294
11295         /* clear mbuf payload */
11296         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11297                         rte_pktmbuf_tailroom(ut_params->ibuf));
11298
11299         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11300                         reference->plaintext.len);
11301         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11302         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11303
11304         /* Create operation */
11305         retval = create_cipher_auth_operation(ts_params,
11306                         ut_params,
11307                         reference, 0);
11308
11309         if (retval < 0)
11310                 return retval;
11311
11312         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11313                         ut_params->op);
11314
11315         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
11316
11317         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11318                         "crypto op processing failed");
11319
11320         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
11321
11322         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11323                         ut_params->op->sym->auth.data.offset);
11324         auth_tag = authciphertext + plaintext_pad_len;
11325         debug_hexdump(stdout, "ciphertext:", authciphertext,
11326                         reference->ciphertext.len);
11327         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
11328
11329         /* Validate obuf */
11330         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11331                         authciphertext,
11332                         reference->ciphertext.data,
11333                         reference->ciphertext.len,
11334                         "Ciphertext data not as expected");
11335
11336         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11337                         auth_tag,
11338                         reference->digest.data,
11339                         reference->digest.len,
11340                         "Generated digest not as expected");
11341
11342         return TEST_SUCCESS;
11343
11344 }
11345
11346 static int
11347 test_authenticated_decrypt_with_esn(
11348                 struct crypto_testsuite_params *ts_params,
11349                 struct crypto_unittest_params *ut_params,
11350                 const struct test_crypto_vector *reference)
11351 {
11352         int retval;
11353
11354         uint8_t *ciphertext;
11355         uint8_t cipher_key[reference->cipher_key.len + 1];
11356         uint8_t auth_key[reference->auth_key.len + 1];
11357
11358         /* Create session */
11359         memcpy(cipher_key, reference->cipher_key.data,
11360                         reference->cipher_key.len);
11361         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11362
11363         /* Setup Authentication Parameters */
11364         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11365         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
11366         ut_params->auth_xform.auth.algo = reference->auth_algo;
11367         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11368         ut_params->auth_xform.auth.key.data = auth_key;
11369         ut_params->auth_xform.auth.digest_length = reference->digest.len;
11370         ut_params->auth_xform.next = &ut_params->cipher_xform;
11371
11372         /* Setup Cipher Parameters */
11373         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11374         ut_params->cipher_xform.next = NULL;
11375         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
11376         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
11377         ut_params->cipher_xform.cipher.key.data = cipher_key;
11378         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
11379         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
11380         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
11381
11382         /* Create Crypto session*/
11383         ut_params->sess = rte_cryptodev_sym_session_create(
11384                         ts_params->session_mpool);
11385
11386         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11387                                 ut_params->sess,
11388                                 &ut_params->auth_xform,
11389                                 ts_params->session_priv_mpool);
11390
11391         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11392
11393         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11394         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11395                         "Failed to allocate input buffer in mempool");
11396
11397         /* clear mbuf payload */
11398         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11399                         rte_pktmbuf_tailroom(ut_params->ibuf));
11400
11401         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11402                         reference->ciphertext.len);
11403         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
11404         memcpy(ciphertext, reference->ciphertext.data,
11405                         reference->ciphertext.len);
11406
11407         /* Create operation */
11408         retval = create_cipher_auth_verify_operation(ts_params,
11409                         ut_params,
11410                         reference);
11411
11412         if (retval < 0)
11413                 return retval;
11414
11415         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11416                         ut_params->op);
11417
11418         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11419         TEST_ASSERT_EQUAL(ut_params->op->status,
11420                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11421                         "crypto op processing passed");
11422
11423         ut_params->obuf = ut_params->op->sym->m_src;
11424         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
11425
11426         return 0;
11427 }
11428
11429 static int
11430 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
11431                 const struct aead_test_data *tdata,
11432                 void *digest_mem, uint64_t digest_phys)
11433 {
11434         struct crypto_testsuite_params *ts_params = &testsuite_params;
11435         struct crypto_unittest_params *ut_params = &unittest_params;
11436
11437         const unsigned int auth_tag_len = tdata->auth_tag.len;
11438         const unsigned int iv_len = tdata->iv.len;
11439         unsigned int aad_len = tdata->aad.len;
11440         unsigned int aad_len_pad = 0;
11441
11442         /* Generate Crypto op data structure */
11443         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11444                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11445         TEST_ASSERT_NOT_NULL(ut_params->op,
11446                 "Failed to allocate symmetric crypto operation struct");
11447
11448         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11449
11450         sym_op->aead.digest.data = digest_mem;
11451
11452         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
11453                         "no room to append digest");
11454
11455         sym_op->aead.digest.phys_addr = digest_phys;
11456
11457         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
11458                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
11459                                 auth_tag_len);
11460                 debug_hexdump(stdout, "digest:",
11461                                 sym_op->aead.digest.data,
11462                                 auth_tag_len);
11463         }
11464
11465         /* Append aad data */
11466         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
11467                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11468                                 uint8_t *, IV_OFFSET);
11469
11470                 /* Copy IV 1 byte after the IV pointer, according to the API */
11471                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
11472
11473                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
11474
11475                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
11476                                 ut_params->ibuf, aad_len);
11477                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
11478                                 "no room to prepend aad");
11479                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
11480                                 ut_params->ibuf);
11481
11482                 memset(sym_op->aead.aad.data, 0, aad_len);
11483                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
11484                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
11485
11486                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
11487                 debug_hexdump(stdout, "aad:",
11488                                 sym_op->aead.aad.data, aad_len);
11489         } else {
11490                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11491                                 uint8_t *, IV_OFFSET);
11492
11493                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
11494
11495                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
11496
11497                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
11498                                 ut_params->ibuf, aad_len_pad);
11499                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
11500                                 "no room to prepend aad");
11501                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
11502                                 ut_params->ibuf);
11503
11504                 memset(sym_op->aead.aad.data, 0, aad_len);
11505                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
11506
11507                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
11508                 debug_hexdump(stdout, "aad:",
11509                                 sym_op->aead.aad.data, aad_len);
11510         }
11511
11512         sym_op->aead.data.length = tdata->plaintext.len;
11513         sym_op->aead.data.offset = aad_len_pad;
11514
11515         return 0;
11516 }
11517
11518 #define SGL_MAX_NO      16
11519
11520 static int
11521 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
11522                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
11523 {
11524         struct crypto_testsuite_params *ts_params = &testsuite_params;
11525         struct crypto_unittest_params *ut_params = &unittest_params;
11526         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
11527         int retval;
11528         int to_trn = 0;
11529         int to_trn_tbl[SGL_MAX_NO];
11530         int segs = 1;
11531         unsigned int trn_data = 0;
11532         uint8_t *plaintext, *ciphertext, *auth_tag;
11533
11534         if (fragsz > tdata->plaintext.len)
11535                 fragsz = tdata->plaintext.len;
11536
11537         uint16_t plaintext_len = fragsz;
11538         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
11539
11540         if (fragsz_oop > tdata->plaintext.len)
11541                 frag_size_oop = tdata->plaintext.len;
11542
11543         int ecx = 0;
11544         void *digest_mem = NULL;
11545
11546         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
11547
11548         if (tdata->plaintext.len % fragsz != 0) {
11549                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
11550                         return 1;
11551         }       else {
11552                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
11553                         return 1;
11554         }
11555
11556         /*
11557          * For out-op-place we need to alloc another mbuf
11558          */
11559         if (oop) {
11560                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11561                 rte_pktmbuf_append(ut_params->obuf,
11562                                 frag_size_oop + prepend_len);
11563                 buf_oop = ut_params->obuf;
11564         }
11565
11566         /* Create AEAD session */
11567         retval = create_aead_session(ts_params->valid_devs[0],
11568                         tdata->algo,
11569                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
11570                         tdata->key.data, tdata->key.len,
11571                         tdata->aad.len, tdata->auth_tag.len,
11572                         tdata->iv.len);
11573         if (retval < 0)
11574                 return retval;
11575
11576         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11577
11578         /* clear mbuf payload */
11579         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11580                         rte_pktmbuf_tailroom(ut_params->ibuf));
11581
11582         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11583                         plaintext_len);
11584
11585         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
11586
11587         trn_data += plaintext_len;
11588
11589         buf = ut_params->ibuf;
11590
11591         /*
11592          * Loop until no more fragments
11593          */
11594
11595         while (trn_data < tdata->plaintext.len) {
11596                 ++segs;
11597                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
11598                                 (tdata->plaintext.len - trn_data) : fragsz;
11599
11600                 to_trn_tbl[ecx++] = to_trn;
11601
11602                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11603                 buf = buf->next;
11604
11605                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
11606                                 rte_pktmbuf_tailroom(buf));
11607
11608                 /* OOP */
11609                 if (oop && !fragsz_oop) {
11610                         buf_last_oop = buf_oop->next =
11611                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
11612                         buf_oop = buf_oop->next;
11613                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
11614                                         0, rte_pktmbuf_tailroom(buf_oop));
11615                         rte_pktmbuf_append(buf_oop, to_trn);
11616                 }
11617
11618                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
11619                                 to_trn);
11620
11621                 memcpy(plaintext, tdata->plaintext.data + trn_data,
11622                                 to_trn);
11623                 trn_data += to_trn;
11624                 if (trn_data  == tdata->plaintext.len) {
11625                         if (oop) {
11626                                 if (!fragsz_oop)
11627                                         digest_mem = rte_pktmbuf_append(buf_oop,
11628                                                 tdata->auth_tag.len);
11629                         } else
11630                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
11631                                         tdata->auth_tag.len);
11632                 }
11633         }
11634
11635         uint64_t digest_phys = 0;
11636
11637         ut_params->ibuf->nb_segs = segs;
11638
11639         segs = 1;
11640         if (fragsz_oop && oop) {
11641                 to_trn = 0;
11642                 ecx = 0;
11643
11644                 if (frag_size_oop == tdata->plaintext.len) {
11645                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
11646                                 tdata->auth_tag.len);
11647
11648                         digest_phys = rte_pktmbuf_iova_offset(
11649                                         ut_params->obuf,
11650                                         tdata->plaintext.len + prepend_len);
11651                 }
11652
11653                 trn_data = frag_size_oop;
11654                 while (trn_data < tdata->plaintext.len) {
11655                         ++segs;
11656                         to_trn =
11657                                 (tdata->plaintext.len - trn_data <
11658                                                 frag_size_oop) ?
11659                                 (tdata->plaintext.len - trn_data) :
11660                                                 frag_size_oop;
11661
11662                         to_trn_tbl[ecx++] = to_trn;
11663
11664                         buf_last_oop = buf_oop->next =
11665                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
11666                         buf_oop = buf_oop->next;
11667                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
11668                                         0, rte_pktmbuf_tailroom(buf_oop));
11669                         rte_pktmbuf_append(buf_oop, to_trn);
11670
11671                         trn_data += to_trn;
11672
11673                         if (trn_data  == tdata->plaintext.len) {
11674                                 digest_mem = rte_pktmbuf_append(buf_oop,
11675                                         tdata->auth_tag.len);
11676                         }
11677                 }
11678
11679                 ut_params->obuf->nb_segs = segs;
11680         }
11681
11682         /*
11683          * Place digest at the end of the last buffer
11684          */
11685         if (!digest_phys)
11686                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
11687         if (oop && buf_last_oop)
11688                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
11689
11690         if (!digest_mem && !oop) {
11691                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11692                                 + tdata->auth_tag.len);
11693                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
11694                                 tdata->plaintext.len);
11695         }
11696
11697         /* Create AEAD operation */
11698         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
11699                         tdata, digest_mem, digest_phys);
11700
11701         if (retval < 0)
11702                 return retval;
11703
11704         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11705
11706         ut_params->op->sym->m_src = ut_params->ibuf;
11707         if (oop)
11708                 ut_params->op->sym->m_dst = ut_params->obuf;
11709
11710         /* Process crypto operation */
11711         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11712                         ut_params->op), "failed to process sym crypto op");
11713
11714         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11715                         "crypto op processing failed");
11716
11717
11718         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
11719                         uint8_t *, prepend_len);
11720         if (oop) {
11721                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11722                                 uint8_t *, prepend_len);
11723         }
11724
11725         if (fragsz_oop)
11726                 fragsz = fragsz_oop;
11727
11728         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11729                         ciphertext,
11730                         tdata->ciphertext.data,
11731                         fragsz,
11732                         "Ciphertext data not as expected");
11733
11734         buf = ut_params->op->sym->m_src->next;
11735         if (oop)
11736                 buf = ut_params->op->sym->m_dst->next;
11737
11738         unsigned int off = fragsz;
11739
11740         ecx = 0;
11741         while (buf) {
11742                 ciphertext = rte_pktmbuf_mtod(buf,
11743                                 uint8_t *);
11744
11745                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11746                                 ciphertext,
11747                                 tdata->ciphertext.data + off,
11748                                 to_trn_tbl[ecx],
11749                                 "Ciphertext data not as expected");
11750
11751                 off += to_trn_tbl[ecx++];
11752                 buf = buf->next;
11753         }
11754
11755         auth_tag = digest_mem;
11756         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11757                         auth_tag,
11758                         tdata->auth_tag.data,
11759                         tdata->auth_tag.len,
11760                         "Generated auth tag not as expected");
11761
11762         return 0;
11763 }
11764
11765 static int
11766 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
11767 {
11768         return test_authenticated_encryption_SGL(
11769                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
11770 }
11771
11772 static int
11773 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
11774 {
11775         return test_authenticated_encryption_SGL(
11776                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
11777 }
11778
11779 static int
11780 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
11781 {
11782         return test_authenticated_encryption_SGL(
11783                         &gcm_test_case_8, OUT_OF_PLACE, 400,
11784                         gcm_test_case_8.plaintext.len);
11785 }
11786
11787 static int
11788 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
11789 {
11790
11791         return test_authenticated_encryption_SGL(
11792                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
11793 }
11794
11795 static int
11796 test_authentication_verify_fail_when_data_corrupted(
11797                 struct crypto_testsuite_params *ts_params,
11798                 struct crypto_unittest_params *ut_params,
11799                 const struct test_crypto_vector *reference)
11800 {
11801         return test_authentication_verify_fail_when_data_corruption(
11802                         ts_params, ut_params, reference, 1);
11803 }
11804
11805 static int
11806 test_authentication_verify_fail_when_tag_corrupted(
11807                 struct crypto_testsuite_params *ts_params,
11808                 struct crypto_unittest_params *ut_params,
11809                 const struct test_crypto_vector *reference)
11810 {
11811         return test_authentication_verify_fail_when_data_corruption(
11812                         ts_params, ut_params, reference, 0);
11813 }
11814
11815 static int
11816 test_authentication_verify_GMAC_fail_when_data_corrupted(
11817                 struct crypto_testsuite_params *ts_params,
11818                 struct crypto_unittest_params *ut_params,
11819                 const struct test_crypto_vector *reference)
11820 {
11821         return test_authentication_verify_GMAC_fail_when_corruption(
11822                         ts_params, ut_params, reference, 1);
11823 }
11824
11825 static int
11826 test_authentication_verify_GMAC_fail_when_tag_corrupted(
11827                 struct crypto_testsuite_params *ts_params,
11828                 struct crypto_unittest_params *ut_params,
11829                 const struct test_crypto_vector *reference)
11830 {
11831         return test_authentication_verify_GMAC_fail_when_corruption(
11832                         ts_params, ut_params, reference, 0);
11833 }
11834
11835 static int
11836 test_authenticated_decryption_fail_when_data_corrupted(
11837                 struct crypto_testsuite_params *ts_params,
11838                 struct crypto_unittest_params *ut_params,
11839                 const struct test_crypto_vector *reference)
11840 {
11841         return test_authenticated_decryption_fail_when_corruption(
11842                         ts_params, ut_params, reference, 1);
11843 }
11844
11845 static int
11846 test_authenticated_decryption_fail_when_tag_corrupted(
11847                 struct crypto_testsuite_params *ts_params,
11848                 struct crypto_unittest_params *ut_params,
11849                 const struct test_crypto_vector *reference)
11850 {
11851         return test_authenticated_decryption_fail_when_corruption(
11852                         ts_params, ut_params, reference, 0);
11853 }
11854
11855 static int
11856 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
11857 {
11858         return test_authentication_verify_fail_when_data_corrupted(
11859                         &testsuite_params, &unittest_params,
11860                         &hmac_sha1_test_crypto_vector);
11861 }
11862
11863 static int
11864 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
11865 {
11866         return test_authentication_verify_fail_when_tag_corrupted(
11867                         &testsuite_params, &unittest_params,
11868                         &hmac_sha1_test_crypto_vector);
11869 }
11870
11871 static int
11872 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
11873 {
11874         return test_authentication_verify_GMAC_fail_when_data_corrupted(
11875                         &testsuite_params, &unittest_params,
11876                         &aes128_gmac_test_vector);
11877 }
11878
11879 static int
11880 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
11881 {
11882         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
11883                         &testsuite_params, &unittest_params,
11884                         &aes128_gmac_test_vector);
11885 }
11886
11887 static int
11888 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
11889 {
11890         return test_authenticated_decryption_fail_when_data_corrupted(
11891                         &testsuite_params,
11892                         &unittest_params,
11893                         &aes128cbc_hmac_sha1_test_vector);
11894 }
11895
11896 static int
11897 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
11898 {
11899         return test_authenticated_decryption_fail_when_tag_corrupted(
11900                         &testsuite_params,
11901                         &unittest_params,
11902                         &aes128cbc_hmac_sha1_test_vector);
11903 }
11904
11905 static int
11906 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
11907 {
11908         return test_authenticated_encryt_with_esn(
11909                         &testsuite_params,
11910                         &unittest_params,
11911                         &aes128cbc_hmac_sha1_aad_test_vector);
11912 }
11913
11914 static int
11915 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
11916 {
11917         return test_authenticated_decrypt_with_esn(
11918                         &testsuite_params,
11919                         &unittest_params,
11920                         &aes128cbc_hmac_sha1_aad_test_vector);
11921 }
11922
11923 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
11924
11925 /* global AESNI slave IDs for the scheduler test */
11926 uint8_t aesni_ids[2];
11927
11928 static int
11929 test_scheduler_attach_slave_op(void)
11930 {
11931         struct crypto_testsuite_params *ts_params = &testsuite_params;
11932         uint8_t sched_id = ts_params->valid_devs[0];
11933         uint32_t nb_devs, i, nb_devs_attached = 0;
11934         int ret;
11935         char vdev_name[32];
11936
11937         /* create 2 AESNI_MB if necessary */
11938         nb_devs = rte_cryptodev_device_count_by_driver(
11939                         rte_cryptodev_driver_id_get(
11940                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
11941         if (nb_devs < 2) {
11942                 for (i = nb_devs; i < 2; i++) {
11943                         snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
11944                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
11945                                         i);
11946                         ret = rte_vdev_init(vdev_name, NULL);
11947
11948                         TEST_ASSERT(ret == 0,
11949                                 "Failed to create instance %u of"
11950                                 " pmd : %s",
11951                                 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
11952                 }
11953         }
11954
11955         /* attach 2 AESNI_MB cdevs */
11956         for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
11957                         i++) {
11958                 struct rte_cryptodev_info info;
11959                 unsigned int session_size;
11960
11961                 rte_cryptodev_info_get(i, &info);
11962                 if (info.driver_id != rte_cryptodev_driver_id_get(
11963                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
11964                         continue;
11965
11966                 session_size = rte_cryptodev_sym_get_private_session_size(i);
11967                 /*
11968                  * Create the session mempool again, since now there are new devices
11969                  * to use the mempool.
11970                  */
11971                 if (ts_params->session_mpool) {
11972                         rte_mempool_free(ts_params->session_mpool);
11973                         ts_params->session_mpool = NULL;
11974                 }
11975                 if (ts_params->session_priv_mpool) {
11976                         rte_mempool_free(ts_params->session_priv_mpool);
11977                         ts_params->session_priv_mpool = NULL;
11978                 }
11979
11980                 if (info.sym.max_nb_sessions != 0 &&
11981                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
11982                         RTE_LOG(ERR, USER1,
11983                                         "Device does not support "
11984                                         "at least %u sessions\n",
11985                                         MAX_NB_SESSIONS);
11986                         return TEST_FAILED;
11987                 }
11988                 /*
11989                  * Create mempool with maximum number of sessions,
11990                  * to include the session headers
11991                  */
11992                 if (ts_params->session_mpool == NULL) {
11993                         ts_params->session_mpool =
11994                                 rte_cryptodev_sym_session_pool_create(
11995                                                 "test_sess_mp",
11996                                                 MAX_NB_SESSIONS, 0, 0, 0,
11997                                                 SOCKET_ID_ANY);
11998                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
11999                                         "session mempool allocation failed");
12000                 }
12001
12002                 /*
12003                  * Create mempool with maximum number of sessions,
12004                  * to include device specific session private data
12005                  */
12006                 if (ts_params->session_priv_mpool == NULL) {
12007                         ts_params->session_priv_mpool = rte_mempool_create(
12008                                         "test_sess_mp_priv",
12009                                         MAX_NB_SESSIONS,
12010                                         session_size,
12011                                         0, 0, NULL, NULL, NULL,
12012                                         NULL, SOCKET_ID_ANY,
12013                                         0);
12014
12015                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
12016                                         "session mempool allocation failed");
12017                 }
12018
12019                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
12020                 ts_params->qp_conf.mp_session_private =
12021                                 ts_params->session_priv_mpool;
12022
12023                 ret = rte_cryptodev_scheduler_slave_attach(sched_id,
12024                                 (uint8_t)i);
12025
12026                 TEST_ASSERT(ret == 0,
12027                         "Failed to attach device %u of pmd : %s", i,
12028                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12029
12030                 aesni_ids[nb_devs_attached] = (uint8_t)i;
12031
12032                 nb_devs_attached++;
12033         }
12034
12035         return 0;
12036 }
12037
12038 static int
12039 test_scheduler_detach_slave_op(void)
12040 {
12041         struct crypto_testsuite_params *ts_params = &testsuite_params;
12042         uint8_t sched_id = ts_params->valid_devs[0];
12043         uint32_t i;
12044         int ret;
12045
12046         for (i = 0; i < 2; i++) {
12047                 ret = rte_cryptodev_scheduler_slave_detach(sched_id,
12048                                 aesni_ids[i]);
12049                 TEST_ASSERT(ret == 0,
12050                         "Failed to detach device %u", aesni_ids[i]);
12051         }
12052
12053         return 0;
12054 }
12055
12056 static int
12057 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
12058 {
12059         struct crypto_testsuite_params *ts_params = &testsuite_params;
12060         uint8_t sched_id = ts_params->valid_devs[0];
12061         /* set mode */
12062         return rte_cryptodev_scheduler_mode_set(sched_id,
12063                 scheduler_mode);
12064 }
12065
12066 static int
12067 test_scheduler_mode_roundrobin_op(void)
12068 {
12069         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
12070                         0, "Failed to set roundrobin mode");
12071         return 0;
12072
12073 }
12074
12075 static int
12076 test_scheduler_mode_multicore_op(void)
12077 {
12078         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
12079                         0, "Failed to set multicore mode");
12080
12081         return 0;
12082 }
12083
12084 static int
12085 test_scheduler_mode_failover_op(void)
12086 {
12087         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
12088                         0, "Failed to set failover mode");
12089
12090         return 0;
12091 }
12092
12093 static int
12094 test_scheduler_mode_pkt_size_distr_op(void)
12095 {
12096         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
12097                         0, "Failed to set pktsize mode");
12098
12099         return 0;
12100 }
12101
12102 static struct unit_test_suite cryptodev_scheduler_testsuite  = {
12103         .suite_name = "Crypto Device Scheduler Unit Test Suite",
12104         .setup = testsuite_setup,
12105         .teardown = testsuite_teardown,
12106         .unit_test_cases = {
12107                 /* Multi Core */
12108                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
12109                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
12110                 TEST_CASE_ST(ut_setup, ut_teardown,
12111                                         test_AES_chain_scheduler_all),
12112                 TEST_CASE_ST(ut_setup, ut_teardown,
12113                                         test_AES_cipheronly_scheduler_all),
12114                 TEST_CASE_ST(ut_setup, ut_teardown,
12115                                         test_authonly_scheduler_all),
12116                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
12117
12118                 /* Round Robin */
12119                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
12120                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
12121                 TEST_CASE_ST(ut_setup, ut_teardown,
12122                                 test_AES_chain_scheduler_all),
12123                 TEST_CASE_ST(ut_setup, ut_teardown,
12124                                 test_AES_cipheronly_scheduler_all),
12125                 TEST_CASE_ST(ut_setup, ut_teardown,
12126                                 test_authonly_scheduler_all),
12127                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
12128
12129                 /* Fail over */
12130                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
12131                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
12132                 TEST_CASE_ST(ut_setup, ut_teardown,
12133                                         test_AES_chain_scheduler_all),
12134                 TEST_CASE_ST(ut_setup, ut_teardown,
12135                                         test_AES_cipheronly_scheduler_all),
12136                 TEST_CASE_ST(ut_setup, ut_teardown,
12137                                         test_authonly_scheduler_all),
12138                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
12139
12140                 /* PKT SIZE */
12141                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
12142                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
12143                 TEST_CASE_ST(ut_setup, ut_teardown,
12144                                         test_AES_chain_scheduler_all),
12145                 TEST_CASE_ST(ut_setup, ut_teardown,
12146                                         test_AES_cipheronly_scheduler_all),
12147                 TEST_CASE_ST(ut_setup, ut_teardown,
12148                                         test_authonly_scheduler_all),
12149                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
12150
12151                 TEST_CASES_END() /**< NULL terminate unit test array */
12152         }
12153 };
12154
12155 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
12156
12157 static struct unit_test_suite cryptodev_qat_testsuite  = {
12158         .suite_name = "Crypto QAT Unit Test Suite",
12159         .setup = testsuite_setup,
12160         .teardown = testsuite_teardown,
12161         .unit_test_cases = {
12162                 TEST_CASE_ST(ut_setup, ut_teardown,
12163                                 test_device_configure_invalid_dev_id),
12164                 TEST_CASE_ST(ut_setup, ut_teardown,
12165                                 test_device_configure_invalid_queue_pair_ids),
12166                 TEST_CASE_ST(ut_setup, ut_teardown,
12167                                 test_queue_pair_descriptor_setup),
12168                 TEST_CASE_ST(ut_setup, ut_teardown,
12169                                 test_multi_session),
12170
12171                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
12172                 TEST_CASE_ST(ut_setup, ut_teardown,
12173                                                 test_AES_cipheronly_qat_all),
12174                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
12175                 TEST_CASE_ST(ut_setup, ut_teardown,
12176                                                 test_3DES_cipheronly_qat_all),
12177                 TEST_CASE_ST(ut_setup, ut_teardown,
12178                                                 test_DES_cipheronly_qat_all),
12179                 TEST_CASE_ST(ut_setup, ut_teardown,
12180                                                 test_AES_docsis_qat_all),
12181                 TEST_CASE_ST(ut_setup, ut_teardown,
12182                                                 test_DES_docsis_qat_all),
12183                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_qat_all),
12184                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
12185
12186                 /** AES CCM Authenticated Encryption 128 bits key */
12187                 TEST_CASE_ST(ut_setup, ut_teardown,
12188                         test_AES_CCM_authenticated_encryption_test_case_128_1),
12189                 TEST_CASE_ST(ut_setup, ut_teardown,
12190                         test_AES_CCM_authenticated_encryption_test_case_128_2),
12191                 TEST_CASE_ST(ut_setup, ut_teardown,
12192                         test_AES_CCM_authenticated_encryption_test_case_128_3),
12193
12194                 /** AES CCM Authenticated Decryption 128 bits key*/
12195                 TEST_CASE_ST(ut_setup, ut_teardown,
12196                         test_AES_CCM_authenticated_decryption_test_case_128_1),
12197                 TEST_CASE_ST(ut_setup, ut_teardown,
12198                         test_AES_CCM_authenticated_decryption_test_case_128_2),
12199                 TEST_CASE_ST(ut_setup, ut_teardown,
12200                         test_AES_CCM_authenticated_decryption_test_case_128_3),
12201
12202                 TEST_CASE_ST(ut_setup, ut_teardown,
12203                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
12204                 TEST_CASE_ST(ut_setup, ut_teardown,
12205                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
12206                 /** AES GCM Authenticated Encryption */
12207                 TEST_CASE_ST(ut_setup, ut_teardown,
12208                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
12209                 TEST_CASE_ST(ut_setup, ut_teardown,
12210                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
12211                 TEST_CASE_ST(ut_setup, ut_teardown,
12212                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
12213                 TEST_CASE_ST(ut_setup, ut_teardown,
12214                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
12215                 TEST_CASE_ST(ut_setup, ut_teardown,
12216                         test_AES_GCM_authenticated_encryption_test_case_1),
12217                 TEST_CASE_ST(ut_setup, ut_teardown,
12218                         test_AES_GCM_authenticated_encryption_test_case_2),
12219                 TEST_CASE_ST(ut_setup, ut_teardown,
12220                         test_AES_GCM_authenticated_encryption_test_case_3),
12221                 TEST_CASE_ST(ut_setup, ut_teardown,
12222                         test_AES_GCM_authenticated_encryption_test_case_4),
12223                 TEST_CASE_ST(ut_setup, ut_teardown,
12224                         test_AES_GCM_authenticated_encryption_test_case_5),
12225                 TEST_CASE_ST(ut_setup, ut_teardown,
12226                         test_AES_GCM_authenticated_encryption_test_case_6),
12227                 TEST_CASE_ST(ut_setup, ut_teardown,
12228                         test_AES_GCM_authenticated_encryption_test_case_7),
12229                 TEST_CASE_ST(ut_setup, ut_teardown,
12230                         test_AES_GCM_authenticated_encryption_test_case_8),
12231
12232                 /** AES GCM Authenticated Decryption */
12233                 TEST_CASE_ST(ut_setup, ut_teardown,
12234                         test_AES_GCM_authenticated_decryption_test_case_1),
12235                 TEST_CASE_ST(ut_setup, ut_teardown,
12236                         test_AES_GCM_authenticated_decryption_test_case_2),
12237                 TEST_CASE_ST(ut_setup, ut_teardown,
12238                         test_AES_GCM_authenticated_decryption_test_case_3),
12239                 TEST_CASE_ST(ut_setup, ut_teardown,
12240                         test_AES_GCM_authenticated_decryption_test_case_4),
12241                 TEST_CASE_ST(ut_setup, ut_teardown,
12242                         test_AES_GCM_authenticated_decryption_test_case_5),
12243                 TEST_CASE_ST(ut_setup, ut_teardown,
12244                         test_AES_GCM_authenticated_decryption_test_case_6),
12245                 TEST_CASE_ST(ut_setup, ut_teardown,
12246                         test_AES_GCM_authenticated_decryption_test_case_7),
12247                 TEST_CASE_ST(ut_setup, ut_teardown,
12248                         test_AES_GCM_authenticated_decryption_test_case_8),
12249
12250                 /** AES GCM Authenticated Encryption 192 bits key */
12251                 TEST_CASE_ST(ut_setup, ut_teardown,
12252                         test_AES_GCM_auth_encryption_test_case_192_1),
12253                 TEST_CASE_ST(ut_setup, ut_teardown,
12254                         test_AES_GCM_auth_encryption_test_case_192_2),
12255                 TEST_CASE_ST(ut_setup, ut_teardown,
12256                         test_AES_GCM_auth_encryption_test_case_192_3),
12257                 TEST_CASE_ST(ut_setup, ut_teardown,
12258                         test_AES_GCM_auth_encryption_test_case_192_4),
12259                 TEST_CASE_ST(ut_setup, ut_teardown,
12260                         test_AES_GCM_auth_encryption_test_case_192_5),
12261                 TEST_CASE_ST(ut_setup, ut_teardown,
12262                         test_AES_GCM_auth_encryption_test_case_192_6),
12263                 TEST_CASE_ST(ut_setup, ut_teardown,
12264                         test_AES_GCM_auth_encryption_test_case_192_7),
12265
12266                 /** AES GCM Authenticated Decryption 192 bits key */
12267                 TEST_CASE_ST(ut_setup, ut_teardown,
12268                         test_AES_GCM_auth_decryption_test_case_192_1),
12269                 TEST_CASE_ST(ut_setup, ut_teardown,
12270                         test_AES_GCM_auth_decryption_test_case_192_2),
12271                 TEST_CASE_ST(ut_setup, ut_teardown,
12272                         test_AES_GCM_auth_decryption_test_case_192_3),
12273                 TEST_CASE_ST(ut_setup, ut_teardown,
12274                         test_AES_GCM_auth_decryption_test_case_192_4),
12275                 TEST_CASE_ST(ut_setup, ut_teardown,
12276                         test_AES_GCM_auth_decryption_test_case_192_5),
12277                 TEST_CASE_ST(ut_setup, ut_teardown,
12278                         test_AES_GCM_auth_decryption_test_case_192_6),
12279                 TEST_CASE_ST(ut_setup, ut_teardown,
12280                         test_AES_GCM_auth_decryption_test_case_192_7),
12281
12282                 /** AES GCM Authenticated Encryption 256 bits key */
12283                 TEST_CASE_ST(ut_setup, ut_teardown,
12284                         test_AES_GCM_auth_encryption_test_case_256_1),
12285                 TEST_CASE_ST(ut_setup, ut_teardown,
12286                         test_AES_GCM_auth_encryption_test_case_256_2),
12287                 TEST_CASE_ST(ut_setup, ut_teardown,
12288                         test_AES_GCM_auth_encryption_test_case_256_3),
12289                 TEST_CASE_ST(ut_setup, ut_teardown,
12290                         test_AES_GCM_auth_encryption_test_case_256_4),
12291                 TEST_CASE_ST(ut_setup, ut_teardown,
12292                         test_AES_GCM_auth_encryption_test_case_256_5),
12293                 TEST_CASE_ST(ut_setup, ut_teardown,
12294                         test_AES_GCM_auth_encryption_test_case_256_6),
12295                 TEST_CASE_ST(ut_setup, ut_teardown,
12296                         test_AES_GCM_auth_encryption_test_case_256_7),
12297
12298                 /** AES GCM Authenticated Decryption 256 bits key */
12299                 TEST_CASE_ST(ut_setup, ut_teardown,
12300                         test_AES_GCM_auth_decryption_test_case_256_1),
12301                 TEST_CASE_ST(ut_setup, ut_teardown,
12302                         test_AES_GCM_auth_decryption_test_case_256_2),
12303                 TEST_CASE_ST(ut_setup, ut_teardown,
12304                         test_AES_GCM_auth_decryption_test_case_256_3),
12305                 TEST_CASE_ST(ut_setup, ut_teardown,
12306                         test_AES_GCM_auth_decryption_test_case_256_4),
12307                 TEST_CASE_ST(ut_setup, ut_teardown,
12308                         test_AES_GCM_auth_decryption_test_case_256_5),
12309                 TEST_CASE_ST(ut_setup, ut_teardown,
12310                         test_AES_GCM_auth_decryption_test_case_256_6),
12311                 TEST_CASE_ST(ut_setup, ut_teardown,
12312                         test_AES_GCM_auth_decryption_test_case_256_7),
12313
12314                 /** AES GMAC Authentication */
12315                 TEST_CASE_ST(ut_setup, ut_teardown,
12316                         test_AES_GMAC_authentication_test_case_1),
12317                 TEST_CASE_ST(ut_setup, ut_teardown,
12318                         test_AES_GMAC_authentication_verify_test_case_1),
12319                 TEST_CASE_ST(ut_setup, ut_teardown,
12320                         test_AES_GMAC_authentication_test_case_2),
12321                 TEST_CASE_ST(ut_setup, ut_teardown,
12322                         test_AES_GMAC_authentication_verify_test_case_2),
12323                 TEST_CASE_ST(ut_setup, ut_teardown,
12324                         test_AES_GMAC_authentication_test_case_3),
12325                 TEST_CASE_ST(ut_setup, ut_teardown,
12326                         test_AES_GMAC_authentication_verify_test_case_3),
12327
12328                 /** SNOW 3G encrypt only (UEA2) */
12329                 TEST_CASE_ST(ut_setup, ut_teardown,
12330                         test_snow3g_encryption_test_case_1),
12331                 TEST_CASE_ST(ut_setup, ut_teardown,
12332                         test_snow3g_encryption_test_case_2),
12333                 TEST_CASE_ST(ut_setup, ut_teardown,
12334                         test_snow3g_encryption_test_case_3),
12335                 TEST_CASE_ST(ut_setup, ut_teardown,
12336                         test_snow3g_encryption_test_case_4),
12337                 TEST_CASE_ST(ut_setup, ut_teardown,
12338                         test_snow3g_encryption_test_case_5),
12339
12340                 TEST_CASE_ST(ut_setup, ut_teardown,
12341                         test_snow3g_encryption_test_case_1_oop),
12342                 TEST_CASE_ST(ut_setup, ut_teardown,
12343                         test_snow3g_decryption_test_case_1_oop),
12344
12345                 /** SNOW 3G generate auth, then encrypt (UEA2) */
12346                 TEST_CASE_ST(ut_setup, ut_teardown,
12347                         test_snow3g_auth_cipher_test_case_1),
12348                 TEST_CASE_ST(ut_setup, ut_teardown,
12349                         test_snow3g_auth_cipher_test_case_2),
12350                 TEST_CASE_ST(ut_setup, ut_teardown,
12351                         test_snow3g_auth_cipher_test_case_2_oop),
12352                 TEST_CASE_ST(ut_setup, ut_teardown,
12353                         test_snow3g_auth_cipher_part_digest_enc),
12354                 TEST_CASE_ST(ut_setup, ut_teardown,
12355                         test_snow3g_auth_cipher_part_digest_enc_oop),
12356                 TEST_CASE_ST(ut_setup, ut_teardown,
12357                         test_snow3g_auth_cipher_test_case_3_sgl),
12358                 TEST_CASE_ST(ut_setup, ut_teardown,
12359                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
12360                 TEST_CASE_ST(ut_setup, ut_teardown,
12361                         test_snow3g_auth_cipher_part_digest_enc_sgl),
12362                 TEST_CASE_ST(ut_setup, ut_teardown,
12363                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
12364
12365                 /** SNOW 3G decrypt (UEA2), then verify auth */
12366                 TEST_CASE_ST(ut_setup, ut_teardown,
12367                         test_snow3g_auth_cipher_verify_test_case_1),
12368                 TEST_CASE_ST(ut_setup, ut_teardown,
12369                         test_snow3g_auth_cipher_verify_test_case_2),
12370                 TEST_CASE_ST(ut_setup, ut_teardown,
12371                         test_snow3g_auth_cipher_verify_test_case_2_oop),
12372                 TEST_CASE_ST(ut_setup, ut_teardown,
12373                         test_snow3g_auth_cipher_verify_part_digest_enc),
12374                 TEST_CASE_ST(ut_setup, ut_teardown,
12375                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
12376                 TEST_CASE_ST(ut_setup, ut_teardown,
12377                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
12378                 TEST_CASE_ST(ut_setup, ut_teardown,
12379                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
12380                 TEST_CASE_ST(ut_setup, ut_teardown,
12381                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
12382                 TEST_CASE_ST(ut_setup, ut_teardown,
12383                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
12384
12385                 /** SNOW 3G decrypt only (UEA2) */
12386                 TEST_CASE_ST(ut_setup, ut_teardown,
12387                         test_snow3g_decryption_test_case_1),
12388                 TEST_CASE_ST(ut_setup, ut_teardown,
12389                         test_snow3g_decryption_test_case_2),
12390                 TEST_CASE_ST(ut_setup, ut_teardown,
12391                         test_snow3g_decryption_test_case_3),
12392                 TEST_CASE_ST(ut_setup, ut_teardown,
12393                         test_snow3g_decryption_test_case_4),
12394                 TEST_CASE_ST(ut_setup, ut_teardown,
12395                         test_snow3g_decryption_test_case_5),
12396                 TEST_CASE_ST(ut_setup, ut_teardown,
12397                         test_snow3g_decryption_with_digest_test_case_1),
12398                 TEST_CASE_ST(ut_setup, ut_teardown,
12399                         test_snow3g_hash_generate_test_case_1),
12400                 TEST_CASE_ST(ut_setup, ut_teardown,
12401                         test_snow3g_hash_generate_test_case_2),
12402                 TEST_CASE_ST(ut_setup, ut_teardown,
12403                         test_snow3g_hash_generate_test_case_3),
12404                 TEST_CASE_ST(ut_setup, ut_teardown,
12405                         test_snow3g_hash_verify_test_case_1),
12406                 TEST_CASE_ST(ut_setup, ut_teardown,
12407                         test_snow3g_hash_verify_test_case_2),
12408                 TEST_CASE_ST(ut_setup, ut_teardown,
12409                         test_snow3g_hash_verify_test_case_3),
12410                 TEST_CASE_ST(ut_setup, ut_teardown,
12411                         test_snow3g_cipher_auth_test_case_1),
12412                 TEST_CASE_ST(ut_setup, ut_teardown,
12413                         test_snow3g_auth_cipher_with_digest_test_case_1),
12414
12415                 /** ZUC encrypt only (EEA3) */
12416                 TEST_CASE_ST(ut_setup, ut_teardown,
12417                         test_zuc_encryption_test_case_1),
12418                 TEST_CASE_ST(ut_setup, ut_teardown,
12419                         test_zuc_encryption_test_case_2),
12420                 TEST_CASE_ST(ut_setup, ut_teardown,
12421                         test_zuc_encryption_test_case_3),
12422                 TEST_CASE_ST(ut_setup, ut_teardown,
12423                         test_zuc_encryption_test_case_4),
12424                 TEST_CASE_ST(ut_setup, ut_teardown,
12425                         test_zuc_encryption_test_case_5),
12426
12427                 /** ZUC authenticate (EIA3) */
12428                 TEST_CASE_ST(ut_setup, ut_teardown,
12429                         test_zuc_hash_generate_test_case_6),
12430                 TEST_CASE_ST(ut_setup, ut_teardown,
12431                         test_zuc_hash_generate_test_case_7),
12432                 TEST_CASE_ST(ut_setup, ut_teardown,
12433                         test_zuc_hash_generate_test_case_8),
12434
12435                 /** ZUC alg-chain (EEA3/EIA3) */
12436                 TEST_CASE_ST(ut_setup, ut_teardown,
12437                         test_zuc_cipher_auth_test_case_1),
12438                 TEST_CASE_ST(ut_setup, ut_teardown,
12439                         test_zuc_cipher_auth_test_case_2),
12440
12441                 /** ZUC generate auth, then encrypt (EEA3) */
12442                 TEST_CASE_ST(ut_setup, ut_teardown,
12443                         test_zuc_auth_cipher_test_case_1),
12444                 TEST_CASE_ST(ut_setup, ut_teardown,
12445                         test_zuc_auth_cipher_test_case_1_oop),
12446                 TEST_CASE_ST(ut_setup, ut_teardown,
12447                         test_zuc_auth_cipher_test_case_1_sgl),
12448                 TEST_CASE_ST(ut_setup, ut_teardown,
12449                         test_zuc_auth_cipher_test_case_1_oop_sgl),
12450
12451                 /** ZUC decrypt (EEA3), then verify auth */
12452                 TEST_CASE_ST(ut_setup, ut_teardown,
12453                         test_zuc_auth_cipher_verify_test_case_1),
12454                 TEST_CASE_ST(ut_setup, ut_teardown,
12455                         test_zuc_auth_cipher_verify_test_case_1_oop),
12456                 TEST_CASE_ST(ut_setup, ut_teardown,
12457                         test_zuc_auth_cipher_verify_test_case_1_sgl),
12458                 TEST_CASE_ST(ut_setup, ut_teardown,
12459                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
12460
12461                 /** HMAC_MD5 Authentication */
12462                 TEST_CASE_ST(ut_setup, ut_teardown,
12463                         test_MD5_HMAC_generate_case_1),
12464                 TEST_CASE_ST(ut_setup, ut_teardown,
12465                         test_MD5_HMAC_verify_case_1),
12466                 TEST_CASE_ST(ut_setup, ut_teardown,
12467                         test_MD5_HMAC_generate_case_2),
12468                 TEST_CASE_ST(ut_setup, ut_teardown,
12469                         test_MD5_HMAC_verify_case_2),
12470
12471                 /** NULL algo tests done in chain_all,
12472                  * cipheronly and authonly suites
12473                  */
12474
12475                 /** KASUMI tests */
12476                 TEST_CASE_ST(ut_setup, ut_teardown,
12477                         test_kasumi_hash_generate_test_case_1),
12478                 TEST_CASE_ST(ut_setup, ut_teardown,
12479                         test_kasumi_hash_generate_test_case_2),
12480                 TEST_CASE_ST(ut_setup, ut_teardown,
12481                         test_kasumi_hash_generate_test_case_3),
12482                 TEST_CASE_ST(ut_setup, ut_teardown,
12483                         test_kasumi_hash_generate_test_case_4),
12484                 TEST_CASE_ST(ut_setup, ut_teardown,
12485                         test_kasumi_hash_generate_test_case_5),
12486                 TEST_CASE_ST(ut_setup, ut_teardown,
12487                         test_kasumi_hash_generate_test_case_6),
12488
12489                 TEST_CASE_ST(ut_setup, ut_teardown,
12490                         test_kasumi_hash_verify_test_case_1),
12491                 TEST_CASE_ST(ut_setup, ut_teardown,
12492                         test_kasumi_hash_verify_test_case_2),
12493                 TEST_CASE_ST(ut_setup, ut_teardown,
12494                         test_kasumi_hash_verify_test_case_3),
12495                 TEST_CASE_ST(ut_setup, ut_teardown,
12496                         test_kasumi_hash_verify_test_case_4),
12497                 TEST_CASE_ST(ut_setup, ut_teardown,
12498                         test_kasumi_hash_verify_test_case_5),
12499
12500                 TEST_CASE_ST(ut_setup, ut_teardown,
12501                         test_kasumi_encryption_test_case_1),
12502                 TEST_CASE_ST(ut_setup, ut_teardown,
12503                         test_kasumi_encryption_test_case_3),
12504                 TEST_CASE_ST(ut_setup, ut_teardown,
12505                         test_kasumi_cipher_auth_test_case_1),
12506
12507                 /** KASUMI generate auth, then encrypt (F8) */
12508                 TEST_CASE_ST(ut_setup, ut_teardown,
12509                         test_kasumi_auth_cipher_test_case_1),
12510                 TEST_CASE_ST(ut_setup, ut_teardown,
12511                         test_kasumi_auth_cipher_test_case_2),
12512                 TEST_CASE_ST(ut_setup, ut_teardown,
12513                         test_kasumi_auth_cipher_test_case_2_oop),
12514                 TEST_CASE_ST(ut_setup, ut_teardown,
12515                         test_kasumi_auth_cipher_test_case_2_sgl),
12516                 TEST_CASE_ST(ut_setup, ut_teardown,
12517                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
12518
12519                 /** KASUMI decrypt (F8), then verify auth */
12520                 TEST_CASE_ST(ut_setup, ut_teardown,
12521                         test_kasumi_auth_cipher_verify_test_case_1),
12522                 TEST_CASE_ST(ut_setup, ut_teardown,
12523                         test_kasumi_auth_cipher_verify_test_case_2),
12524                 TEST_CASE_ST(ut_setup, ut_teardown,
12525                         test_kasumi_auth_cipher_verify_test_case_2_oop),
12526                 TEST_CASE_ST(ut_setup, ut_teardown,
12527                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
12528                 TEST_CASE_ST(ut_setup, ut_teardown,
12529                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
12530
12531                 /** Negative tests */
12532                 TEST_CASE_ST(ut_setup, ut_teardown,
12533                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
12534                 TEST_CASE_ST(ut_setup, ut_teardown,
12535                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12536                 TEST_CASE_ST(ut_setup, ut_teardown,
12537                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
12538                 TEST_CASE_ST(ut_setup, ut_teardown,
12539                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
12540                 TEST_CASE_ST(ut_setup, ut_teardown,
12541                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
12542                 TEST_CASE_ST(ut_setup, ut_teardown,
12543                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
12544                 TEST_CASE_ST(ut_setup, ut_teardown,
12545                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
12546                 TEST_CASE_ST(ut_setup, ut_teardown,
12547                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
12548                 TEST_CASE_ST(ut_setup, ut_teardown,
12549                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
12550                 TEST_CASE_ST(ut_setup, ut_teardown,
12551                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
12552                 TEST_CASE_ST(ut_setup, ut_teardown,
12553                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
12554                 TEST_CASE_ST(ut_setup, ut_teardown,
12555                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
12556                 TEST_CASE_ST(ut_setup, ut_teardown,
12557                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
12558                 TEST_CASE_ST(ut_setup, ut_teardown,
12559                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
12560                 TEST_CASE_ST(ut_setup, ut_teardown,
12561                         authentication_verify_AES128_GMAC_fail_data_corrupt),
12562                 TEST_CASE_ST(ut_setup, ut_teardown,
12563                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
12564                 TEST_CASE_ST(ut_setup, ut_teardown,
12565                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12566                 TEST_CASE_ST(ut_setup, ut_teardown,
12567                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12568
12569                 /** Mixed CIPHER + HASH algorithms */
12570                 /** AUTH AES CMAC + CIPHER AES CTR */
12571                 TEST_CASE_ST(ut_setup, ut_teardown,
12572                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
12573                 TEST_CASE_ST(ut_setup, ut_teardown,
12574                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
12575                 TEST_CASE_ST(ut_setup, ut_teardown,
12576                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
12577                 TEST_CASE_ST(ut_setup, ut_teardown,
12578                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
12579                 TEST_CASE_ST(ut_setup, ut_teardown,
12580                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
12581                 TEST_CASE_ST(ut_setup, ut_teardown,
12582                        test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
12583                 TEST_CASE_ST(ut_setup, ut_teardown,
12584                        test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
12585                 TEST_CASE_ST(ut_setup, ut_teardown,
12586                    test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
12587
12588                 /** AUTH ZUC + CIPHER SNOW3G */
12589                 TEST_CASE_ST(ut_setup, ut_teardown,
12590                         test_auth_zuc_cipher_snow_test_case_1),
12591                 TEST_CASE_ST(ut_setup, ut_teardown,
12592                         test_verify_auth_zuc_cipher_snow_test_case_1),
12593                 /** AUTH AES CMAC + CIPHER SNOW3G */
12594                 TEST_CASE_ST(ut_setup, ut_teardown,
12595                         test_auth_aes_cmac_cipher_snow_test_case_1),
12596                 TEST_CASE_ST(ut_setup, ut_teardown,
12597                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
12598                 /** AUTH ZUC + CIPHER AES CTR */
12599                 TEST_CASE_ST(ut_setup, ut_teardown,
12600                         test_auth_zuc_cipher_aes_ctr_test_case_1),
12601                 TEST_CASE_ST(ut_setup, ut_teardown,
12602                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
12603                 /** AUTH SNOW3G + CIPHER AES CTR */
12604                 TEST_CASE_ST(ut_setup, ut_teardown,
12605                         test_auth_snow_cipher_aes_ctr_test_case_1),
12606                 TEST_CASE_ST(ut_setup, ut_teardown,
12607                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
12608                 /** AUTH SNOW3G + CIPHER ZUC */
12609                 TEST_CASE_ST(ut_setup, ut_teardown,
12610                         test_auth_snow_cipher_zuc_test_case_1),
12611                 TEST_CASE_ST(ut_setup, ut_teardown,
12612                         test_verify_auth_snow_cipher_zuc_test_case_1),
12613                 /** AUTH AES CMAC + CIPHER ZUC */
12614                 TEST_CASE_ST(ut_setup, ut_teardown,
12615                         test_auth_aes_cmac_cipher_zuc_test_case_1),
12616                 TEST_CASE_ST(ut_setup, ut_teardown,
12617                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
12618
12619                 /** AUTH NULL + CIPHER SNOW3G */
12620                 TEST_CASE_ST(ut_setup, ut_teardown,
12621                         test_auth_null_cipher_snow_test_case_1),
12622                 TEST_CASE_ST(ut_setup, ut_teardown,
12623                         test_verify_auth_null_cipher_snow_test_case_1),
12624                 /** AUTH NULL + CIPHER ZUC */
12625                 TEST_CASE_ST(ut_setup, ut_teardown,
12626                         test_auth_null_cipher_zuc_test_case_1),
12627                 TEST_CASE_ST(ut_setup, ut_teardown,
12628                         test_verify_auth_null_cipher_zuc_test_case_1),
12629                 /** AUTH SNOW3G + CIPHER NULL */
12630                 TEST_CASE_ST(ut_setup, ut_teardown,
12631                         test_auth_snow_cipher_null_test_case_1),
12632                 TEST_CASE_ST(ut_setup, ut_teardown,
12633                         test_verify_auth_snow_cipher_null_test_case_1),
12634                 /** AUTH ZUC + CIPHER NULL */
12635                 TEST_CASE_ST(ut_setup, ut_teardown,
12636                         test_auth_zuc_cipher_null_test_case_1),
12637                 TEST_CASE_ST(ut_setup, ut_teardown,
12638                         test_verify_auth_zuc_cipher_null_test_case_1),
12639                 /** AUTH NULL + CIPHER AES CTR */
12640                 TEST_CASE_ST(ut_setup, ut_teardown,
12641                         test_auth_null_cipher_aes_ctr_test_case_1),
12642                 TEST_CASE_ST(ut_setup, ut_teardown,
12643                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
12644                 /** AUTH AES CMAC + CIPHER NULL */
12645                 TEST_CASE_ST(ut_setup, ut_teardown,
12646                         test_auth_aes_cmac_cipher_null_test_case_1),
12647                 TEST_CASE_ST(ut_setup, ut_teardown,
12648                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
12649
12650                 TEST_CASES_END() /**< NULL terminate unit test array */
12651         }
12652 };
12653
12654 static struct unit_test_suite cryptodev_virtio_testsuite = {
12655         .suite_name = "Crypto VIRTIO Unit Test Suite",
12656         .setup = testsuite_setup,
12657         .teardown = testsuite_teardown,
12658         .unit_test_cases = {
12659                 TEST_CASE_ST(ut_setup, ut_teardown,
12660                                 test_AES_cipheronly_virtio_all),
12661
12662                 TEST_CASES_END() /**< NULL terminate unit test array */
12663         }
12664 };
12665
12666 static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
12667         .suite_name = "Crypto Device AESNI MB Unit Test Suite",
12668         .setup = testsuite_setup,
12669         .teardown = testsuite_teardown,
12670         .unit_test_cases = {
12671 #if IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0)
12672                 TEST_CASE_ST(ut_setup, ut_teardown,
12673                         test_AES_GCM_authenticated_encryption_test_case_1),
12674                 TEST_CASE_ST(ut_setup, ut_teardown,
12675                         test_AES_GCM_authenticated_encryption_test_case_2),
12676                 TEST_CASE_ST(ut_setup, ut_teardown,
12677                         test_AES_GCM_authenticated_encryption_test_case_3),
12678                 TEST_CASE_ST(ut_setup, ut_teardown,
12679                         test_AES_GCM_authenticated_encryption_test_case_4),
12680                 TEST_CASE_ST(ut_setup, ut_teardown,
12681                         test_AES_GCM_authenticated_encryption_test_case_5),
12682                 TEST_CASE_ST(ut_setup, ut_teardown,
12683                         test_AES_GCM_authenticated_encryption_test_case_6),
12684                 TEST_CASE_ST(ut_setup, ut_teardown,
12685                         test_AES_GCM_authenticated_encryption_test_case_7),
12686
12687                 /** AES GCM Authenticated Decryption */
12688                 TEST_CASE_ST(ut_setup, ut_teardown,
12689                         test_AES_GCM_authenticated_decryption_test_case_1),
12690                 TEST_CASE_ST(ut_setup, ut_teardown,
12691                         test_AES_GCM_authenticated_decryption_test_case_2),
12692                 TEST_CASE_ST(ut_setup, ut_teardown,
12693                         test_AES_GCM_authenticated_decryption_test_case_3),
12694                 TEST_CASE_ST(ut_setup, ut_teardown,
12695                         test_AES_GCM_authenticated_decryption_test_case_4),
12696                 TEST_CASE_ST(ut_setup, ut_teardown,
12697                         test_AES_GCM_authenticated_decryption_test_case_5),
12698                 TEST_CASE_ST(ut_setup, ut_teardown,
12699                         test_AES_GCM_authenticated_decryption_test_case_6),
12700                 TEST_CASE_ST(ut_setup, ut_teardown,
12701                         test_AES_GCM_authenticated_decryption_test_case_7),
12702
12703                 /** AES GCM Authenticated Encryption 192 bits key */
12704                 TEST_CASE_ST(ut_setup, ut_teardown,
12705                         test_AES_GCM_auth_encryption_test_case_192_1),
12706                 TEST_CASE_ST(ut_setup, ut_teardown,
12707                         test_AES_GCM_auth_encryption_test_case_192_2),
12708                 TEST_CASE_ST(ut_setup, ut_teardown,
12709                         test_AES_GCM_auth_encryption_test_case_192_3),
12710                 TEST_CASE_ST(ut_setup, ut_teardown,
12711                         test_AES_GCM_auth_encryption_test_case_192_4),
12712                 TEST_CASE_ST(ut_setup, ut_teardown,
12713                         test_AES_GCM_auth_encryption_test_case_192_5),
12714                 TEST_CASE_ST(ut_setup, ut_teardown,
12715                         test_AES_GCM_auth_encryption_test_case_192_6),
12716                 TEST_CASE_ST(ut_setup, ut_teardown,
12717                         test_AES_GCM_auth_encryption_test_case_192_7),
12718
12719                 /** AES GCM Authenticated Decryption 192 bits key */
12720                 TEST_CASE_ST(ut_setup, ut_teardown,
12721                         test_AES_GCM_auth_decryption_test_case_192_1),
12722                 TEST_CASE_ST(ut_setup, ut_teardown,
12723                         test_AES_GCM_auth_decryption_test_case_192_2),
12724                 TEST_CASE_ST(ut_setup, ut_teardown,
12725                         test_AES_GCM_auth_decryption_test_case_192_3),
12726                 TEST_CASE_ST(ut_setup, ut_teardown,
12727                         test_AES_GCM_auth_decryption_test_case_192_4),
12728                 TEST_CASE_ST(ut_setup, ut_teardown,
12729                         test_AES_GCM_auth_decryption_test_case_192_5),
12730                 TEST_CASE_ST(ut_setup, ut_teardown,
12731                         test_AES_GCM_auth_decryption_test_case_192_6),
12732                 TEST_CASE_ST(ut_setup, ut_teardown,
12733                         test_AES_GCM_auth_decryption_test_case_192_7),
12734
12735                 /** AES GCM Authenticated Encryption 256 bits key */
12736                 TEST_CASE_ST(ut_setup, ut_teardown,
12737                         test_AES_GCM_auth_encryption_test_case_256_1),
12738                 TEST_CASE_ST(ut_setup, ut_teardown,
12739                         test_AES_GCM_auth_encryption_test_case_256_2),
12740                 TEST_CASE_ST(ut_setup, ut_teardown,
12741                         test_AES_GCM_auth_encryption_test_case_256_3),
12742                 TEST_CASE_ST(ut_setup, ut_teardown,
12743                         test_AES_GCM_auth_encryption_test_case_256_4),
12744                 TEST_CASE_ST(ut_setup, ut_teardown,
12745                         test_AES_GCM_auth_encryption_test_case_256_5),
12746                 TEST_CASE_ST(ut_setup, ut_teardown,
12747                         test_AES_GCM_auth_encryption_test_case_256_6),
12748                 TEST_CASE_ST(ut_setup, ut_teardown,
12749                         test_AES_GCM_auth_encryption_test_case_256_7),
12750
12751                 /** AES GCM Authenticated Decryption 256 bits key */
12752                 TEST_CASE_ST(ut_setup, ut_teardown,
12753                         test_AES_GCM_auth_decryption_test_case_256_1),
12754                 TEST_CASE_ST(ut_setup, ut_teardown,
12755                         test_AES_GCM_auth_decryption_test_case_256_2),
12756                 TEST_CASE_ST(ut_setup, ut_teardown,
12757                         test_AES_GCM_auth_decryption_test_case_256_3),
12758                 TEST_CASE_ST(ut_setup, ut_teardown,
12759                         test_AES_GCM_auth_decryption_test_case_256_4),
12760                 TEST_CASE_ST(ut_setup, ut_teardown,
12761                         test_AES_GCM_auth_decryption_test_case_256_5),
12762                 TEST_CASE_ST(ut_setup, ut_teardown,
12763                         test_AES_GCM_auth_decryption_test_case_256_6),
12764                 TEST_CASE_ST(ut_setup, ut_teardown,
12765                         test_AES_GCM_auth_decryption_test_case_256_7),
12766
12767                 /** AES GCM Authenticated Encryption big aad size */
12768                 TEST_CASE_ST(ut_setup, ut_teardown,
12769                         test_AES_GCM_auth_encryption_test_case_aad_1),
12770                 TEST_CASE_ST(ut_setup, ut_teardown,
12771                         test_AES_GCM_auth_encryption_test_case_aad_2),
12772
12773                 /** AES GCM Authenticated Decryption big aad size */
12774                 TEST_CASE_ST(ut_setup, ut_teardown,
12775                         test_AES_GCM_auth_decryption_test_case_aad_1),
12776                 TEST_CASE_ST(ut_setup, ut_teardown,
12777                         test_AES_GCM_auth_decryption_test_case_aad_2),
12778
12779                 /** Session-less tests */
12780                 TEST_CASE_ST(ut_setup, ut_teardown,
12781                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
12782                 TEST_CASE_ST(ut_setup, ut_teardown,
12783                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
12784
12785                 /** AES GMAC Authentication */
12786                 TEST_CASE_ST(ut_setup, ut_teardown,
12787                         test_AES_GMAC_authentication_test_case_1),
12788                 TEST_CASE_ST(ut_setup, ut_teardown,
12789                         test_AES_GMAC_authentication_verify_test_case_1),
12790                 TEST_CASE_ST(ut_setup, ut_teardown,
12791                         test_AES_GMAC_authentication_test_case_2),
12792                 TEST_CASE_ST(ut_setup, ut_teardown,
12793                         test_AES_GMAC_authentication_verify_test_case_2),
12794                 TEST_CASE_ST(ut_setup, ut_teardown,
12795                         test_AES_GMAC_authentication_test_case_3),
12796                 TEST_CASE_ST(ut_setup, ut_teardown,
12797                         test_AES_GMAC_authentication_verify_test_case_3),
12798 #endif /* IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0) */
12799
12800                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
12801                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all),
12802                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all),
12803                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all),
12804                 TEST_CASE_ST(ut_setup, ut_teardown,
12805                                                 test_DES_cipheronly_mb_all),
12806                 TEST_CASE_ST(ut_setup, ut_teardown,
12807                                                 test_DES_docsis_mb_all),
12808                 TEST_CASE_ST(ut_setup, ut_teardown,
12809                                                 test_3DES_cipheronly_mb_all),
12810                 TEST_CASE_ST(ut_setup, ut_teardown,
12811                         test_AES_CCM_authenticated_encryption_test_case_128_1),
12812                 TEST_CASE_ST(ut_setup, ut_teardown,
12813                         test_AES_CCM_authenticated_decryption_test_case_128_1),
12814                 TEST_CASE_ST(ut_setup, ut_teardown,
12815                         test_AES_CCM_authenticated_encryption_test_case_128_2),
12816                 TEST_CASE_ST(ut_setup, ut_teardown,
12817                         test_AES_CCM_authenticated_decryption_test_case_128_2),
12818                 TEST_CASE_ST(ut_setup, ut_teardown,
12819                         test_AES_CCM_authenticated_encryption_test_case_128_3),
12820                 TEST_CASE_ST(ut_setup, ut_teardown,
12821                         test_AES_CCM_authenticated_decryption_test_case_128_3),
12822
12823                 TEST_CASES_END() /**< NULL terminate unit test array */
12824         }
12825 };
12826
12827 static struct unit_test_suite cryptodev_openssl_testsuite  = {
12828         .suite_name = "Crypto Device OPENSSL Unit Test Suite",
12829         .setup = testsuite_setup,
12830         .teardown = testsuite_teardown,
12831         .unit_test_cases = {
12832                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
12833                 TEST_CASE_ST(ut_setup, ut_teardown,
12834                                 test_multi_session_random_usage),
12835                 TEST_CASE_ST(ut_setup, ut_teardown,
12836                                 test_AES_chain_openssl_all),
12837                 TEST_CASE_ST(ut_setup, ut_teardown,
12838                                 test_AES_cipheronly_openssl_all),
12839                 TEST_CASE_ST(ut_setup, ut_teardown,
12840                                 test_3DES_chain_openssl_all),
12841                 TEST_CASE_ST(ut_setup, ut_teardown,
12842                                 test_3DES_cipheronly_openssl_all),
12843                 TEST_CASE_ST(ut_setup, ut_teardown,
12844                                 test_DES_cipheronly_openssl_all),
12845                 TEST_CASE_ST(ut_setup, ut_teardown,
12846                                 test_DES_docsis_openssl_all),
12847                 TEST_CASE_ST(ut_setup, ut_teardown,
12848                                 test_authonly_openssl_all),
12849
12850                 /** AES GCM Authenticated Encryption */
12851                 TEST_CASE_ST(ut_setup, ut_teardown,
12852                         test_AES_GCM_authenticated_encryption_test_case_1),
12853                 TEST_CASE_ST(ut_setup, ut_teardown,
12854                         test_AES_GCM_authenticated_encryption_test_case_2),
12855                 TEST_CASE_ST(ut_setup, ut_teardown,
12856                         test_AES_GCM_authenticated_encryption_test_case_3),
12857                 TEST_CASE_ST(ut_setup, ut_teardown,
12858                         test_AES_GCM_authenticated_encryption_test_case_4),
12859                 TEST_CASE_ST(ut_setup, ut_teardown,
12860                         test_AES_GCM_authenticated_encryption_test_case_5),
12861                 TEST_CASE_ST(ut_setup, ut_teardown,
12862                         test_AES_GCM_authenticated_encryption_test_case_6),
12863                 TEST_CASE_ST(ut_setup, ut_teardown,
12864                         test_AES_GCM_authenticated_encryption_test_case_7),
12865
12866                 /** AES GCM Authenticated Decryption */
12867                 TEST_CASE_ST(ut_setup, ut_teardown,
12868                         test_AES_GCM_authenticated_decryption_test_case_1),
12869                 TEST_CASE_ST(ut_setup, ut_teardown,
12870                         test_AES_GCM_authenticated_decryption_test_case_2),
12871                 TEST_CASE_ST(ut_setup, ut_teardown,
12872                         test_AES_GCM_authenticated_decryption_test_case_3),
12873                 TEST_CASE_ST(ut_setup, ut_teardown,
12874                         test_AES_GCM_authenticated_decryption_test_case_4),
12875                 TEST_CASE_ST(ut_setup, ut_teardown,
12876                         test_AES_GCM_authenticated_decryption_test_case_5),
12877                 TEST_CASE_ST(ut_setup, ut_teardown,
12878                         test_AES_GCM_authenticated_decryption_test_case_6),
12879                 TEST_CASE_ST(ut_setup, ut_teardown,
12880                         test_AES_GCM_authenticated_decryption_test_case_7),
12881
12882
12883                 /** AES GCM Authenticated Encryption 192 bits key */
12884                 TEST_CASE_ST(ut_setup, ut_teardown,
12885                         test_AES_GCM_auth_encryption_test_case_192_1),
12886                 TEST_CASE_ST(ut_setup, ut_teardown,
12887                         test_AES_GCM_auth_encryption_test_case_192_2),
12888                 TEST_CASE_ST(ut_setup, ut_teardown,
12889                         test_AES_GCM_auth_encryption_test_case_192_3),
12890                 TEST_CASE_ST(ut_setup, ut_teardown,
12891                         test_AES_GCM_auth_encryption_test_case_192_4),
12892                 TEST_CASE_ST(ut_setup, ut_teardown,
12893                         test_AES_GCM_auth_encryption_test_case_192_5),
12894                 TEST_CASE_ST(ut_setup, ut_teardown,
12895                         test_AES_GCM_auth_encryption_test_case_192_6),
12896                 TEST_CASE_ST(ut_setup, ut_teardown,
12897                         test_AES_GCM_auth_encryption_test_case_192_7),
12898
12899                 /** AES GCM Authenticated Decryption 192 bits key */
12900                 TEST_CASE_ST(ut_setup, ut_teardown,
12901                         test_AES_GCM_auth_decryption_test_case_192_1),
12902                 TEST_CASE_ST(ut_setup, ut_teardown,
12903                         test_AES_GCM_auth_decryption_test_case_192_2),
12904                 TEST_CASE_ST(ut_setup, ut_teardown,
12905                         test_AES_GCM_auth_decryption_test_case_192_3),
12906                 TEST_CASE_ST(ut_setup, ut_teardown,
12907                         test_AES_GCM_auth_decryption_test_case_192_4),
12908                 TEST_CASE_ST(ut_setup, ut_teardown,
12909                         test_AES_GCM_auth_decryption_test_case_192_5),
12910                 TEST_CASE_ST(ut_setup, ut_teardown,
12911                         test_AES_GCM_auth_decryption_test_case_192_6),
12912                 TEST_CASE_ST(ut_setup, ut_teardown,
12913                         test_AES_GCM_auth_decryption_test_case_192_7),
12914
12915                 /** AES GCM Authenticated Encryption 256 bits key */
12916                 TEST_CASE_ST(ut_setup, ut_teardown,
12917                         test_AES_GCM_auth_encryption_test_case_256_1),
12918                 TEST_CASE_ST(ut_setup, ut_teardown,
12919                         test_AES_GCM_auth_encryption_test_case_256_2),
12920                 TEST_CASE_ST(ut_setup, ut_teardown,
12921                         test_AES_GCM_auth_encryption_test_case_256_3),
12922                 TEST_CASE_ST(ut_setup, ut_teardown,
12923                         test_AES_GCM_auth_encryption_test_case_256_4),
12924                 TEST_CASE_ST(ut_setup, ut_teardown,
12925                         test_AES_GCM_auth_encryption_test_case_256_5),
12926                 TEST_CASE_ST(ut_setup, ut_teardown,
12927                         test_AES_GCM_auth_encryption_test_case_256_6),
12928                 TEST_CASE_ST(ut_setup, ut_teardown,
12929                         test_AES_GCM_auth_encryption_test_case_256_7),
12930
12931                 /** AES GCM Authenticated Decryption 256 bits key */
12932                 TEST_CASE_ST(ut_setup, ut_teardown,
12933                         test_AES_GCM_auth_decryption_test_case_256_1),
12934                 TEST_CASE_ST(ut_setup, ut_teardown,
12935                         test_AES_GCM_auth_decryption_test_case_256_2),
12936                 TEST_CASE_ST(ut_setup, ut_teardown,
12937                         test_AES_GCM_auth_decryption_test_case_256_3),
12938                 TEST_CASE_ST(ut_setup, ut_teardown,
12939                         test_AES_GCM_auth_decryption_test_case_256_4),
12940                 TEST_CASE_ST(ut_setup, ut_teardown,
12941                         test_AES_GCM_auth_decryption_test_case_256_5),
12942                 TEST_CASE_ST(ut_setup, ut_teardown,
12943                         test_AES_GCM_auth_decryption_test_case_256_6),
12944                 TEST_CASE_ST(ut_setup, ut_teardown,
12945                         test_AES_GCM_auth_decryption_test_case_256_7),
12946
12947                 /** AES GMAC Authentication */
12948                 TEST_CASE_ST(ut_setup, ut_teardown,
12949                         test_AES_GMAC_authentication_test_case_1),
12950                 TEST_CASE_ST(ut_setup, ut_teardown,
12951                         test_AES_GMAC_authentication_verify_test_case_1),
12952                 TEST_CASE_ST(ut_setup, ut_teardown,
12953                         test_AES_GMAC_authentication_test_case_2),
12954                 TEST_CASE_ST(ut_setup, ut_teardown,
12955                         test_AES_GMAC_authentication_verify_test_case_2),
12956                 TEST_CASE_ST(ut_setup, ut_teardown,
12957                         test_AES_GMAC_authentication_test_case_3),
12958                 TEST_CASE_ST(ut_setup, ut_teardown,
12959                         test_AES_GMAC_authentication_verify_test_case_3),
12960                 TEST_CASE_ST(ut_setup, ut_teardown,
12961                         test_AES_GMAC_authentication_test_case_4),
12962                 TEST_CASE_ST(ut_setup, ut_teardown,
12963                         test_AES_GMAC_authentication_verify_test_case_4),
12964
12965                 /** AES CCM Authenticated Encryption 128 bits key */
12966                 TEST_CASE_ST(ut_setup, ut_teardown,
12967                         test_AES_CCM_authenticated_encryption_test_case_128_1),
12968                 TEST_CASE_ST(ut_setup, ut_teardown,
12969                         test_AES_CCM_authenticated_encryption_test_case_128_2),
12970                 TEST_CASE_ST(ut_setup, ut_teardown,
12971                         test_AES_CCM_authenticated_encryption_test_case_128_3),
12972
12973                 /** AES CCM Authenticated Decryption 128 bits key*/
12974                 TEST_CASE_ST(ut_setup, ut_teardown,
12975                         test_AES_CCM_authenticated_decryption_test_case_128_1),
12976                 TEST_CASE_ST(ut_setup, ut_teardown,
12977                         test_AES_CCM_authenticated_decryption_test_case_128_2),
12978                 TEST_CASE_ST(ut_setup, ut_teardown,
12979                         test_AES_CCM_authenticated_decryption_test_case_128_3),
12980
12981                 /** AES CCM Authenticated Encryption 192 bits key */
12982                 TEST_CASE_ST(ut_setup, ut_teardown,
12983                         test_AES_CCM_authenticated_encryption_test_case_192_1),
12984                 TEST_CASE_ST(ut_setup, ut_teardown,
12985                         test_AES_CCM_authenticated_encryption_test_case_192_2),
12986                 TEST_CASE_ST(ut_setup, ut_teardown,
12987                         test_AES_CCM_authenticated_encryption_test_case_192_3),
12988
12989                 /** AES CCM Authenticated Decryption 192 bits key*/
12990                 TEST_CASE_ST(ut_setup, ut_teardown,
12991                         test_AES_CCM_authenticated_decryption_test_case_192_1),
12992                 TEST_CASE_ST(ut_setup, ut_teardown,
12993                         test_AES_CCM_authenticated_decryption_test_case_192_2),
12994                 TEST_CASE_ST(ut_setup, ut_teardown,
12995                         test_AES_CCM_authenticated_decryption_test_case_192_3),
12996
12997                 /** AES CCM Authenticated Encryption 256 bits key */
12998                 TEST_CASE_ST(ut_setup, ut_teardown,
12999                         test_AES_CCM_authenticated_encryption_test_case_256_1),
13000                 TEST_CASE_ST(ut_setup, ut_teardown,
13001                         test_AES_CCM_authenticated_encryption_test_case_256_2),
13002                 TEST_CASE_ST(ut_setup, ut_teardown,
13003                         test_AES_CCM_authenticated_encryption_test_case_256_3),
13004
13005                 /** AES CCM Authenticated Decryption 256 bits key*/
13006                 TEST_CASE_ST(ut_setup, ut_teardown,
13007                         test_AES_CCM_authenticated_decryption_test_case_256_1),
13008                 TEST_CASE_ST(ut_setup, ut_teardown,
13009                         test_AES_CCM_authenticated_decryption_test_case_256_2),
13010                 TEST_CASE_ST(ut_setup, ut_teardown,
13011                         test_AES_CCM_authenticated_decryption_test_case_256_3),
13012
13013                 /** Scatter-Gather */
13014                 TEST_CASE_ST(ut_setup, ut_teardown,
13015                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
13016
13017                 /** Negative tests */
13018                 TEST_CASE_ST(ut_setup, ut_teardown,
13019                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13020                 TEST_CASE_ST(ut_setup, ut_teardown,
13021                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13022                 TEST_CASE_ST(ut_setup, ut_teardown,
13023                         authentication_verify_AES128_GMAC_fail_data_corrupt),
13024                 TEST_CASE_ST(ut_setup, ut_teardown,
13025                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
13026                 TEST_CASE_ST(ut_setup, ut_teardown,
13027                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13028                 TEST_CASE_ST(ut_setup, ut_teardown,
13029                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13030
13031                 /* ESN Testcase */
13032                 TEST_CASE_ST(ut_setup, ut_teardown,
13033                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
13034
13035                 TEST_CASE_ST(ut_setup, ut_teardown,
13036                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
13037
13038                 TEST_CASES_END() /**< NULL terminate unit test array */
13039         }
13040 };
13041
13042 static struct unit_test_suite cryptodev_aesni_gcm_testsuite  = {
13043         .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
13044         .setup = testsuite_setup,
13045         .teardown = testsuite_teardown,
13046         .unit_test_cases = {
13047                 /** AES GCM Authenticated Encryption */
13048                 TEST_CASE_ST(ut_setup, ut_teardown,
13049                         test_AES_GCM_authenticated_encryption_test_case_1),
13050                 TEST_CASE_ST(ut_setup, ut_teardown,
13051                         test_AES_GCM_authenticated_encryption_test_case_2),
13052                 TEST_CASE_ST(ut_setup, ut_teardown,
13053                         test_AES_GCM_authenticated_encryption_test_case_3),
13054                 TEST_CASE_ST(ut_setup, ut_teardown,
13055                         test_AES_GCM_authenticated_encryption_test_case_4),
13056                 TEST_CASE_ST(ut_setup, ut_teardown,
13057                         test_AES_GCM_authenticated_encryption_test_case_5),
13058                 TEST_CASE_ST(ut_setup, ut_teardown,
13059                         test_AES_GCM_authenticated_encryption_test_case_6),
13060                 TEST_CASE_ST(ut_setup, ut_teardown,
13061                         test_AES_GCM_authenticated_encryption_test_case_7),
13062
13063                 /** AES GCM Authenticated Decryption */
13064                 TEST_CASE_ST(ut_setup, ut_teardown,
13065                         test_AES_GCM_authenticated_decryption_test_case_1),
13066                 TEST_CASE_ST(ut_setup, ut_teardown,
13067                         test_AES_GCM_authenticated_decryption_test_case_2),
13068                 TEST_CASE_ST(ut_setup, ut_teardown,
13069                         test_AES_GCM_authenticated_decryption_test_case_3),
13070                 TEST_CASE_ST(ut_setup, ut_teardown,
13071                         test_AES_GCM_authenticated_decryption_test_case_4),
13072                 TEST_CASE_ST(ut_setup, ut_teardown,
13073                         test_AES_GCM_authenticated_decryption_test_case_5),
13074                 TEST_CASE_ST(ut_setup, ut_teardown,
13075                         test_AES_GCM_authenticated_decryption_test_case_6),
13076                 TEST_CASE_ST(ut_setup, ut_teardown,
13077                         test_AES_GCM_authenticated_decryption_test_case_7),
13078
13079                 /** AES GCM Authenticated Encryption 192 bits key */
13080                 TEST_CASE_ST(ut_setup, ut_teardown,
13081                         test_AES_GCM_auth_encryption_test_case_192_1),
13082                 TEST_CASE_ST(ut_setup, ut_teardown,
13083                         test_AES_GCM_auth_encryption_test_case_192_2),
13084                 TEST_CASE_ST(ut_setup, ut_teardown,
13085                         test_AES_GCM_auth_encryption_test_case_192_3),
13086                 TEST_CASE_ST(ut_setup, ut_teardown,
13087                         test_AES_GCM_auth_encryption_test_case_192_4),
13088                 TEST_CASE_ST(ut_setup, ut_teardown,
13089                         test_AES_GCM_auth_encryption_test_case_192_5),
13090                 TEST_CASE_ST(ut_setup, ut_teardown,
13091                         test_AES_GCM_auth_encryption_test_case_192_6),
13092                 TEST_CASE_ST(ut_setup, ut_teardown,
13093                         test_AES_GCM_auth_encryption_test_case_192_7),
13094
13095                 /** AES GCM Authenticated Decryption 192 bits key */
13096                 TEST_CASE_ST(ut_setup, ut_teardown,
13097                         test_AES_GCM_auth_decryption_test_case_192_1),
13098                 TEST_CASE_ST(ut_setup, ut_teardown,
13099                         test_AES_GCM_auth_decryption_test_case_192_2),
13100                 TEST_CASE_ST(ut_setup, ut_teardown,
13101                         test_AES_GCM_auth_decryption_test_case_192_3),
13102                 TEST_CASE_ST(ut_setup, ut_teardown,
13103                         test_AES_GCM_auth_decryption_test_case_192_4),
13104                 TEST_CASE_ST(ut_setup, ut_teardown,
13105                         test_AES_GCM_auth_decryption_test_case_192_5),
13106                 TEST_CASE_ST(ut_setup, ut_teardown,
13107                         test_AES_GCM_auth_decryption_test_case_192_6),
13108                 TEST_CASE_ST(ut_setup, ut_teardown,
13109                         test_AES_GCM_auth_decryption_test_case_192_7),
13110
13111                 /** AES GCM Authenticated Encryption 256 bits key */
13112                 TEST_CASE_ST(ut_setup, ut_teardown,
13113                         test_AES_GCM_auth_encryption_test_case_256_1),
13114                 TEST_CASE_ST(ut_setup, ut_teardown,
13115                         test_AES_GCM_auth_encryption_test_case_256_2),
13116                 TEST_CASE_ST(ut_setup, ut_teardown,
13117                         test_AES_GCM_auth_encryption_test_case_256_3),
13118                 TEST_CASE_ST(ut_setup, ut_teardown,
13119                         test_AES_GCM_auth_encryption_test_case_256_4),
13120                 TEST_CASE_ST(ut_setup, ut_teardown,
13121                         test_AES_GCM_auth_encryption_test_case_256_5),
13122                 TEST_CASE_ST(ut_setup, ut_teardown,
13123                         test_AES_GCM_auth_encryption_test_case_256_6),
13124                 TEST_CASE_ST(ut_setup, ut_teardown,
13125                         test_AES_GCM_auth_encryption_test_case_256_7),
13126
13127                 /** AES GCM Authenticated Decryption 256 bits key */
13128                 TEST_CASE_ST(ut_setup, ut_teardown,
13129                         test_AES_GCM_auth_decryption_test_case_256_1),
13130                 TEST_CASE_ST(ut_setup, ut_teardown,
13131                         test_AES_GCM_auth_decryption_test_case_256_2),
13132                 TEST_CASE_ST(ut_setup, ut_teardown,
13133                         test_AES_GCM_auth_decryption_test_case_256_3),
13134                 TEST_CASE_ST(ut_setup, ut_teardown,
13135                         test_AES_GCM_auth_decryption_test_case_256_4),
13136                 TEST_CASE_ST(ut_setup, ut_teardown,
13137                         test_AES_GCM_auth_decryption_test_case_256_5),
13138                 TEST_CASE_ST(ut_setup, ut_teardown,
13139                         test_AES_GCM_auth_decryption_test_case_256_6),
13140                 TEST_CASE_ST(ut_setup, ut_teardown,
13141                         test_AES_GCM_auth_decryption_test_case_256_7),
13142
13143                 /** AES GCM Authenticated Encryption big aad size */
13144                 TEST_CASE_ST(ut_setup, ut_teardown,
13145                         test_AES_GCM_auth_encryption_test_case_aad_1),
13146                 TEST_CASE_ST(ut_setup, ut_teardown,
13147                         test_AES_GCM_auth_encryption_test_case_aad_2),
13148
13149                 /** AES GCM Authenticated Decryption big aad size */
13150                 TEST_CASE_ST(ut_setup, ut_teardown,
13151                         test_AES_GCM_auth_decryption_test_case_aad_1),
13152                 TEST_CASE_ST(ut_setup, ut_teardown,
13153                         test_AES_GCM_auth_decryption_test_case_aad_2),
13154
13155                 /** AES GMAC Authentication */
13156                 TEST_CASE_ST(ut_setup, ut_teardown,
13157                         test_AES_GMAC_authentication_test_case_1),
13158                 TEST_CASE_ST(ut_setup, ut_teardown,
13159                         test_AES_GMAC_authentication_verify_test_case_1),
13160                 TEST_CASE_ST(ut_setup, ut_teardown,
13161                         test_AES_GMAC_authentication_test_case_3),
13162                 TEST_CASE_ST(ut_setup, ut_teardown,
13163                         test_AES_GMAC_authentication_verify_test_case_3),
13164                 TEST_CASE_ST(ut_setup, ut_teardown,
13165                         test_AES_GMAC_authentication_test_case_4),
13166                 TEST_CASE_ST(ut_setup, ut_teardown,
13167                         test_AES_GMAC_authentication_verify_test_case_4),
13168
13169                 /** Negative tests */
13170                 TEST_CASE_ST(ut_setup, ut_teardown,
13171                         authentication_verify_AES128_GMAC_fail_data_corrupt),
13172                 TEST_CASE_ST(ut_setup, ut_teardown,
13173                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
13174
13175                 /** Out of place tests */
13176                 TEST_CASE_ST(ut_setup, ut_teardown,
13177                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
13178                 TEST_CASE_ST(ut_setup, ut_teardown,
13179                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
13180
13181                 /** Session-less tests */
13182                 TEST_CASE_ST(ut_setup, ut_teardown,
13183                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
13184                 TEST_CASE_ST(ut_setup, ut_teardown,
13185                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
13186
13187                 /** Scatter-Gather */
13188                 TEST_CASE_ST(ut_setup, ut_teardown,
13189                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
13190                 TEST_CASE_ST(ut_setup, ut_teardown,
13191                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
13192
13193                 TEST_CASES_END() /**< NULL terminate unit test array */
13194         }
13195 };
13196
13197 static struct unit_test_suite cryptodev_sw_kasumi_testsuite  = {
13198         .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
13199         .setup = testsuite_setup,
13200         .teardown = testsuite_teardown,
13201         .unit_test_cases = {
13202                 /** KASUMI encrypt only (UEA1) */
13203                 TEST_CASE_ST(ut_setup, ut_teardown,
13204                         test_kasumi_encryption_test_case_1),
13205                 TEST_CASE_ST(ut_setup, ut_teardown,
13206                         test_kasumi_encryption_test_case_1_sgl),
13207                 TEST_CASE_ST(ut_setup, ut_teardown,
13208                         test_kasumi_encryption_test_case_2),
13209                 TEST_CASE_ST(ut_setup, ut_teardown,
13210                         test_kasumi_encryption_test_case_3),
13211                 TEST_CASE_ST(ut_setup, ut_teardown,
13212                         test_kasumi_encryption_test_case_4),
13213                 TEST_CASE_ST(ut_setup, ut_teardown,
13214                         test_kasumi_encryption_test_case_5),
13215                 /** KASUMI decrypt only (UEA1) */
13216                 TEST_CASE_ST(ut_setup, ut_teardown,
13217                         test_kasumi_decryption_test_case_1),
13218                 TEST_CASE_ST(ut_setup, ut_teardown,
13219                         test_kasumi_decryption_test_case_2),
13220                 TEST_CASE_ST(ut_setup, ut_teardown,
13221                         test_kasumi_decryption_test_case_3),
13222                 TEST_CASE_ST(ut_setup, ut_teardown,
13223                         test_kasumi_decryption_test_case_4),
13224                 TEST_CASE_ST(ut_setup, ut_teardown,
13225                         test_kasumi_decryption_test_case_5),
13226
13227                 TEST_CASE_ST(ut_setup, ut_teardown,
13228                         test_kasumi_encryption_test_case_1_oop),
13229                 TEST_CASE_ST(ut_setup, ut_teardown,
13230                         test_kasumi_encryption_test_case_1_oop_sgl),
13231
13232
13233                 TEST_CASE_ST(ut_setup, ut_teardown,
13234                         test_kasumi_decryption_test_case_1_oop),
13235
13236                 /** KASUMI hash only (UIA1) */
13237                 TEST_CASE_ST(ut_setup, ut_teardown,
13238                         test_kasumi_hash_generate_test_case_1),
13239                 TEST_CASE_ST(ut_setup, ut_teardown,
13240                         test_kasumi_hash_generate_test_case_2),
13241                 TEST_CASE_ST(ut_setup, ut_teardown,
13242                         test_kasumi_hash_generate_test_case_3),
13243                 TEST_CASE_ST(ut_setup, ut_teardown,
13244                         test_kasumi_hash_generate_test_case_4),
13245                 TEST_CASE_ST(ut_setup, ut_teardown,
13246                         test_kasumi_hash_generate_test_case_5),
13247                 TEST_CASE_ST(ut_setup, ut_teardown,
13248                         test_kasumi_hash_generate_test_case_6),
13249                 TEST_CASE_ST(ut_setup, ut_teardown,
13250                         test_kasumi_hash_verify_test_case_1),
13251                 TEST_CASE_ST(ut_setup, ut_teardown,
13252                         test_kasumi_hash_verify_test_case_2),
13253                 TEST_CASE_ST(ut_setup, ut_teardown,
13254                         test_kasumi_hash_verify_test_case_3),
13255                 TEST_CASE_ST(ut_setup, ut_teardown,
13256                         test_kasumi_hash_verify_test_case_4),
13257                 TEST_CASE_ST(ut_setup, ut_teardown,
13258                         test_kasumi_hash_verify_test_case_5),
13259                 TEST_CASE_ST(ut_setup, ut_teardown,
13260                         test_kasumi_cipher_auth_test_case_1),
13261
13262                 /** KASUMI generate auth, then encrypt (F8) */
13263                 TEST_CASE_ST(ut_setup, ut_teardown,
13264                         test_kasumi_auth_cipher_test_case_1),
13265                 TEST_CASE_ST(ut_setup, ut_teardown,
13266                         test_kasumi_auth_cipher_test_case_2),
13267                 TEST_CASE_ST(ut_setup, ut_teardown,
13268                         test_kasumi_auth_cipher_test_case_2_oop),
13269                 TEST_CASE_ST(ut_setup, ut_teardown,
13270                         test_kasumi_auth_cipher_test_case_2_sgl),
13271                 TEST_CASE_ST(ut_setup, ut_teardown,
13272                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
13273
13274                 /** KASUMI decrypt (F8), then verify auth */
13275                 TEST_CASE_ST(ut_setup, ut_teardown,
13276                         test_kasumi_auth_cipher_verify_test_case_1),
13277                 TEST_CASE_ST(ut_setup, ut_teardown,
13278                         test_kasumi_auth_cipher_verify_test_case_2),
13279                 TEST_CASE_ST(ut_setup, ut_teardown,
13280                         test_kasumi_auth_cipher_verify_test_case_2_oop),
13281                 TEST_CASE_ST(ut_setup, ut_teardown,
13282                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
13283                 TEST_CASE_ST(ut_setup, ut_teardown,
13284                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
13285                 TEST_CASES_END() /**< NULL terminate unit test array */
13286         }
13287 };
13288 static struct unit_test_suite cryptodev_sw_snow3g_testsuite  = {
13289         .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
13290         .setup = testsuite_setup,
13291         .teardown = testsuite_teardown,
13292         .unit_test_cases = {
13293                 /** SNOW 3G encrypt only (UEA2) */
13294                 TEST_CASE_ST(ut_setup, ut_teardown,
13295                         test_snow3g_encryption_test_case_1),
13296                 TEST_CASE_ST(ut_setup, ut_teardown,
13297                         test_snow3g_encryption_test_case_2),
13298                 TEST_CASE_ST(ut_setup, ut_teardown,
13299                         test_snow3g_encryption_test_case_3),
13300                 TEST_CASE_ST(ut_setup, ut_teardown,
13301                         test_snow3g_encryption_test_case_4),
13302                 TEST_CASE_ST(ut_setup, ut_teardown,
13303                         test_snow3g_encryption_test_case_5),
13304                 TEST_CASE_ST(ut_setup, ut_teardown,
13305                         test_snow3g_auth_cipher_with_digest_test_case_1),
13306
13307                 TEST_CASE_ST(ut_setup, ut_teardown,
13308                         test_snow3g_encryption_test_case_1_oop),
13309                 TEST_CASE_ST(ut_setup, ut_teardown,
13310                                 test_snow3g_encryption_test_case_1_oop_sgl),
13311                 TEST_CASE_ST(ut_setup, ut_teardown,
13312                         test_snow3g_decryption_test_case_1_oop),
13313
13314                 TEST_CASE_ST(ut_setup, ut_teardown,
13315                         test_snow3g_encryption_test_case_1_offset_oop),
13316
13317                 /** SNOW 3G decrypt only (UEA2) */
13318                 TEST_CASE_ST(ut_setup, ut_teardown,
13319                         test_snow3g_decryption_test_case_1),
13320                 TEST_CASE_ST(ut_setup, ut_teardown,
13321                         test_snow3g_decryption_test_case_2),
13322                 TEST_CASE_ST(ut_setup, ut_teardown,
13323                         test_snow3g_decryption_test_case_3),
13324                 TEST_CASE_ST(ut_setup, ut_teardown,
13325                         test_snow3g_decryption_test_case_4),
13326                 TEST_CASE_ST(ut_setup, ut_teardown,
13327                         test_snow3g_decryption_test_case_5),
13328                 TEST_CASE_ST(ut_setup, ut_teardown,
13329                         test_snow3g_decryption_with_digest_test_case_1),
13330                 TEST_CASE_ST(ut_setup, ut_teardown,
13331                         test_snow3g_hash_generate_test_case_1),
13332                 TEST_CASE_ST(ut_setup, ut_teardown,
13333                         test_snow3g_hash_generate_test_case_2),
13334                 TEST_CASE_ST(ut_setup, ut_teardown,
13335                         test_snow3g_hash_generate_test_case_3),
13336                 /* Tests with buffers which length is not byte-aligned */
13337                 TEST_CASE_ST(ut_setup, ut_teardown,
13338                         test_snow3g_hash_generate_test_case_4),
13339                 TEST_CASE_ST(ut_setup, ut_teardown,
13340                         test_snow3g_hash_generate_test_case_5),
13341                 TEST_CASE_ST(ut_setup, ut_teardown,
13342                         test_snow3g_hash_generate_test_case_6),
13343                 TEST_CASE_ST(ut_setup, ut_teardown,
13344                         test_snow3g_hash_verify_test_case_1),
13345                 TEST_CASE_ST(ut_setup, ut_teardown,
13346                         test_snow3g_hash_verify_test_case_2),
13347                 TEST_CASE_ST(ut_setup, ut_teardown,
13348                         test_snow3g_hash_verify_test_case_3),
13349                 /* Tests with buffers which length is not byte-aligned */
13350                 TEST_CASE_ST(ut_setup, ut_teardown,
13351                         test_snow3g_hash_verify_test_case_4),
13352                 TEST_CASE_ST(ut_setup, ut_teardown,
13353                         test_snow3g_hash_verify_test_case_5),
13354                 TEST_CASE_ST(ut_setup, ut_teardown,
13355                         test_snow3g_hash_verify_test_case_6),
13356                 TEST_CASE_ST(ut_setup, ut_teardown,
13357                         test_snow3g_cipher_auth_test_case_1),
13358
13359                 /** SNOW 3G generate auth, then encrypt (UEA2) */
13360                 TEST_CASE_ST(ut_setup, ut_teardown,
13361                         test_snow3g_auth_cipher_test_case_1),
13362                 TEST_CASE_ST(ut_setup, ut_teardown,
13363                         test_snow3g_auth_cipher_test_case_2),
13364                 TEST_CASE_ST(ut_setup, ut_teardown,
13365                         test_snow3g_auth_cipher_test_case_2_oop),
13366                 TEST_CASE_ST(ut_setup, ut_teardown,
13367                         test_snow3g_auth_cipher_part_digest_enc),
13368                 TEST_CASE_ST(ut_setup, ut_teardown,
13369                         test_snow3g_auth_cipher_part_digest_enc_oop),
13370                 TEST_CASE_ST(ut_setup, ut_teardown,
13371                         test_snow3g_auth_cipher_test_case_3_sgl),
13372                 TEST_CASE_ST(ut_setup, ut_teardown,
13373                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
13374                 TEST_CASE_ST(ut_setup, ut_teardown,
13375                         test_snow3g_auth_cipher_part_digest_enc_sgl),
13376                 TEST_CASE_ST(ut_setup, ut_teardown,
13377                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
13378
13379                 /** SNOW 3G decrypt (UEA2), then verify auth */
13380                 TEST_CASE_ST(ut_setup, ut_teardown,
13381                         test_snow3g_auth_cipher_verify_test_case_1),
13382                 TEST_CASE_ST(ut_setup, ut_teardown,
13383                         test_snow3g_auth_cipher_verify_test_case_2),
13384                 TEST_CASE_ST(ut_setup, ut_teardown,
13385                         test_snow3g_auth_cipher_verify_test_case_2_oop),
13386                 TEST_CASE_ST(ut_setup, ut_teardown,
13387                         test_snow3g_auth_cipher_verify_part_digest_enc),
13388                 TEST_CASE_ST(ut_setup, ut_teardown,
13389                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
13390                 TEST_CASE_ST(ut_setup, ut_teardown,
13391                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
13392                 TEST_CASE_ST(ut_setup, ut_teardown,
13393                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
13394                 TEST_CASE_ST(ut_setup, ut_teardown,
13395                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
13396                 TEST_CASE_ST(ut_setup, ut_teardown,
13397                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
13398
13399                 TEST_CASES_END() /**< NULL terminate unit test array */
13400         }
13401 };
13402
13403 static struct unit_test_suite cryptodev_sw_zuc_testsuite  = {
13404         .suite_name = "Crypto Device SW ZUC Unit Test Suite",
13405         .setup = testsuite_setup,
13406         .teardown = testsuite_teardown,
13407         .unit_test_cases = {
13408                 /** ZUC encrypt only (EEA3) */
13409                 TEST_CASE_ST(ut_setup, ut_teardown,
13410                         test_zuc_encryption_test_case_1),
13411                 TEST_CASE_ST(ut_setup, ut_teardown,
13412                         test_zuc_encryption_test_case_2),
13413                 TEST_CASE_ST(ut_setup, ut_teardown,
13414                         test_zuc_encryption_test_case_3),
13415                 TEST_CASE_ST(ut_setup, ut_teardown,
13416                         test_zuc_encryption_test_case_4),
13417                 TEST_CASE_ST(ut_setup, ut_teardown,
13418                         test_zuc_encryption_test_case_5),
13419                 TEST_CASE_ST(ut_setup, ut_teardown,
13420                         test_zuc_hash_generate_test_case_1),
13421                 TEST_CASE_ST(ut_setup, ut_teardown,
13422                         test_zuc_hash_generate_test_case_2),
13423                 TEST_CASE_ST(ut_setup, ut_teardown,
13424                         test_zuc_hash_generate_test_case_3),
13425                 TEST_CASE_ST(ut_setup, ut_teardown,
13426                         test_zuc_hash_generate_test_case_4),
13427                 TEST_CASE_ST(ut_setup, ut_teardown,
13428                         test_zuc_hash_generate_test_case_5),
13429                 TEST_CASE_ST(ut_setup, ut_teardown,
13430                         test_zuc_encryption_test_case_6_sgl),
13431                 TEST_CASES_END() /**< NULL terminate unit test array */
13432         }
13433 };
13434
13435 static struct unit_test_suite cryptodev_caam_jr_testsuite  = {
13436         .suite_name = "Crypto CAAM JR Unit Test Suite",
13437         .setup = testsuite_setup,
13438         .teardown = testsuite_teardown,
13439         .unit_test_cases = {
13440                 TEST_CASE_ST(ut_setup, ut_teardown,
13441                              test_device_configure_invalid_dev_id),
13442                 TEST_CASE_ST(ut_setup, ut_teardown,
13443                              test_multi_session),
13444
13445                 TEST_CASE_ST(ut_setup, ut_teardown,
13446                              test_AES_chain_caam_jr_all),
13447                 TEST_CASE_ST(ut_setup, ut_teardown,
13448                              test_3DES_chain_caam_jr_all),
13449                 TEST_CASE_ST(ut_setup, ut_teardown,
13450                              test_AES_cipheronly_caam_jr_all),
13451                 TEST_CASE_ST(ut_setup, ut_teardown,
13452                              test_3DES_cipheronly_caam_jr_all),
13453                 TEST_CASE_ST(ut_setup, ut_teardown,
13454                              test_authonly_caam_jr_all),
13455
13456                 TEST_CASES_END() /**< NULL terminate unit test array */
13457         }
13458 };
13459
13460 static struct unit_test_suite cryptodev_dpaa_sec_testsuite  = {
13461         .suite_name = "Crypto DPAA_SEC Unit Test Suite",
13462         .setup = testsuite_setup,
13463         .teardown = testsuite_teardown,
13464         .unit_test_cases = {
13465                 TEST_CASE_ST(ut_setup, ut_teardown,
13466                              test_device_configure_invalid_dev_id),
13467                 TEST_CASE_ST(ut_setup, ut_teardown,
13468                              test_multi_session),
13469
13470                 TEST_CASE_ST(ut_setup, ut_teardown,
13471                              test_AES_chain_dpaa_sec_all),
13472                 TEST_CASE_ST(ut_setup, ut_teardown,
13473                              test_3DES_chain_dpaa_sec_all),
13474                 TEST_CASE_ST(ut_setup, ut_teardown,
13475                              test_AES_cipheronly_dpaa_sec_all),
13476                 TEST_CASE_ST(ut_setup, ut_teardown,
13477                              test_3DES_cipheronly_dpaa_sec_all),
13478                 TEST_CASE_ST(ut_setup, ut_teardown,
13479                              test_authonly_dpaa_sec_all),
13480
13481 #ifdef RTE_LIBRTE_SECURITY
13482                 TEST_CASE_ST(ut_setup, ut_teardown,
13483                         test_PDCP_PROTO_cplane_encap_all),
13484
13485                 TEST_CASE_ST(ut_setup, ut_teardown,
13486                         test_PDCP_PROTO_cplane_decap_all),
13487
13488                 TEST_CASE_ST(ut_setup, ut_teardown,
13489                         test_PDCP_PROTO_uplane_encap_all),
13490
13491                 TEST_CASE_ST(ut_setup, ut_teardown,
13492                         test_PDCP_PROTO_uplane_decap_all),
13493
13494                 TEST_CASE_ST(ut_setup, ut_teardown,
13495                         test_PDCP_PROTO_SGL_in_place_32B),
13496                 TEST_CASE_ST(ut_setup, ut_teardown,
13497                         test_PDCP_PROTO_SGL_oop_32B_128B),
13498                 TEST_CASE_ST(ut_setup, ut_teardown,
13499                         test_PDCP_PROTO_SGL_oop_32B_40B),
13500                 TEST_CASE_ST(ut_setup, ut_teardown,
13501                         test_PDCP_PROTO_SGL_oop_128B_32B),
13502 #endif
13503                 /** AES GCM Authenticated Encryption */
13504                 TEST_CASE_ST(ut_setup, ut_teardown,
13505                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
13506                 TEST_CASE_ST(ut_setup, ut_teardown,
13507                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
13508                 TEST_CASE_ST(ut_setup, ut_teardown,
13509                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
13510                 TEST_CASE_ST(ut_setup, ut_teardown,
13511                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
13512                 TEST_CASE_ST(ut_setup, ut_teardown,
13513                         test_AES_GCM_authenticated_encryption_test_case_1),
13514                 TEST_CASE_ST(ut_setup, ut_teardown,
13515                         test_AES_GCM_authenticated_encryption_test_case_2),
13516                 TEST_CASE_ST(ut_setup, ut_teardown,
13517                         test_AES_GCM_authenticated_encryption_test_case_3),
13518                 TEST_CASE_ST(ut_setup, ut_teardown,
13519                         test_AES_GCM_authenticated_encryption_test_case_4),
13520                 TEST_CASE_ST(ut_setup, ut_teardown,
13521                         test_AES_GCM_authenticated_encryption_test_case_5),
13522                 TEST_CASE_ST(ut_setup, ut_teardown,
13523                         test_AES_GCM_authenticated_encryption_test_case_6),
13524                 TEST_CASE_ST(ut_setup, ut_teardown,
13525                         test_AES_GCM_authenticated_encryption_test_case_7),
13526                 TEST_CASE_ST(ut_setup, ut_teardown,
13527                         test_AES_GCM_authenticated_encryption_test_case_8),
13528
13529                 /** AES GCM Authenticated Decryption */
13530                 TEST_CASE_ST(ut_setup, ut_teardown,
13531                         test_AES_GCM_authenticated_decryption_test_case_1),
13532                 TEST_CASE_ST(ut_setup, ut_teardown,
13533                         test_AES_GCM_authenticated_decryption_test_case_2),
13534                 TEST_CASE_ST(ut_setup, ut_teardown,
13535                         test_AES_GCM_authenticated_decryption_test_case_3),
13536                 TEST_CASE_ST(ut_setup, ut_teardown,
13537                         test_AES_GCM_authenticated_decryption_test_case_4),
13538                 TEST_CASE_ST(ut_setup, ut_teardown,
13539                         test_AES_GCM_authenticated_decryption_test_case_5),
13540                 TEST_CASE_ST(ut_setup, ut_teardown,
13541                         test_AES_GCM_authenticated_decryption_test_case_6),
13542                 TEST_CASE_ST(ut_setup, ut_teardown,
13543                         test_AES_GCM_authenticated_decryption_test_case_7),
13544                 TEST_CASE_ST(ut_setup, ut_teardown,
13545                         test_AES_GCM_authenticated_decryption_test_case_8),
13546
13547                 /** AES GCM Authenticated Encryption 192 bits key */
13548                 TEST_CASE_ST(ut_setup, ut_teardown,
13549                         test_AES_GCM_auth_encryption_test_case_192_1),
13550                 TEST_CASE_ST(ut_setup, ut_teardown,
13551                         test_AES_GCM_auth_encryption_test_case_192_2),
13552                 TEST_CASE_ST(ut_setup, ut_teardown,
13553                         test_AES_GCM_auth_encryption_test_case_192_3),
13554                 TEST_CASE_ST(ut_setup, ut_teardown,
13555                         test_AES_GCM_auth_encryption_test_case_192_4),
13556                 TEST_CASE_ST(ut_setup, ut_teardown,
13557                         test_AES_GCM_auth_encryption_test_case_192_5),
13558                 TEST_CASE_ST(ut_setup, ut_teardown,
13559                         test_AES_GCM_auth_encryption_test_case_192_6),
13560                 TEST_CASE_ST(ut_setup, ut_teardown,
13561                         test_AES_GCM_auth_encryption_test_case_192_7),
13562
13563                 /** AES GCM Authenticated Decryption 192 bits key */
13564                 TEST_CASE_ST(ut_setup, ut_teardown,
13565                         test_AES_GCM_auth_decryption_test_case_192_1),
13566                 TEST_CASE_ST(ut_setup, ut_teardown,
13567                         test_AES_GCM_auth_decryption_test_case_192_2),
13568                 TEST_CASE_ST(ut_setup, ut_teardown,
13569                         test_AES_GCM_auth_decryption_test_case_192_3),
13570                 TEST_CASE_ST(ut_setup, ut_teardown,
13571                         test_AES_GCM_auth_decryption_test_case_192_4),
13572                 TEST_CASE_ST(ut_setup, ut_teardown,
13573                         test_AES_GCM_auth_decryption_test_case_192_5),
13574                 TEST_CASE_ST(ut_setup, ut_teardown,
13575                         test_AES_GCM_auth_decryption_test_case_192_6),
13576                 TEST_CASE_ST(ut_setup, ut_teardown,
13577                         test_AES_GCM_auth_decryption_test_case_192_7),
13578
13579                 /** AES GCM Authenticated Encryption 256 bits key */
13580                 TEST_CASE_ST(ut_setup, ut_teardown,
13581                         test_AES_GCM_auth_encryption_test_case_256_1),
13582                 TEST_CASE_ST(ut_setup, ut_teardown,
13583                         test_AES_GCM_auth_encryption_test_case_256_2),
13584                 TEST_CASE_ST(ut_setup, ut_teardown,
13585                         test_AES_GCM_auth_encryption_test_case_256_3),
13586                 TEST_CASE_ST(ut_setup, ut_teardown,
13587                         test_AES_GCM_auth_encryption_test_case_256_4),
13588                 TEST_CASE_ST(ut_setup, ut_teardown,
13589                         test_AES_GCM_auth_encryption_test_case_256_5),
13590                 TEST_CASE_ST(ut_setup, ut_teardown,
13591                         test_AES_GCM_auth_encryption_test_case_256_6),
13592                 TEST_CASE_ST(ut_setup, ut_teardown,
13593                         test_AES_GCM_auth_encryption_test_case_256_7),
13594
13595                 /** AES GCM Authenticated Decryption 256 bits key */
13596                 TEST_CASE_ST(ut_setup, ut_teardown,
13597                         test_AES_GCM_auth_decryption_test_case_256_1),
13598                 TEST_CASE_ST(ut_setup, ut_teardown,
13599                         test_AES_GCM_auth_decryption_test_case_256_2),
13600                 TEST_CASE_ST(ut_setup, ut_teardown,
13601                         test_AES_GCM_auth_decryption_test_case_256_3),
13602                 TEST_CASE_ST(ut_setup, ut_teardown,
13603                         test_AES_GCM_auth_decryption_test_case_256_4),
13604                 TEST_CASE_ST(ut_setup, ut_teardown,
13605                         test_AES_GCM_auth_decryption_test_case_256_5),
13606                 TEST_CASE_ST(ut_setup, ut_teardown,
13607                         test_AES_GCM_auth_decryption_test_case_256_6),
13608                 TEST_CASE_ST(ut_setup, ut_teardown,
13609                         test_AES_GCM_auth_decryption_test_case_256_7),
13610
13611                 /** Out of place tests */
13612                 TEST_CASE_ST(ut_setup, ut_teardown,
13613                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
13614                 TEST_CASE_ST(ut_setup, ut_teardown,
13615                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
13616
13617                 /** SNOW 3G encrypt only (UEA2) */
13618                 TEST_CASE_ST(ut_setup, ut_teardown,
13619                         test_snow3g_encryption_test_case_1),
13620                 TEST_CASE_ST(ut_setup, ut_teardown,
13621                         test_snow3g_encryption_test_case_2),
13622                 TEST_CASE_ST(ut_setup, ut_teardown,
13623                         test_snow3g_encryption_test_case_3),
13624                 TEST_CASE_ST(ut_setup, ut_teardown,
13625                         test_snow3g_encryption_test_case_4),
13626                 TEST_CASE_ST(ut_setup, ut_teardown,
13627                         test_snow3g_encryption_test_case_5),
13628
13629                 TEST_CASE_ST(ut_setup, ut_teardown,
13630                         test_snow3g_encryption_test_case_1_oop),
13631                 TEST_CASE_ST(ut_setup, ut_teardown,
13632                                 test_snow3g_encryption_test_case_1_oop_sgl),
13633                 TEST_CASE_ST(ut_setup, ut_teardown,
13634                         test_snow3g_decryption_test_case_1_oop),
13635
13636                 /** SNOW 3G decrypt only (UEA2) */
13637                 TEST_CASE_ST(ut_setup, ut_teardown,
13638                         test_snow3g_decryption_test_case_1),
13639                 TEST_CASE_ST(ut_setup, ut_teardown,
13640                         test_snow3g_decryption_test_case_2),
13641                 TEST_CASE_ST(ut_setup, ut_teardown,
13642                         test_snow3g_decryption_test_case_3),
13643                 TEST_CASE_ST(ut_setup, ut_teardown,
13644                         test_snow3g_decryption_test_case_4),
13645                 TEST_CASE_ST(ut_setup, ut_teardown,
13646                         test_snow3g_decryption_test_case_5),
13647
13648                 TEST_CASE_ST(ut_setup, ut_teardown,
13649                         test_snow3g_hash_generate_test_case_1),
13650                 TEST_CASE_ST(ut_setup, ut_teardown,
13651                         test_snow3g_hash_generate_test_case_2),
13652                 TEST_CASE_ST(ut_setup, ut_teardown,
13653                         test_snow3g_hash_generate_test_case_3),
13654                 TEST_CASE_ST(ut_setup, ut_teardown,
13655                         test_snow3g_hash_verify_test_case_1),
13656                 TEST_CASE_ST(ut_setup, ut_teardown,
13657                         test_snow3g_hash_verify_test_case_2),
13658                 TEST_CASE_ST(ut_setup, ut_teardown,
13659                         test_snow3g_hash_verify_test_case_3),
13660
13661                 /** ZUC encrypt only (EEA3) */
13662                 TEST_CASE_ST(ut_setup, ut_teardown,
13663                         test_zuc_encryption_test_case_1),
13664                 TEST_CASE_ST(ut_setup, ut_teardown,
13665                         test_zuc_encryption_test_case_2),
13666                 TEST_CASE_ST(ut_setup, ut_teardown,
13667                         test_zuc_encryption_test_case_3),
13668                 TEST_CASE_ST(ut_setup, ut_teardown,
13669                         test_zuc_encryption_test_case_4),
13670                 TEST_CASE_ST(ut_setup, ut_teardown,
13671                         test_zuc_encryption_test_case_5),
13672
13673                 /** ZUC authenticate (EIA3) */
13674                 TEST_CASE_ST(ut_setup, ut_teardown,
13675                         test_zuc_hash_generate_test_case_6),
13676                 TEST_CASE_ST(ut_setup, ut_teardown,
13677                         test_zuc_hash_generate_test_case_7),
13678                 TEST_CASE_ST(ut_setup, ut_teardown,
13679                         test_zuc_hash_generate_test_case_8),
13680
13681                 /** Negative tests */
13682                 TEST_CASE_ST(ut_setup, ut_teardown,
13683                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
13684                 TEST_CASE_ST(ut_setup, ut_teardown,
13685                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
13686                 TEST_CASE_ST(ut_setup, ut_teardown,
13687                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
13688                 TEST_CASE_ST(ut_setup, ut_teardown,
13689                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
13690                 TEST_CASE_ST(ut_setup, ut_teardown,
13691                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
13692                 TEST_CASE_ST(ut_setup, ut_teardown,
13693                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
13694                 TEST_CASE_ST(ut_setup, ut_teardown,
13695                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
13696                 TEST_CASE_ST(ut_setup, ut_teardown,
13697                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
13698                 TEST_CASE_ST(ut_setup, ut_teardown,
13699                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
13700                 TEST_CASE_ST(ut_setup, ut_teardown,
13701                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
13702                 TEST_CASE_ST(ut_setup, ut_teardown,
13703                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
13704                 TEST_CASE_ST(ut_setup, ut_teardown,
13705                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
13706                 TEST_CASE_ST(ut_setup, ut_teardown,
13707                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13708                 TEST_CASE_ST(ut_setup, ut_teardown,
13709                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13710                 TEST_CASE_ST(ut_setup, ut_teardown,
13711                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13712                 TEST_CASE_ST(ut_setup, ut_teardown,
13713                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13714
13715                 /* ESN Testcase */
13716                 TEST_CASE_ST(ut_setup, ut_teardown,
13717                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
13718                 TEST_CASE_ST(ut_setup, ut_teardown,
13719                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
13720
13721                 TEST_CASES_END() /**< NULL terminate unit test array */
13722         }
13723 };
13724
13725 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite  = {
13726         .suite_name = "Crypto DPAA2_SEC Unit Test Suite",
13727         .setup = testsuite_setup,
13728         .teardown = testsuite_teardown,
13729         .unit_test_cases = {
13730                 TEST_CASE_ST(ut_setup, ut_teardown,
13731                         test_device_configure_invalid_dev_id),
13732                 TEST_CASE_ST(ut_setup, ut_teardown,
13733                         test_multi_session),
13734                 TEST_CASE_ST(ut_setup, ut_teardown,
13735                         test_AES_chain_dpaa2_sec_all),
13736                 TEST_CASE_ST(ut_setup, ut_teardown,
13737                         test_3DES_chain_dpaa2_sec_all),
13738                 TEST_CASE_ST(ut_setup, ut_teardown,
13739                         test_AES_cipheronly_dpaa2_sec_all),
13740                 TEST_CASE_ST(ut_setup, ut_teardown,
13741                         test_3DES_cipheronly_dpaa2_sec_all),
13742                 TEST_CASE_ST(ut_setup, ut_teardown,
13743                         test_authonly_dpaa2_sec_all),
13744
13745 #ifdef RTE_LIBRTE_SECURITY
13746                 TEST_CASE_ST(ut_setup, ut_teardown,
13747                         test_PDCP_PROTO_cplane_encap_all),
13748
13749                 TEST_CASE_ST(ut_setup, ut_teardown,
13750                         test_PDCP_PROTO_cplane_decap_all),
13751
13752                 TEST_CASE_ST(ut_setup, ut_teardown,
13753                         test_PDCP_PROTO_uplane_encap_all),
13754
13755                 TEST_CASE_ST(ut_setup, ut_teardown,
13756                         test_PDCP_PROTO_uplane_decap_all),
13757
13758                 TEST_CASE_ST(ut_setup, ut_teardown,
13759                         test_PDCP_PROTO_SGL_in_place_32B),
13760                 TEST_CASE_ST(ut_setup, ut_teardown,
13761                         test_PDCP_PROTO_SGL_oop_32B_128B),
13762                 TEST_CASE_ST(ut_setup, ut_teardown,
13763                         test_PDCP_PROTO_SGL_oop_32B_40B),
13764                 TEST_CASE_ST(ut_setup, ut_teardown,
13765                         test_PDCP_PROTO_SGL_oop_128B_32B),
13766 #endif
13767                 /** AES GCM Authenticated Encryption */
13768                 TEST_CASE_ST(ut_setup, ut_teardown,
13769                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
13770                 TEST_CASE_ST(ut_setup, ut_teardown,
13771                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
13772                 TEST_CASE_ST(ut_setup, ut_teardown,
13773                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
13774                 TEST_CASE_ST(ut_setup, ut_teardown,
13775                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
13776                 TEST_CASE_ST(ut_setup, ut_teardown,
13777                         test_AES_GCM_authenticated_encryption_test_case_1),
13778                 TEST_CASE_ST(ut_setup, ut_teardown,
13779                         test_AES_GCM_authenticated_encryption_test_case_2),
13780                 TEST_CASE_ST(ut_setup, ut_teardown,
13781                         test_AES_GCM_authenticated_encryption_test_case_3),
13782                 TEST_CASE_ST(ut_setup, ut_teardown,
13783                         test_AES_GCM_authenticated_encryption_test_case_4),
13784                 TEST_CASE_ST(ut_setup, ut_teardown,
13785                         test_AES_GCM_authenticated_encryption_test_case_5),
13786                 TEST_CASE_ST(ut_setup, ut_teardown,
13787                         test_AES_GCM_authenticated_encryption_test_case_6),
13788                 TEST_CASE_ST(ut_setup, ut_teardown,
13789                         test_AES_GCM_authenticated_encryption_test_case_7),
13790                 TEST_CASE_ST(ut_setup, ut_teardown,
13791                         test_AES_GCM_authenticated_encryption_test_case_8),
13792
13793                 /** AES GCM Authenticated Decryption */
13794                 TEST_CASE_ST(ut_setup, ut_teardown,
13795                         test_AES_GCM_authenticated_decryption_test_case_1),
13796                 TEST_CASE_ST(ut_setup, ut_teardown,
13797                         test_AES_GCM_authenticated_decryption_test_case_2),
13798                 TEST_CASE_ST(ut_setup, ut_teardown,
13799                         test_AES_GCM_authenticated_decryption_test_case_3),
13800                 TEST_CASE_ST(ut_setup, ut_teardown,
13801                         test_AES_GCM_authenticated_decryption_test_case_4),
13802                 TEST_CASE_ST(ut_setup, ut_teardown,
13803                         test_AES_GCM_authenticated_decryption_test_case_5),
13804                 TEST_CASE_ST(ut_setup, ut_teardown,
13805                         test_AES_GCM_authenticated_decryption_test_case_6),
13806                 TEST_CASE_ST(ut_setup, ut_teardown,
13807                         test_AES_GCM_authenticated_decryption_test_case_7),
13808                 TEST_CASE_ST(ut_setup, ut_teardown,
13809                         test_AES_GCM_authenticated_decryption_test_case_8),
13810
13811                 /** AES GCM Authenticated Encryption 192 bits key */
13812                 TEST_CASE_ST(ut_setup, ut_teardown,
13813                         test_AES_GCM_auth_encryption_test_case_192_1),
13814                 TEST_CASE_ST(ut_setup, ut_teardown,
13815                         test_AES_GCM_auth_encryption_test_case_192_2),
13816                 TEST_CASE_ST(ut_setup, ut_teardown,
13817                         test_AES_GCM_auth_encryption_test_case_192_3),
13818                 TEST_CASE_ST(ut_setup, ut_teardown,
13819                         test_AES_GCM_auth_encryption_test_case_192_4),
13820                 TEST_CASE_ST(ut_setup, ut_teardown,
13821                         test_AES_GCM_auth_encryption_test_case_192_5),
13822                 TEST_CASE_ST(ut_setup, ut_teardown,
13823                         test_AES_GCM_auth_encryption_test_case_192_6),
13824                 TEST_CASE_ST(ut_setup, ut_teardown,
13825                         test_AES_GCM_auth_encryption_test_case_192_7),
13826
13827                 /** AES GCM Authenticated Decryption 192 bits key */
13828                 TEST_CASE_ST(ut_setup, ut_teardown,
13829                         test_AES_GCM_auth_decryption_test_case_192_1),
13830                 TEST_CASE_ST(ut_setup, ut_teardown,
13831                         test_AES_GCM_auth_decryption_test_case_192_2),
13832                 TEST_CASE_ST(ut_setup, ut_teardown,
13833                         test_AES_GCM_auth_decryption_test_case_192_3),
13834                 TEST_CASE_ST(ut_setup, ut_teardown,
13835                         test_AES_GCM_auth_decryption_test_case_192_4),
13836                 TEST_CASE_ST(ut_setup, ut_teardown,
13837                         test_AES_GCM_auth_decryption_test_case_192_5),
13838                 TEST_CASE_ST(ut_setup, ut_teardown,
13839                         test_AES_GCM_auth_decryption_test_case_192_6),
13840                 TEST_CASE_ST(ut_setup, ut_teardown,
13841                         test_AES_GCM_auth_decryption_test_case_192_7),
13842
13843                 /** AES GCM Authenticated Encryption 256 bits key */
13844                 TEST_CASE_ST(ut_setup, ut_teardown,
13845                         test_AES_GCM_auth_encryption_test_case_256_1),
13846                 TEST_CASE_ST(ut_setup, ut_teardown,
13847                         test_AES_GCM_auth_encryption_test_case_256_2),
13848                 TEST_CASE_ST(ut_setup, ut_teardown,
13849                         test_AES_GCM_auth_encryption_test_case_256_3),
13850                 TEST_CASE_ST(ut_setup, ut_teardown,
13851                         test_AES_GCM_auth_encryption_test_case_256_4),
13852                 TEST_CASE_ST(ut_setup, ut_teardown,
13853                         test_AES_GCM_auth_encryption_test_case_256_5),
13854                 TEST_CASE_ST(ut_setup, ut_teardown,
13855                         test_AES_GCM_auth_encryption_test_case_256_6),
13856                 TEST_CASE_ST(ut_setup, ut_teardown,
13857                         test_AES_GCM_auth_encryption_test_case_256_7),
13858
13859                 /** AES GCM Authenticated Decryption 256 bits key */
13860                 TEST_CASE_ST(ut_setup, ut_teardown,
13861                         test_AES_GCM_auth_decryption_test_case_256_1),
13862                 TEST_CASE_ST(ut_setup, ut_teardown,
13863                         test_AES_GCM_auth_decryption_test_case_256_2),
13864                 TEST_CASE_ST(ut_setup, ut_teardown,
13865                         test_AES_GCM_auth_decryption_test_case_256_3),
13866                 TEST_CASE_ST(ut_setup, ut_teardown,
13867                         test_AES_GCM_auth_decryption_test_case_256_4),
13868                 TEST_CASE_ST(ut_setup, ut_teardown,
13869                         test_AES_GCM_auth_decryption_test_case_256_5),
13870                 TEST_CASE_ST(ut_setup, ut_teardown,
13871                         test_AES_GCM_auth_decryption_test_case_256_6),
13872                 TEST_CASE_ST(ut_setup, ut_teardown,
13873                         test_AES_GCM_auth_decryption_test_case_256_7),
13874
13875                 /** Out of place tests */
13876                 TEST_CASE_ST(ut_setup, ut_teardown,
13877                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
13878                 TEST_CASE_ST(ut_setup, ut_teardown,
13879                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
13880
13881                 /** SNOW 3G encrypt only (UEA2) */
13882                 TEST_CASE_ST(ut_setup, ut_teardown,
13883                         test_snow3g_encryption_test_case_1),
13884                 TEST_CASE_ST(ut_setup, ut_teardown,
13885                         test_snow3g_encryption_test_case_2),
13886                 TEST_CASE_ST(ut_setup, ut_teardown,
13887                         test_snow3g_encryption_test_case_3),
13888                 TEST_CASE_ST(ut_setup, ut_teardown,
13889                         test_snow3g_encryption_test_case_4),
13890                 TEST_CASE_ST(ut_setup, ut_teardown,
13891                         test_snow3g_encryption_test_case_5),
13892
13893                 TEST_CASE_ST(ut_setup, ut_teardown,
13894                         test_snow3g_encryption_test_case_1_oop),
13895                 TEST_CASE_ST(ut_setup, ut_teardown,
13896                                 test_snow3g_encryption_test_case_1_oop_sgl),
13897                 TEST_CASE_ST(ut_setup, ut_teardown,
13898                         test_snow3g_decryption_test_case_1_oop),
13899
13900                 /** SNOW 3G decrypt only (UEA2) */
13901                 TEST_CASE_ST(ut_setup, ut_teardown,
13902                         test_snow3g_decryption_test_case_1),
13903                 TEST_CASE_ST(ut_setup, ut_teardown,
13904                         test_snow3g_decryption_test_case_2),
13905                 TEST_CASE_ST(ut_setup, ut_teardown,
13906                         test_snow3g_decryption_test_case_3),
13907                 TEST_CASE_ST(ut_setup, ut_teardown,
13908                         test_snow3g_decryption_test_case_4),
13909                 TEST_CASE_ST(ut_setup, ut_teardown,
13910                         test_snow3g_decryption_test_case_5),
13911
13912                 TEST_CASE_ST(ut_setup, ut_teardown,
13913                         test_snow3g_hash_generate_test_case_1),
13914                 TEST_CASE_ST(ut_setup, ut_teardown,
13915                         test_snow3g_hash_generate_test_case_2),
13916                 TEST_CASE_ST(ut_setup, ut_teardown,
13917                         test_snow3g_hash_generate_test_case_3),
13918                 TEST_CASE_ST(ut_setup, ut_teardown,
13919                         test_snow3g_hash_verify_test_case_1),
13920                 TEST_CASE_ST(ut_setup, ut_teardown,
13921                         test_snow3g_hash_verify_test_case_2),
13922                 TEST_CASE_ST(ut_setup, ut_teardown,
13923                         test_snow3g_hash_verify_test_case_3),
13924
13925                 /** ZUC encrypt only (EEA3) */
13926                 TEST_CASE_ST(ut_setup, ut_teardown,
13927                         test_zuc_encryption_test_case_1),
13928                 TEST_CASE_ST(ut_setup, ut_teardown,
13929                         test_zuc_encryption_test_case_2),
13930                 TEST_CASE_ST(ut_setup, ut_teardown,
13931                         test_zuc_encryption_test_case_3),
13932                 TEST_CASE_ST(ut_setup, ut_teardown,
13933                         test_zuc_encryption_test_case_4),
13934                 TEST_CASE_ST(ut_setup, ut_teardown,
13935                         test_zuc_encryption_test_case_5),
13936
13937                 /** ZUC authenticate (EIA3) */
13938                 TEST_CASE_ST(ut_setup, ut_teardown,
13939                         test_zuc_hash_generate_test_case_6),
13940                 TEST_CASE_ST(ut_setup, ut_teardown,
13941                         test_zuc_hash_generate_test_case_7),
13942                 TEST_CASE_ST(ut_setup, ut_teardown,
13943                         test_zuc_hash_generate_test_case_8),
13944
13945                 /** HMAC_MD5 Authentication */
13946                 TEST_CASE_ST(ut_setup, ut_teardown,
13947                         test_MD5_HMAC_generate_case_1),
13948                 TEST_CASE_ST(ut_setup, ut_teardown,
13949                         test_MD5_HMAC_verify_case_1),
13950                 TEST_CASE_ST(ut_setup, ut_teardown,
13951                         test_MD5_HMAC_generate_case_2),
13952                 TEST_CASE_ST(ut_setup, ut_teardown,
13953                         test_MD5_HMAC_verify_case_2),
13954
13955                 /** Negative tests */
13956                 TEST_CASE_ST(ut_setup, ut_teardown,
13957                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
13958                 TEST_CASE_ST(ut_setup, ut_teardown,
13959                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
13960                 TEST_CASE_ST(ut_setup, ut_teardown,
13961                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
13962                 TEST_CASE_ST(ut_setup, ut_teardown,
13963                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
13964                 TEST_CASE_ST(ut_setup, ut_teardown,
13965                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
13966                 TEST_CASE_ST(ut_setup, ut_teardown,
13967                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
13968                 TEST_CASE_ST(ut_setup, ut_teardown,
13969                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
13970                 TEST_CASE_ST(ut_setup, ut_teardown,
13971                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
13972                 TEST_CASE_ST(ut_setup, ut_teardown,
13973                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
13974                 TEST_CASE_ST(ut_setup, ut_teardown,
13975                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
13976                 TEST_CASE_ST(ut_setup, ut_teardown,
13977                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
13978                 TEST_CASE_ST(ut_setup, ut_teardown,
13979                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
13980                 TEST_CASE_ST(ut_setup, ut_teardown,
13981                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13982                 TEST_CASE_ST(ut_setup, ut_teardown,
13983                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13984                 TEST_CASE_ST(ut_setup, ut_teardown,
13985                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13986                 TEST_CASE_ST(ut_setup, ut_teardown,
13987                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13988
13989                 /* ESN Testcase */
13990                 TEST_CASE_ST(ut_setup, ut_teardown,
13991                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
13992
13993                 TEST_CASE_ST(ut_setup, ut_teardown,
13994                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
13995
13996                 TEST_CASES_END() /**< NULL terminate unit test array */
13997         }
13998 };
13999
14000 static struct unit_test_suite cryptodev_null_testsuite  = {
14001         .suite_name = "Crypto Device NULL Unit Test Suite",
14002         .setup = testsuite_setup,
14003         .teardown = testsuite_teardown,
14004         .unit_test_cases = {
14005                 TEST_CASE_ST(ut_setup, ut_teardown,
14006                         test_null_invalid_operation),
14007                 TEST_CASE_ST(ut_setup, ut_teardown,
14008                         test_null_burst_operation),
14009                 TEST_CASE_ST(ut_setup, ut_teardown,
14010                         test_AES_chain_null_all),
14011                 TEST_CASE_ST(ut_setup, ut_teardown,
14012                         test_AES_cipheronly_null_all),
14013                 TEST_CASE_ST(ut_setup, ut_teardown,
14014                                 test_authonly_null_all),
14015
14016                 TEST_CASES_END() /**< NULL terminate unit test array */
14017         }
14018 };
14019
14020 static struct unit_test_suite cryptodev_armv8_testsuite  = {
14021         .suite_name = "Crypto Device ARMv8 Unit Test Suite",
14022         .setup = testsuite_setup,
14023         .teardown = testsuite_teardown,
14024         .unit_test_cases = {
14025                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_armv8_all),
14026
14027                 /** Negative tests */
14028                 TEST_CASE_ST(ut_setup, ut_teardown,
14029                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14030                 TEST_CASE_ST(ut_setup, ut_teardown,
14031                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14032
14033                 TEST_CASES_END() /**< NULL terminate unit test array */
14034         }
14035 };
14036
14037 static struct unit_test_suite cryptodev_mrvl_testsuite  = {
14038         .suite_name = "Crypto Device Marvell Component Test Suite",
14039         .setup = testsuite_setup,
14040         .teardown = testsuite_teardown,
14041         .unit_test_cases = {
14042                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
14043                 TEST_CASE_ST(ut_setup, ut_teardown,
14044                                 test_multi_session_random_usage),
14045                 TEST_CASE_ST(ut_setup, ut_teardown,
14046                                 test_AES_chain_mrvl_all),
14047                 TEST_CASE_ST(ut_setup, ut_teardown,
14048                                 test_AES_cipheronly_mrvl_all),
14049                 TEST_CASE_ST(ut_setup, ut_teardown,
14050                                 test_authonly_mrvl_all),
14051                 TEST_CASE_ST(ut_setup, ut_teardown,
14052                                 test_3DES_chain_mrvl_all),
14053                 TEST_CASE_ST(ut_setup, ut_teardown,
14054                                 test_3DES_cipheronly_mrvl_all),
14055
14056                 /** Negative tests */
14057                 TEST_CASE_ST(ut_setup, ut_teardown,
14058                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
14059                 TEST_CASE_ST(ut_setup, ut_teardown,
14060                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14061                 TEST_CASE_ST(ut_setup, ut_teardown,
14062                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14063                 TEST_CASE_ST(ut_setup, ut_teardown,
14064                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14065
14066                 TEST_CASES_END() /**< NULL terminate unit test array */
14067         }
14068 };
14069
14070 static struct unit_test_suite cryptodev_ccp_testsuite  = {
14071         .suite_name = "Crypto Device CCP Unit Test Suite",
14072         .setup = testsuite_setup,
14073         .teardown = testsuite_teardown,
14074         .unit_test_cases = {
14075                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
14076                 TEST_CASE_ST(ut_setup, ut_teardown,
14077                                 test_multi_session_random_usage),
14078                 TEST_CASE_ST(ut_setup, ut_teardown,
14079                                 test_AES_chain_ccp_all),
14080                 TEST_CASE_ST(ut_setup, ut_teardown,
14081                                 test_AES_cipheronly_ccp_all),
14082                 TEST_CASE_ST(ut_setup, ut_teardown,
14083                                 test_3DES_chain_ccp_all),
14084                 TEST_CASE_ST(ut_setup, ut_teardown,
14085                                 test_3DES_cipheronly_ccp_all),
14086                 TEST_CASE_ST(ut_setup, ut_teardown,
14087                                 test_authonly_ccp_all),
14088
14089                 /** Negative tests */
14090                 TEST_CASE_ST(ut_setup, ut_teardown,
14091                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
14092                 TEST_CASE_ST(ut_setup, ut_teardown,
14093                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14094                 TEST_CASE_ST(ut_setup, ut_teardown,
14095                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14096                 TEST_CASE_ST(ut_setup, ut_teardown,
14097                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14098
14099                 TEST_CASES_END() /**< NULL terminate unit test array */
14100         }
14101 };
14102
14103 static struct unit_test_suite cryptodev_octeontx_testsuite  = {
14104         .suite_name = "Crypto Device OCTEONTX Unit Test Suite",
14105         .setup = testsuite_setup,
14106         .teardown = testsuite_teardown,
14107         .unit_test_cases = {
14108                 TEST_CASE_ST(ut_setup, ut_teardown,
14109                         test_AES_chain_octeontx_all),
14110                 TEST_CASE_ST(ut_setup, ut_teardown,
14111                         test_AES_cipheronly_octeontx_all),
14112                 TEST_CASE_ST(ut_setup, ut_teardown,
14113                         test_3DES_chain_octeontx_all),
14114                 TEST_CASE_ST(ut_setup, ut_teardown,
14115                         test_3DES_cipheronly_octeontx_all),
14116                 TEST_CASE_ST(ut_setup, ut_teardown,
14117                         test_authonly_octeontx_all),
14118
14119                 /** AES GCM Authenticated Encryption */
14120                 TEST_CASE_ST(ut_setup, ut_teardown,
14121                         test_AES_GCM_authenticated_encryption_test_case_1),
14122                 TEST_CASE_ST(ut_setup, ut_teardown,
14123                         test_AES_GCM_authenticated_encryption_test_case_2),
14124                 TEST_CASE_ST(ut_setup, ut_teardown,
14125                         test_AES_GCM_authenticated_encryption_test_case_3),
14126                 TEST_CASE_ST(ut_setup, ut_teardown,
14127                         test_AES_GCM_authenticated_encryption_test_case_4),
14128                 TEST_CASE_ST(ut_setup, ut_teardown,
14129                         test_AES_GCM_authenticated_encryption_test_case_5),
14130                 TEST_CASE_ST(ut_setup, ut_teardown,
14131                         test_AES_GCM_authenticated_encryption_test_case_6),
14132                 TEST_CASE_ST(ut_setup, ut_teardown,
14133                         test_AES_GCM_authenticated_encryption_test_case_7),
14134
14135                 /** AES GCM Authenticated Decryption */
14136                 TEST_CASE_ST(ut_setup, ut_teardown,
14137                         test_AES_GCM_authenticated_decryption_test_case_1),
14138                 TEST_CASE_ST(ut_setup, ut_teardown,
14139                         test_AES_GCM_authenticated_decryption_test_case_2),
14140                 TEST_CASE_ST(ut_setup, ut_teardown,
14141                         test_AES_GCM_authenticated_decryption_test_case_3),
14142                 TEST_CASE_ST(ut_setup, ut_teardown,
14143                         test_AES_GCM_authenticated_decryption_test_case_4),
14144                 TEST_CASE_ST(ut_setup, ut_teardown,
14145                         test_AES_GCM_authenticated_decryption_test_case_5),
14146                 TEST_CASE_ST(ut_setup, ut_teardown,
14147                         test_AES_GCM_authenticated_decryption_test_case_6),
14148                 TEST_CASE_ST(ut_setup, ut_teardown,
14149                         test_AES_GCM_authenticated_decryption_test_case_7),
14150                 /** AES GMAC Authentication */
14151                 TEST_CASE_ST(ut_setup, ut_teardown,
14152                         test_AES_GMAC_authentication_test_case_1),
14153                 TEST_CASE_ST(ut_setup, ut_teardown,
14154                         test_AES_GMAC_authentication_verify_test_case_1),
14155                 TEST_CASE_ST(ut_setup, ut_teardown,
14156                         test_AES_GMAC_authentication_test_case_2),
14157                 TEST_CASE_ST(ut_setup, ut_teardown,
14158                         test_AES_GMAC_authentication_verify_test_case_2),
14159                 TEST_CASE_ST(ut_setup, ut_teardown,
14160                         test_AES_GMAC_authentication_test_case_3),
14161                 TEST_CASE_ST(ut_setup, ut_teardown,
14162                         test_AES_GMAC_authentication_verify_test_case_3),
14163
14164                 /** SNOW 3G encrypt only (UEA2) */
14165                 TEST_CASE_ST(ut_setup, ut_teardown,
14166                         test_snow3g_encryption_test_case_1),
14167                 TEST_CASE_ST(ut_setup, ut_teardown,
14168                         test_snow3g_encryption_test_case_2),
14169                 TEST_CASE_ST(ut_setup, ut_teardown,
14170                         test_snow3g_encryption_test_case_3),
14171                 TEST_CASE_ST(ut_setup, ut_teardown,
14172                         test_snow3g_encryption_test_case_4),
14173                 TEST_CASE_ST(ut_setup, ut_teardown,
14174                         test_snow3g_encryption_test_case_5),
14175
14176                 TEST_CASE_ST(ut_setup, ut_teardown,
14177                         test_snow3g_encryption_test_case_1_oop),
14178                 TEST_CASE_ST(ut_setup, ut_teardown,
14179                         test_snow3g_decryption_test_case_1_oop),
14180                 TEST_CASE_ST(ut_setup, ut_teardown,
14181                         test_snow3g_encryption_test_case_1_oop_sgl),
14182
14183                 /** SNOW 3G decrypt only (UEA2) */
14184                 TEST_CASE_ST(ut_setup, ut_teardown,
14185                         test_snow3g_decryption_test_case_1),
14186                 TEST_CASE_ST(ut_setup, ut_teardown,
14187                         test_snow3g_decryption_test_case_2),
14188                 TEST_CASE_ST(ut_setup, ut_teardown,
14189                         test_snow3g_decryption_test_case_3),
14190                 TEST_CASE_ST(ut_setup, ut_teardown,
14191                         test_snow3g_decryption_test_case_4),
14192                 TEST_CASE_ST(ut_setup, ut_teardown,
14193                         test_snow3g_decryption_test_case_5),
14194
14195                 TEST_CASE_ST(ut_setup, ut_teardown,
14196                         test_snow3g_hash_generate_test_case_1),
14197                 TEST_CASE_ST(ut_setup, ut_teardown,
14198                         test_snow3g_hash_generate_test_case_2),
14199                 TEST_CASE_ST(ut_setup, ut_teardown,
14200                         test_snow3g_hash_generate_test_case_3),
14201                 TEST_CASE_ST(ut_setup, ut_teardown,
14202                         test_snow3g_hash_verify_test_case_1),
14203                 TEST_CASE_ST(ut_setup, ut_teardown,
14204                         test_snow3g_hash_verify_test_case_2),
14205                 TEST_CASE_ST(ut_setup, ut_teardown,
14206                         test_snow3g_hash_verify_test_case_3),
14207
14208                 /** ZUC encrypt only (EEA3) */
14209                 TEST_CASE_ST(ut_setup, ut_teardown,
14210                         test_zuc_encryption_test_case_1),
14211                 TEST_CASE_ST(ut_setup, ut_teardown,
14212                         test_zuc_encryption_test_case_2),
14213                 TEST_CASE_ST(ut_setup, ut_teardown,
14214                         test_zuc_encryption_test_case_3),
14215                 TEST_CASE_ST(ut_setup, ut_teardown,
14216                         test_zuc_encryption_test_case_4),
14217                 TEST_CASE_ST(ut_setup, ut_teardown,
14218                         test_zuc_encryption_test_case_5),
14219                 TEST_CASE_ST(ut_setup, ut_teardown,
14220                         test_zuc_hash_generate_test_case_1),
14221                 TEST_CASE_ST(ut_setup, ut_teardown,
14222                         test_zuc_hash_generate_test_case_2),
14223                 TEST_CASE_ST(ut_setup, ut_teardown,
14224                         test_zuc_hash_generate_test_case_3),
14225                 TEST_CASE_ST(ut_setup, ut_teardown,
14226                         test_zuc_hash_generate_test_case_4),
14227                 TEST_CASE_ST(ut_setup, ut_teardown,
14228                         test_zuc_hash_generate_test_case_5),
14229                 TEST_CASE_ST(ut_setup, ut_teardown,
14230                         test_zuc_encryption_test_case_6_sgl),
14231
14232                 /** KASUMI encrypt only (UEA1) */
14233                 TEST_CASE_ST(ut_setup, ut_teardown,
14234                         test_kasumi_encryption_test_case_1),
14235                 TEST_CASE_ST(ut_setup, ut_teardown,
14236                         test_kasumi_encryption_test_case_2),
14237                 TEST_CASE_ST(ut_setup, ut_teardown,
14238                         test_kasumi_encryption_test_case_3),
14239                 TEST_CASE_ST(ut_setup, ut_teardown,
14240                         test_kasumi_encryption_test_case_4),
14241                 TEST_CASE_ST(ut_setup, ut_teardown,
14242                         test_kasumi_encryption_test_case_5),
14243                 TEST_CASE_ST(ut_setup, ut_teardown,
14244                         test_kasumi_encryption_test_case_1_sgl),
14245                 TEST_CASE_ST(ut_setup, ut_teardown,
14246                         test_kasumi_encryption_test_case_1_oop_sgl),
14247                 /** KASUMI decrypt only (UEA1) */
14248                 TEST_CASE_ST(ut_setup, ut_teardown,
14249                         test_kasumi_decryption_test_case_1),
14250                 TEST_CASE_ST(ut_setup, ut_teardown,
14251                         test_kasumi_decryption_test_case_2),
14252                 TEST_CASE_ST(ut_setup, ut_teardown,
14253                         test_kasumi_decryption_test_case_3),
14254                 TEST_CASE_ST(ut_setup, ut_teardown,
14255                         test_kasumi_decryption_test_case_4),
14256                 TEST_CASE_ST(ut_setup, ut_teardown,
14257                         test_kasumi_decryption_test_case_5),
14258
14259                 TEST_CASE_ST(ut_setup, ut_teardown,
14260                         test_kasumi_encryption_test_case_1_oop),
14261                 TEST_CASE_ST(ut_setup, ut_teardown,
14262                         test_kasumi_decryption_test_case_1_oop),
14263
14264                 /** KASUMI hash only (UIA1) */
14265                 TEST_CASE_ST(ut_setup, ut_teardown,
14266                         test_kasumi_hash_generate_test_case_1),
14267                 TEST_CASE_ST(ut_setup, ut_teardown,
14268                         test_kasumi_hash_generate_test_case_2),
14269                 TEST_CASE_ST(ut_setup, ut_teardown,
14270                         test_kasumi_hash_generate_test_case_3),
14271                 TEST_CASE_ST(ut_setup, ut_teardown,
14272                         test_kasumi_hash_generate_test_case_4),
14273                 TEST_CASE_ST(ut_setup, ut_teardown,
14274                         test_kasumi_hash_generate_test_case_5),
14275                 TEST_CASE_ST(ut_setup, ut_teardown,
14276                         test_kasumi_hash_generate_test_case_6),
14277                 TEST_CASE_ST(ut_setup, ut_teardown,
14278                         test_kasumi_hash_verify_test_case_1),
14279                 TEST_CASE_ST(ut_setup, ut_teardown,
14280                         test_kasumi_hash_verify_test_case_2),
14281                 TEST_CASE_ST(ut_setup, ut_teardown,
14282                         test_kasumi_hash_verify_test_case_3),
14283                 TEST_CASE_ST(ut_setup, ut_teardown,
14284                         test_kasumi_hash_verify_test_case_4),
14285                 TEST_CASE_ST(ut_setup, ut_teardown,
14286                         test_kasumi_hash_verify_test_case_5),
14287
14288                 /** NULL tests */
14289                 TEST_CASE_ST(ut_setup, ut_teardown,
14290                         test_null_cipher_only_operation),
14291                 TEST_CASE_ST(ut_setup, ut_teardown,
14292                         test_null_auth_only_operation),
14293                 TEST_CASE_ST(ut_setup, ut_teardown,
14294                         test_null_cipher_auth_operation),
14295                 TEST_CASE_ST(ut_setup, ut_teardown,
14296                         test_null_auth_cipher_operation),
14297
14298                 /** Negative tests */
14299                 TEST_CASE_ST(ut_setup, ut_teardown,
14300                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
14301                 TEST_CASE_ST(ut_setup, ut_teardown,
14302                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14303                 TEST_CASE_ST(ut_setup, ut_teardown,
14304                         authentication_verify_AES128_GMAC_fail_data_corrupt),
14305                 TEST_CASE_ST(ut_setup, ut_teardown,
14306                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
14307                 TEST_CASE_ST(ut_setup, ut_teardown,
14308                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14309                 TEST_CASE_ST(ut_setup, ut_teardown,
14310                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14311                 TEST_CASES_END() /**< NULL terminate unit test array */
14312         }
14313 };
14314
14315 static struct unit_test_suite cryptodev_nitrox_testsuite  = {
14316         .suite_name = "Crypto NITROX Unit Test Suite",
14317         .setup = testsuite_setup,
14318         .teardown = testsuite_teardown,
14319         .unit_test_cases = {
14320                 TEST_CASE_ST(ut_setup, ut_teardown,
14321                              test_device_configure_invalid_dev_id),
14322                 TEST_CASE_ST(ut_setup, ut_teardown,
14323                                 test_device_configure_invalid_queue_pair_ids),
14324                 TEST_CASE_ST(ut_setup, ut_teardown,
14325                              test_AES_chain_nitrox_all),
14326
14327                 TEST_CASES_END() /**< NULL terminate unit test array */
14328         }
14329 };
14330
14331 static struct unit_test_suite cryptodev_octeontx2_testsuite  = {
14332         .suite_name = "Crypto Device OCTEON TX2 Unit Test Suite",
14333         .setup = testsuite_setup,
14334         .teardown = testsuite_teardown,
14335         .unit_test_cases = {
14336                 TEST_CASE_ST(ut_setup, ut_teardown,
14337                         test_AES_chain_octeontx2_all),
14338                 TEST_CASE_ST(ut_setup, ut_teardown,
14339                         test_AES_cipheronly_octeontx2_all),
14340                 TEST_CASE_ST(ut_setup, ut_teardown,
14341                         test_3DES_chain_octeontx2_all),
14342                 TEST_CASE_ST(ut_setup, ut_teardown,
14343                         test_3DES_cipheronly_octeontx2_all),
14344                 TEST_CASE_ST(ut_setup, ut_teardown,
14345                         test_authonly_octeontx2_all),
14346
14347                 /** AES GCM Authenticated Encryption */
14348                 TEST_CASE_ST(ut_setup, ut_teardown,
14349                         test_AES_GCM_authenticated_encryption_test_case_1),
14350                 TEST_CASE_ST(ut_setup, ut_teardown,
14351                         test_AES_GCM_authenticated_encryption_test_case_2),
14352                 TEST_CASE_ST(ut_setup, ut_teardown,
14353                         test_AES_GCM_authenticated_encryption_test_case_3),
14354                 TEST_CASE_ST(ut_setup, ut_teardown,
14355                         test_AES_GCM_authenticated_encryption_test_case_4),
14356                 TEST_CASE_ST(ut_setup, ut_teardown,
14357                         test_AES_GCM_authenticated_encryption_test_case_5),
14358                 TEST_CASE_ST(ut_setup, ut_teardown,
14359                         test_AES_GCM_authenticated_encryption_test_case_6),
14360                 TEST_CASE_ST(ut_setup, ut_teardown,
14361                         test_AES_GCM_authenticated_encryption_test_case_7),
14362
14363                 /** AES GCM Authenticated Decryption */
14364                 TEST_CASE_ST(ut_setup, ut_teardown,
14365                         test_AES_GCM_authenticated_decryption_test_case_1),
14366                 TEST_CASE_ST(ut_setup, ut_teardown,
14367                         test_AES_GCM_authenticated_decryption_test_case_2),
14368                 TEST_CASE_ST(ut_setup, ut_teardown,
14369                         test_AES_GCM_authenticated_decryption_test_case_3),
14370                 TEST_CASE_ST(ut_setup, ut_teardown,
14371                         test_AES_GCM_authenticated_decryption_test_case_4),
14372                 TEST_CASE_ST(ut_setup, ut_teardown,
14373                         test_AES_GCM_authenticated_decryption_test_case_5),
14374                 TEST_CASE_ST(ut_setup, ut_teardown,
14375                         test_AES_GCM_authenticated_decryption_test_case_6),
14376                 TEST_CASE_ST(ut_setup, ut_teardown,
14377                         test_AES_GCM_authenticated_decryption_test_case_7),
14378                 /** AES GMAC Authentication */
14379                 TEST_CASE_ST(ut_setup, ut_teardown,
14380                         test_AES_GMAC_authentication_test_case_1),
14381                 TEST_CASE_ST(ut_setup, ut_teardown,
14382                         test_AES_GMAC_authentication_verify_test_case_1),
14383                 TEST_CASE_ST(ut_setup, ut_teardown,
14384                         test_AES_GMAC_authentication_test_case_2),
14385                 TEST_CASE_ST(ut_setup, ut_teardown,
14386                         test_AES_GMAC_authentication_verify_test_case_2),
14387                 TEST_CASE_ST(ut_setup, ut_teardown,
14388                         test_AES_GMAC_authentication_test_case_3),
14389                 TEST_CASE_ST(ut_setup, ut_teardown,
14390                         test_AES_GMAC_authentication_verify_test_case_3),
14391
14392                 /** SNOW 3G encrypt only (UEA2) */
14393                 TEST_CASE_ST(ut_setup, ut_teardown,
14394                         test_snow3g_encryption_test_case_1),
14395                 TEST_CASE_ST(ut_setup, ut_teardown,
14396                         test_snow3g_encryption_test_case_2),
14397                 TEST_CASE_ST(ut_setup, ut_teardown,
14398                         test_snow3g_encryption_test_case_3),
14399                 TEST_CASE_ST(ut_setup, ut_teardown,
14400                         test_snow3g_encryption_test_case_4),
14401                 TEST_CASE_ST(ut_setup, ut_teardown,
14402                         test_snow3g_encryption_test_case_5),
14403
14404                 TEST_CASE_ST(ut_setup, ut_teardown,
14405                         test_snow3g_encryption_test_case_1_oop),
14406                 TEST_CASE_ST(ut_setup, ut_teardown,
14407                         test_snow3g_decryption_test_case_1_oop),
14408                 TEST_CASE_ST(ut_setup, ut_teardown,
14409                         test_snow3g_encryption_test_case_1_oop_sgl),
14410
14411                 /** SNOW 3G decrypt only (UEA2) */
14412                 TEST_CASE_ST(ut_setup, ut_teardown,
14413                         test_snow3g_decryption_test_case_1),
14414                 TEST_CASE_ST(ut_setup, ut_teardown,
14415                         test_snow3g_decryption_test_case_2),
14416                 TEST_CASE_ST(ut_setup, ut_teardown,
14417                         test_snow3g_decryption_test_case_3),
14418                 TEST_CASE_ST(ut_setup, ut_teardown,
14419                         test_snow3g_decryption_test_case_4),
14420                 TEST_CASE_ST(ut_setup, ut_teardown,
14421                         test_snow3g_decryption_test_case_5),
14422
14423                 TEST_CASE_ST(ut_setup, ut_teardown,
14424                         test_snow3g_hash_generate_test_case_1),
14425                 TEST_CASE_ST(ut_setup, ut_teardown,
14426                         test_snow3g_hash_generate_test_case_2),
14427                 TEST_CASE_ST(ut_setup, ut_teardown,
14428                         test_snow3g_hash_generate_test_case_3),
14429                 TEST_CASE_ST(ut_setup, ut_teardown,
14430                         test_snow3g_hash_verify_test_case_1),
14431                 TEST_CASE_ST(ut_setup, ut_teardown,
14432                         test_snow3g_hash_verify_test_case_2),
14433                 TEST_CASE_ST(ut_setup, ut_teardown,
14434                         test_snow3g_hash_verify_test_case_3),
14435
14436                 /** ZUC encrypt only (EEA3) */
14437                 TEST_CASE_ST(ut_setup, ut_teardown,
14438                         test_zuc_encryption_test_case_1),
14439                 TEST_CASE_ST(ut_setup, ut_teardown,
14440                         test_zuc_encryption_test_case_2),
14441                 TEST_CASE_ST(ut_setup, ut_teardown,
14442                         test_zuc_encryption_test_case_3),
14443                 TEST_CASE_ST(ut_setup, ut_teardown,
14444                         test_zuc_encryption_test_case_4),
14445                 TEST_CASE_ST(ut_setup, ut_teardown,
14446                         test_zuc_encryption_test_case_5),
14447                 TEST_CASE_ST(ut_setup, ut_teardown,
14448                         test_zuc_hash_generate_test_case_1),
14449                 TEST_CASE_ST(ut_setup, ut_teardown,
14450                         test_zuc_hash_generate_test_case_2),
14451                 TEST_CASE_ST(ut_setup, ut_teardown,
14452                         test_zuc_hash_generate_test_case_3),
14453                 TEST_CASE_ST(ut_setup, ut_teardown,
14454                         test_zuc_hash_generate_test_case_4),
14455                 TEST_CASE_ST(ut_setup, ut_teardown,
14456                         test_zuc_hash_generate_test_case_5),
14457                 TEST_CASE_ST(ut_setup, ut_teardown,
14458                         test_zuc_encryption_test_case_6_sgl),
14459
14460                 /** KASUMI encrypt only (UEA1) */
14461                 TEST_CASE_ST(ut_setup, ut_teardown,
14462                         test_kasumi_encryption_test_case_1),
14463                 TEST_CASE_ST(ut_setup, ut_teardown,
14464                         test_kasumi_encryption_test_case_2),
14465                 TEST_CASE_ST(ut_setup, ut_teardown,
14466                         test_kasumi_encryption_test_case_3),
14467                 TEST_CASE_ST(ut_setup, ut_teardown,
14468                         test_kasumi_encryption_test_case_4),
14469                 TEST_CASE_ST(ut_setup, ut_teardown,
14470                         test_kasumi_encryption_test_case_5),
14471                 TEST_CASE_ST(ut_setup, ut_teardown,
14472                         test_kasumi_encryption_test_case_1_sgl),
14473                 TEST_CASE_ST(ut_setup, ut_teardown,
14474                         test_kasumi_encryption_test_case_1_oop_sgl),
14475                 /** KASUMI decrypt only (UEA1) */
14476                 TEST_CASE_ST(ut_setup, ut_teardown,
14477                         test_kasumi_decryption_test_case_1),
14478                 TEST_CASE_ST(ut_setup, ut_teardown,
14479                         test_kasumi_decryption_test_case_2),
14480                 TEST_CASE_ST(ut_setup, ut_teardown,
14481                         test_kasumi_decryption_test_case_3),
14482                 TEST_CASE_ST(ut_setup, ut_teardown,
14483                         test_kasumi_decryption_test_case_4),
14484                 TEST_CASE_ST(ut_setup, ut_teardown,
14485                         test_kasumi_decryption_test_case_5),
14486
14487                 TEST_CASE_ST(ut_setup, ut_teardown,
14488                         test_kasumi_encryption_test_case_1_oop),
14489                 TEST_CASE_ST(ut_setup, ut_teardown,
14490                         test_kasumi_decryption_test_case_1_oop),
14491
14492                 /** KASUMI hash only (UIA1) */
14493                 TEST_CASE_ST(ut_setup, ut_teardown,
14494                         test_kasumi_hash_generate_test_case_1),
14495                 TEST_CASE_ST(ut_setup, ut_teardown,
14496                         test_kasumi_hash_generate_test_case_2),
14497                 TEST_CASE_ST(ut_setup, ut_teardown,
14498                         test_kasumi_hash_generate_test_case_3),
14499                 TEST_CASE_ST(ut_setup, ut_teardown,
14500                         test_kasumi_hash_generate_test_case_4),
14501                 TEST_CASE_ST(ut_setup, ut_teardown,
14502                         test_kasumi_hash_generate_test_case_5),
14503                 TEST_CASE_ST(ut_setup, ut_teardown,
14504                         test_kasumi_hash_generate_test_case_6),
14505                 TEST_CASE_ST(ut_setup, ut_teardown,
14506                         test_kasumi_hash_verify_test_case_1),
14507                 TEST_CASE_ST(ut_setup, ut_teardown,
14508                         test_kasumi_hash_verify_test_case_2),
14509                 TEST_CASE_ST(ut_setup, ut_teardown,
14510                         test_kasumi_hash_verify_test_case_3),
14511                 TEST_CASE_ST(ut_setup, ut_teardown,
14512                         test_kasumi_hash_verify_test_case_4),
14513                 TEST_CASE_ST(ut_setup, ut_teardown,
14514                         test_kasumi_hash_verify_test_case_5),
14515
14516                 /** NULL tests */
14517                 TEST_CASE_ST(ut_setup, ut_teardown,
14518                         test_null_cipher_only_operation),
14519                 TEST_CASE_ST(ut_setup, ut_teardown,
14520                         test_null_auth_only_operation),
14521                 TEST_CASE_ST(ut_setup, ut_teardown,
14522                         test_null_cipher_auth_operation),
14523                 TEST_CASE_ST(ut_setup, ut_teardown,
14524                         test_null_auth_cipher_operation),
14525
14526                 /** Negative tests */
14527                 TEST_CASE_ST(ut_setup, ut_teardown,
14528                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
14529                 TEST_CASE_ST(ut_setup, ut_teardown,
14530                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14531                 TEST_CASE_ST(ut_setup, ut_teardown,
14532                         authentication_verify_AES128_GMAC_fail_data_corrupt),
14533                 TEST_CASE_ST(ut_setup, ut_teardown,
14534                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
14535                 TEST_CASE_ST(ut_setup, ut_teardown,
14536                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14537                 TEST_CASE_ST(ut_setup, ut_teardown,
14538                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14539                 TEST_CASES_END() /**< NULL terminate unit test array */
14540         }
14541 };
14542
14543 static int
14544 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
14545 {
14546         gbl_driver_id = rte_cryptodev_driver_id_get(
14547                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
14548
14549         if (gbl_driver_id == -1) {
14550                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check that both "
14551                 "CONFIG_RTE_LIBRTE_PMD_QAT and CONFIG_RTE_LIBRTE_PMD_QAT_SYM "
14552                 "are enabled in config file to run this testsuite.\n");
14553                 return TEST_SKIPPED;
14554         }
14555
14556         return unit_test_suite_runner(&cryptodev_qat_testsuite);
14557 }
14558
14559 static int
14560 test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
14561 {
14562         gbl_driver_id = rte_cryptodev_driver_id_get(
14563                         RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
14564
14565         if (gbl_driver_id == -1) {
14566                 RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded. Check if "
14567                                 "CONFIG_RTE_LIBRTE_PMD_VIRTIO_CRYPTO is enabled "
14568                                 "in config file to run this testsuite.\n");
14569                 return TEST_FAILED;
14570         }
14571
14572         return unit_test_suite_runner(&cryptodev_virtio_testsuite);
14573 }
14574
14575 static int
14576 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
14577 {
14578         gbl_driver_id = rte_cryptodev_driver_id_get(
14579                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14580
14581         if (gbl_driver_id == -1) {
14582                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
14583                                 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
14584                                 "in config file to run this testsuite.\n");
14585                 return TEST_SKIPPED;
14586         }
14587
14588         return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
14589 }
14590
14591 static int
14592 test_cryptodev_openssl(void)
14593 {
14594         gbl_driver_id = rte_cryptodev_driver_id_get(
14595                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
14596
14597         if (gbl_driver_id == -1) {
14598                 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
14599                                 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
14600                                 "in config file to run this testsuite.\n");
14601                 return TEST_SKIPPED;
14602         }
14603
14604         return unit_test_suite_runner(&cryptodev_openssl_testsuite);
14605 }
14606
14607 static int
14608 test_cryptodev_aesni_gcm(void)
14609 {
14610         gbl_driver_id = rte_cryptodev_driver_id_get(
14611                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
14612
14613         if (gbl_driver_id == -1) {
14614                 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
14615                                 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
14616                                 "in config file to run this testsuite.\n");
14617                 return TEST_SKIPPED;
14618         }
14619
14620         return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
14621 }
14622
14623 static int
14624 test_cryptodev_null(void)
14625 {
14626         gbl_driver_id = rte_cryptodev_driver_id_get(
14627                         RTE_STR(CRYPTODEV_NAME_NULL_PMD));
14628
14629         if (gbl_driver_id == -1) {
14630                 RTE_LOG(ERR, USER1, "NULL PMD must be loaded. Check if "
14631                                 "CONFIG_RTE_LIBRTE_PMD_NULL is enabled "
14632                                 "in config file to run this testsuite.\n");
14633                 return TEST_SKIPPED;
14634         }
14635
14636         return unit_test_suite_runner(&cryptodev_null_testsuite);
14637 }
14638
14639 static int
14640 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
14641 {
14642         gbl_driver_id = rte_cryptodev_driver_id_get(
14643                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
14644
14645         if (gbl_driver_id == -1) {
14646                 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
14647                                 "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
14648                                 "in config file to run this testsuite.\n");
14649                 return TEST_SKIPPED;
14650         }
14651
14652         return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
14653 }
14654
14655 static int
14656 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
14657 {
14658         gbl_driver_id = rte_cryptodev_driver_id_get(
14659                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
14660
14661         if (gbl_driver_id == -1) {
14662                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
14663                                 "CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled "
14664                                 "in config file to run this testsuite.\n");
14665                 return TEST_SKIPPED;
14666         }
14667
14668         return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
14669 }
14670
14671 static int
14672 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
14673 {
14674         gbl_driver_id = rte_cryptodev_driver_id_get(
14675                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
14676
14677         if (gbl_driver_id == -1) {
14678                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
14679                                 "CONFIG_RTE_LIBRTE_PMD_ZUC is enabled "
14680                                 "in config file to run this testsuite.\n");
14681                 return TEST_SKIPPED;
14682         }
14683
14684         return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
14685 }
14686
14687 static int
14688 test_cryptodev_armv8(void)
14689 {
14690         gbl_driver_id = rte_cryptodev_driver_id_get(
14691                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
14692
14693         if (gbl_driver_id == -1) {
14694                 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
14695                                 "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
14696                                 "in config file to run this testsuite.\n");
14697                 return TEST_SKIPPED;
14698         }
14699
14700         return unit_test_suite_runner(&cryptodev_armv8_testsuite);
14701 }
14702
14703 static int
14704 test_cryptodev_mrvl(void)
14705 {
14706         gbl_driver_id = rte_cryptodev_driver_id_get(
14707                         RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
14708
14709         if (gbl_driver_id == -1) {
14710                 RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded. Check if "
14711                                 "CONFIG_RTE_LIBRTE_PMD_MVSAM_CRYPTO is enabled "
14712                                 "in config file to run this testsuite.\n");
14713                 return TEST_SKIPPED;
14714         }
14715
14716         return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
14717 }
14718
14719 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
14720
14721 static int
14722 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
14723 {
14724         gbl_driver_id = rte_cryptodev_driver_id_get(
14725                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14726
14727         if (gbl_driver_id == -1) {
14728                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if "
14729                                 "CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled "
14730                                 "in config file to run this testsuite.\n");
14731                 return TEST_SKIPPED;
14732         }
14733
14734         if (rte_cryptodev_driver_id_get(
14735                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
14736                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
14737                         " enabled in config file to run this testsuite.\n");
14738                 return TEST_SKIPPED;
14739 }
14740         return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
14741 }
14742
14743 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
14744
14745 #endif
14746
14747 static int
14748 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
14749 {
14750         gbl_driver_id = rte_cryptodev_driver_id_get(
14751                         RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
14752
14753         if (gbl_driver_id == -1) {
14754                 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
14755                                 "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
14756                                 "in config file to run this testsuite.\n");
14757                 return TEST_SKIPPED;
14758         }
14759
14760         return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
14761 }
14762
14763 static int
14764 test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
14765 {
14766         gbl_driver_id = rte_cryptodev_driver_id_get(
14767                         RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
14768
14769         if (gbl_driver_id == -1) {
14770                 RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded. Check if "
14771                                 "CONFIG_RTE_LIBRTE_PMD_DPAA_SEC is enabled "
14772                                 "in config file to run this testsuite.\n");
14773                 return TEST_SKIPPED;
14774         }
14775
14776         return unit_test_suite_runner(&cryptodev_dpaa_sec_testsuite);
14777 }
14778
14779 static int
14780 test_cryptodev_ccp(void)
14781 {
14782         gbl_driver_id = rte_cryptodev_driver_id_get(
14783                         RTE_STR(CRYPTODEV_NAME_CCP_PMD));
14784
14785         if (gbl_driver_id == -1) {
14786                 RTE_LOG(ERR, USER1, "CCP PMD must be loaded. Check if "
14787                                 "CONFIG_RTE_LIBRTE_PMD_CCP is enabled "
14788                                 "in config file to run this testsuite.\n");
14789                 return TEST_FAILED;
14790         }
14791
14792         return unit_test_suite_runner(&cryptodev_ccp_testsuite);
14793 }
14794
14795 static int
14796 test_cryptodev_octeontx(void)
14797 {
14798         gbl_driver_id = rte_cryptodev_driver_id_get(
14799                         RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
14800         if (gbl_driver_id == -1) {
14801                 RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded. Check if "
14802                                 "CONFIG_RTE_LIBRTE_PMD_OCTEONTX_CRYPTO is "
14803                                 "enabled in config file to run this "
14804                                 "testsuite.\n");
14805                 return TEST_FAILED;
14806         }
14807         return unit_test_suite_runner(&cryptodev_octeontx_testsuite);
14808 }
14809
14810 static int
14811 test_cryptodev_octeontx2(void)
14812 {
14813         gbl_driver_id = rte_cryptodev_driver_id_get(
14814                         RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
14815         if (gbl_driver_id == -1) {
14816                 RTE_LOG(ERR, USER1, "OCTEON TX2 PMD must be loaded. Check if "
14817                                 "CONFIG_RTE_LIBRTE_PMD_OCTEONTX2_CRYPTO is "
14818                                 "enabled in config file to run this "
14819                                 "testsuite.\n");
14820                 return TEST_FAILED;
14821         }
14822         return unit_test_suite_runner(&cryptodev_octeontx2_testsuite);
14823 }
14824
14825 static int
14826 test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
14827 {
14828         gbl_driver_id = rte_cryptodev_driver_id_get(
14829                         RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
14830
14831         if (gbl_driver_id == -1) {
14832                 RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded. Check if "
14833                                 "CONFIG_RTE_LIBRTE_PMD_CAAM_JR is enabled "
14834                                 "in config file to run this testsuite.\n");
14835                 return TEST_FAILED;
14836         }
14837
14838         return unit_test_suite_runner(&cryptodev_caam_jr_testsuite);
14839 }
14840
14841 static int
14842 test_cryptodev_nitrox(void)
14843 {
14844         gbl_driver_id = rte_cryptodev_driver_id_get(
14845                         RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
14846
14847         if (gbl_driver_id == -1) {
14848                 RTE_LOG(ERR, USER1, "NITROX PMD must be loaded. Check if "
14849                                 "CONFIG_RTE_LIBRTE_PMD_NITROX is enabled "
14850                                 "in config file to run this testsuite.\n");
14851                 return TEST_FAILED;
14852         }
14853
14854         return unit_test_suite_runner(&cryptodev_nitrox_testsuite);
14855 }
14856
14857 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
14858 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
14859 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
14860 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
14861 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
14862 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
14863 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
14864 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
14865 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
14866 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
14867 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
14868 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
14869 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
14870 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
14871 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
14872 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
14873 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
14874 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);