app/test/test_cryptodev.c

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